@layerfi/components 0.1.112 → 0.1.113

package/dist/cjs/index.cjs

@@ -64,13 +64,11 @@ const traditional = require("zustand/traditional");
 const index = require("effect/index");
 const effect = require("effect");
 const useSWRInfinite = require("swr/infinite");
-const _ = require("lodash");
 const useSWRMutation = require("swr/mutation");
 const react$1 = require("@floating-ui/react");
 const lucideReact = require("lucide-react");
 const reactAriaComponents = require("react-aria-components");
 const useResizeObserver = require("@react-hook/resize-observer");
-const reactMergeRefs = require("react-merge-refs");
 const Select$1 = require("react-select");
 const CurrencyInput = require("react-currency-input-field");
 const RDP = require("react-datepicker");
@@ -130,7 +128,7 @@ const LinkedAccountsContext = react.createContext({
   setAccountsToAddOpeningBalanceInModal: () => {
   }
 });
-const version = "0.1.112";
+const version = "0.1.113";
 const pkg = {
   version
 };
@@ -173,7 +171,7 @@ const CUSTOM_PREFIX = "Layer-";
 const CUSTOM_HEADERS = {
   [`${CUSTOM_PREFIX}React-Version`]: pkg.version
 };
-const get = (url) => (baseUrl, accessToken, options2) => () => fetch(`${baseUrl}${url((options2 == null ? void 0 : options2.params) || {})}`, {
+const get$1 = (url) => (baseUrl, accessToken, options2) => () => fetch(`${baseUrl}${url((options2 == null ? void 0 : options2.params) || {})}`, {
   headers: __spreadValues({
     "Authorization": "Bearer " + (accessToken || ""),
     "Content-Type": "application/json"
@@ -278,28 +276,28 @@ function toDefinedSearchParameters(input) {
       return [[key, String(value)]];
     }
     return [[key, value]];
-  }).filter(([_2, value]) => value !== "").map(([key, value]) => [toSnakeCase(key), value]);
+  }).filter(([_, value]) => value !== "").map(([key, value]) => [toSnakeCase(key), value]);
   return new URLSearchParams(definedParameterPairs);
 }
-const getBalanceSheet = get(
+const getBalanceSheet = get$1(
   ({ businessId, effectiveDate }) => {
     const parameters = toDefinedSearchParameters({ effectiveDate });
     return `/v1/businesses/${businessId}/reports/balance-sheet?${parameters}`;
   }
 );
-const getBalanceSheetCSV = get(
+const getBalanceSheetCSV = get$1(
   ({ businessId, effectiveDate }) => {
     const parameters = toDefinedSearchParameters({ effectiveDate });
     return `/v1/businesses/${businessId}/reports/balance-sheet/exports/csv?${parameters}`;
   }
 );
-const getBalanceSheetExcel = get(
+const getBalanceSheetExcel = get$1(
   ({ businessId, effectiveDate }) => {
     const parameters = toDefinedSearchParameters({ effectiveDate });
     return `/v1/businesses/${businessId}/reports/balance-sheet/exports/excel?${parameters}`;
   }
 );
-const getBankTransactions = get(
+const getBankTransactions = get$1(
   ({
     businessId,
     cursor,
@@ -333,7 +331,7 @@ const categorizeBankTransaction = put(
 const matchBankTransaction = put(
   ({ businessId, bankTransactionId }) => `/v1/businesses/${businessId}/bank-transactions/${bankTransactionId}/match`
 );
-const getBankTransactionsExcel = get(({
+const getBankTransactionsExcel = get$1(({
   businessId,
   categorized,
   direction,
@@ -354,16 +352,16 @@ const getBankTransactionsExcel = get(({
   });
   return `/v1/businesses/${businessId}/reports/transactions/exports/excel?${parameters}`;
 });
-const getBankTransactionMetadata = get(
+const getBankTransactionMetadata = get$1(
   ({ businessId, bankTransactionId }) => `/v1/businesses/${businessId}/bank-transactions/${bankTransactionId}/metadata`
 );
 const updateBankTransactionMetadata = put(
   ({ businessId, bankTransactionId }) => `/v1/businesses/${businessId}/bank-transactions/${bankTransactionId}/metadata`
 );
-const listBankTransactionDocuments = get(
+const listBankTransactionDocuments = get$1(
   ({ businessId, bankTransactionId }) => `/v1/businesses/${businessId}/bank-transactions/${bankTransactionId}/documents?content_disposition=ATTACHMENT`
 );
-const getBankTransactionDocument = get(
+const getBankTransactionDocument = get$1(
   ({ businessId, bankTransactionId, documentId }) => `/v1/businesses/${businessId}/bank-transactions/${bankTransactionId}/documents/${documentId}?content_disposition=ATTACHMENT`
 );
 const archiveBankTransactionDocument = post(
@@ -386,10 +384,10 @@ const uploadBankTransactionDocument = (baseUrl, accessToken) => ({
     accessToken
   );
 };
-const getBills = get(
+const getBills = get$1(
   ({ businessId, startDate, endDate, status, vendorId, cursor, limit = 15 }) => `/v1/businesses/${businessId}/bills?${vendorId ? `&vendor_id=${vendorId}` : ""}${cursor ? `&cursor=${cursor}` : ""}${startDate ? `&received_at_start=${startDate}` : ""}${endDate ? `&received_at_end=${endDate}` : ""}${status ? `&status=${status}` : ""}&limit=${limit}&sort_by=received_at&sort_order=DESC`
 );
-const getBill = get(
+const getBill = get$1(
   ({ businessId, billId }) => `/v1/businesses/${businessId}/bills/${billId}`
 );
 const updateBill = post(
@@ -401,7 +399,7 @@ const createBill = post(
 const createBillPayment = post(
   ({ businessId }) => `/v1/businesses/${businessId}/bills/bill-payments`
 );
-const getBusiness = get(({ businessId }) => `/v1/businesses/${businessId}`);
+const getBusiness = get$1(({ businessId }) => `/v1/businesses/${businessId}`);
 const updateBusiness = put(
   ({ businessId }) => `/v1/businesses/${businessId}`
 );
@@ -414,13 +412,13 @@ const updateAccount = put(
 const createChildAccount = post(
   ({ businessId, accountId }) => `/v1/businesses/${businessId}/ledger/accounts/${accountId}/create-child-account`
 );
-const getLedgerAccountsLines = get(
+const getLedgerAccountsLines = get$1(
   ({ businessId, accountId, includeReversals }) => `/v1/businesses/${businessId}/ledger/accounts/${accountId}/lines${includeReversals === "true" ? "?include_reversals=true" : ""}`
 );
-const getLedgerAccountsEntry = get(
+const getLedgerAccountsEntry = get$1(
   ({ businessId, entryId }) => `/v1/businesses/${businessId}/ledger/entries/${entryId}`
 );
-const getLedgerAccountBalancesCSV = get(
+const getLedgerAccountBalancesCSV = get$1(
   ({ businessId }) => `/v1/businesses/${businessId}/ledger/balances/exports/csv`
 );
 const createJournalEntries = post(
@@ -429,7 +427,7 @@ const createJournalEntries = post(
 const reverseJournalEntry = post(
   ({ businessId, entryId }) => `/v1/businesses/${businessId}/ledger/entries/${entryId}/reverse`
 );
-const getJournalEntriesCSV = get(
+const getJournalEntriesCSV = get$1(
   ({ businessId }) => `/v1/businesses/${businessId}/ledger/entries/exports/csv`
 );
 const syncConnection = post(({ businessId }) => `/v1/businesses/${businessId}/sync`);
@@ -439,7 +437,7 @@ const updateConnectionStatus = post(
 const updateOpeningBalance = post(
   ({ businessId, accountId }) => `/v1/businesses/${businessId}/external-accounts/${accountId}/opening-balance`
 );
-const listExternalAccounts = get(({ businessId }) => `/v1/businesses/${businessId}/external-accounts`);
+const listExternalAccounts = get$1(({ businessId }) => `/v1/businesses/${businessId}/external-accounts`);
 const confirmAccount = post(
   ({ businessId, accountId }) => `/v1/businesses/${businessId}/external-accounts/${accountId}/confirm`
 );
@@ -472,13 +470,13 @@ const compareProfitAndLoss = post(
 );
 const getProfitAndLossCsv = (apiUrl, accessToken, params) => {
   const { businessId, startDate, endDate, month, year, tagKey, tagValues, reportingBasis, moneyFormat } = params;
-  return get(
+  return get$1(
     ({ businessId: businessId2 }) => `/v1/businesses/${businessId2}/reports/profit-and-loss/exports/csv?${startDate ? `start_date=${encodeURIComponent(toLocalDateString(startDate))}` : ""}${endDate ? `&end_date=${encodeURIComponent(toLocalDateString(endDate))}` : ""}${month ? `&month=${month}` : ""}${year ? `&year=${year}` : ""}${reportingBasis ? `&reporting_basis=${reportingBasis}` : ""}${tagKey ? `&tag_key=${tagKey}` : ""}${tagValues ? `&tag_values=${tagValues}` : ""}${moneyFormat ? `&money_format=${moneyFormat}` : ""}`
   )(apiUrl, accessToken, { params: { businessId } });
 };
 const getProfitAndLossExcel = (apiUrl, accessToken, params) => {
   const { businessId, startDate, endDate, month, year, tagKey, tagValues, reportingBasis, moneyFormat } = params;
-  return get(
+  return get$1(
     ({ businessId: businessId2 }) => `/v1/businesses/${businessId2}/reports/profit-and-loss/exports/excel?${startDate ? `start_date=${encodeURIComponent(toLocalDateString(startDate))}` : ""}${endDate ? `&end_date=${encodeURIComponent(toLocalDateString(endDate))}` : ""}${month ? `&month=${month}` : ""}${year ? `&year=${year}` : ""}${reportingBasis ? `&reporting_basis=${reportingBasis}` : ""}${tagKey ? `&tag_key=${tagKey}` : ""}${tagValues ? `&tag_values=${tagValues}` : ""}${moneyFormat ? `&money_format=${moneyFormat}` : ""}`
   )(apiUrl, accessToken, { params: { businessId } });
 };
@@ -488,22 +486,22 @@ const profitAndLossComparisonCsv = post(
 const syncFromQuickbooks = post(({ businessId }) => `/v1/businesses/${businessId}/quickbooks/sync-from`);
 const initQuickbooksOAuth = post(({ businessId }) => `/v1/businesses/${businessId}/quickbooks/authorize`);
 const unlinkQuickbooksConnection = post(({ businessId }) => `/v1/businesses/${businessId}/quickbooks/unlink`);
-const statusOfQuickbooksConnection = get(
+const statusOfQuickbooksConnection = get$1(
   ({ businessId }) => `/v1/businesses/${businessId}/quickbooks/connection-status`
 );
-const getStatementOfCashFlow = get(
+const getStatementOfCashFlow = get$1(
   ({ businessId, startDate, endDate }) => {
     const parameters = toDefinedSearchParameters({ startDate, endDate });
     return `/v1/businesses/${businessId}/reports/cashflow-statement?${parameters}`;
   }
 );
-const getCashflowStatementCSV = get(
+const getCashflowStatementCSV = get$1(
   ({ businessId, startDate, endDate }) => {
     const parameters = toDefinedSearchParameters({ startDate, endDate });
     return `/v1/businesses/${businessId}/reports/cashflow-statement/exports/csv?${parameters}`;
   }
 );
-const getVendors = get(
+const getVendors = get$1(
   ({ businessId }) => `/v1/businesses/${businessId}/vendors`
 );
 const Layer = {
@@ -1409,36 +1407,36 @@ function withCorrectedRange(fn) {
   };
 }
 function buildStore$2() {
-  const now = /* @__PURE__ */ new Date();
+  const now2 = /* @__PURE__ */ new Date();
   return zustand.createStore((set) => {
-    const apply = (next) => {
+    const apply2 = (next) => {
       set(next);
       return next;
     };
     const setDate = ({ date: date2 }) => {
       const s = RANGE_MODE_LOOKUP.dayPicker.getStartDate({ startDate: date2 });
       const e = RANGE_MODE_LOOKUP.dayPicker.getEndDate({ endDate: date2 });
-      return apply({ startDate: s, endDate: e });
+      return apply2({ startDate: s, endDate: e });
     };
     const setDateRange = withCorrectedRange(({ startDate, endDate }) => {
       const s = RANGE_MODE_LOOKUP.dayRangePicker.getStartDate({ startDate });
       const e = RANGE_MODE_LOOKUP.dayRangePicker.getEndDate({ endDate });
-      return apply({ startDate: s, endDate: e });
+      return apply2({ startDate: s, endDate: e });
     });
     const setMonth = ({ startDate }) => {
       const s = RANGE_MODE_LOOKUP.monthPicker.getStartDate({ startDate });
       const e = RANGE_MODE_LOOKUP.monthPicker.getEndDate({ endDate: startDate });
-      return apply({ startDate: s, endDate: e });
+      return apply2({ startDate: s, endDate: e });
     };
     const setMonthRange = withCorrectedRange(({ startDate, endDate }) => {
       const s = RANGE_MODE_LOOKUP.monthRangePicker.getStartDate({ startDate });
       const e = RANGE_MODE_LOOKUP.monthRangePicker.getEndDate({ endDate });
-      return apply({ startDate: s, endDate: e });
+      return apply2({ startDate: s, endDate: e });
     });
     const setYear = ({ startDate }) => {
       const s = RANGE_MODE_LOOKUP.yearPicker.getStartDate({ startDate });
       const e = RANGE_MODE_LOOKUP.yearPicker.getEndDate({ endDate: startDate });
-      return apply({ startDate: s, endDate: e });
+      return apply2({ startDate: s, endDate: e });
     };
     const setRangeWithExplicitDisplayMode = ({
       startDate,
@@ -1463,8 +1461,8 @@ function buildStore$2() {
       }
     };
     return {
-      startDate: dateFns.startOfMonth(now),
-      endDate: clampToPresentOrPast(dateFns.endOfMonth(now)),
+      startDate: dateFns.startOfMonth(now2),
+      endDate: clampToPresentOrPast(dateFns.endOfMonth(now2)),
       actions: {
         setDate,
         setRangeWithExplicitDisplayMode,
@@ -2932,6 +2930,1456 @@ function useGlobalCacheActions() {
     forceReload
   }), [invalidate, patchCache, optimisticUpdate, forceReload]);
 }
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function("return this")();
+var Symbol$1 = root.Symbol;
+var objectProto$e = Object.prototype;
+var hasOwnProperty$b = objectProto$e.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$e.toString;
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty$b.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var objectProto$d = Object.prototype;
+var nativeObjectToString = objectProto$d.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var symbolTag$1 = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$1;
+}
+function arrayMap(array, iteratee) {
+  var index2 = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index2 < length) {
+    result[index2] = iteratee(array[index2], index2, array);
+  }
+  return result;
+}
+var isArray = Array.isArray;
+var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto$1 ? symbolProto$1.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray(value)) {
+    return arrayMap(value, baseToString) + "";
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
+}
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index2 = string.length;
+  while (index2-- && reWhitespace.test(string.charAt(index2))) {
+  }
+  return index2;
+}
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+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 = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+function identity(value) {
+  return value;
+}
+var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var coreJsData = root["__core-js_shared__"];
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var funcProto$2 = Function.prototype;
+var funcToString$2 = funcProto$2.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$2.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto$1 = Function.prototype, objectProto$c = Object.prototype;
+var funcToString$1 = funcProto$1.toString;
+var hasOwnProperty$a = objectProto$c.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString$1.call(hasOwnProperty$a).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var WeakMap$1 = getNative(root, "WeakMap");
+var objectCreate = Object.create;
+var baseCreate = /* @__PURE__ */ function() {
+  function object() {
+  }
+  return function(proto) {
+    if (!isObject(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = void 0;
+    return result;
+  };
+}();
+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);
+}
+function noop() {
+}
+function copyArray(source, array) {
+  var index2 = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index2 < length) {
+    array[index2] = source[index2];
+  }
+  return array;
+}
+var HOT_COUNT = 800, HOT_SPAN = 16;
+var nativeNow = Date.now;
+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(void 0, arguments);
+  };
+}
+function constant(value) {
+  return function() {
+    return value;
+  };
+}
+var defineProperty = function() {
+  try {
+    var func = getNative(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+}();
+var baseSetToString = !defineProperty ? identity : function(func, string) {
+  return defineProperty(func, "toString", {
+    "configurable": true,
+    "enumerable": false,
+    "value": constant(string),
+    "writable": true
+  });
+};
+var setToString = shortOut(baseSetToString);
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+  var length = array.length, index2 = fromIndex + -1;
+  while (++index2 < length) {
+    if (predicate(array[index2], index2, array)) {
+      return index2;
+    }
+  }
+  return -1;
+}
+function baseIsNaN(value) {
+  return value !== value;
+}
+function strictIndexOf(array, value, fromIndex) {
+  var index2 = fromIndex - 1, length = array.length;
+  while (++index2 < length) {
+    if (array[index2] === value) {
+      return index2;
+    }
+  }
+  return -1;
+}
+function baseIndexOf(array, value, fromIndex) {
+  return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
+}
+function arrayIncludes(array, value) {
+  var length = array == null ? 0 : array.length;
+  return !!length && baseIndexOf(array, value, 0) > -1;
+}
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && defineProperty) {
+    defineProperty(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var objectProto$b = Object.prototype;
+var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty$9.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue(object, key, value);
+  }
+}
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  var index2 = -1, length = props.length;
+  while (++index2 < length) {
+    var key = props[index2];
+    var newValue = void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue(object, key, newValue);
+    }
+  }
+  return object;
+}
+var nativeMax$1 = Math.max;
+function overRest(func, start, transform) {
+  start = nativeMax$1(start === void 0 ? func.length - 1 : start, 0);
+  return function() {
+    var args = arguments, index2 = -1, length = nativeMax$1(args.length - start, 0), array = Array(length);
+    while (++index2 < length) {
+      array[index2] = args[start + index2];
+    }
+    index2 = -1;
+    var otherArgs = Array(start + 1);
+    while (++index2 < start) {
+      otherArgs[index2] = args[index2];
+    }
+    otherArgs[start] = transform(array);
+    return apply(func, this, otherArgs);
+  };
+}
+function baseRest(func, start) {
+  return setToString(overRest(func, start, identity), func + "");
+}
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+function isIterateeCall(value, index2, object) {
+  if (!isObject(object)) {
+    return false;
+  }
+  var type = typeof index2;
+  if (type == "number" ? isArrayLike(object) && isIndex(index2, object.length) : type == "string" && index2 in object) {
+    return eq(object[index2], value);
+  }
+  return false;
+}
+function createAssigner(assigner) {
+  return baseRest(function(object, sources) {
+    var index2 = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
+    customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? void 0 : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index2 < length) {
+      var source = sources[index2];
+      if (source) {
+        assigner(object, source, index2, customizer);
+      }
+    }
+    return object;
+  });
+}
+var objectProto$a = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$a;
+  return value === proto;
+}
+function baseTimes(n, iteratee) {
+  var index2 = -1, result = Array(n);
+  while (++index2 < n) {
+    result[index2] = iteratee(index2);
+  }
+  return result;
+}
+var argsTag$2 = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag$2;
+}
+var objectProto$9 = Object.prototype;
+var hasOwnProperty$8 = objectProto$9.hasOwnProperty;
+var propertyIsEnumerable$1 = objectProto$9.propertyIsEnumerable;
+var isArguments = baseIsArguments(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty$8.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
+};
+function stubFalse() {
+  return false;
+}
+var freeExports$2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$2 = freeExports$2 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2;
+var Buffer$1 = moduleExports$2 ? root.Buffer : void 0;
+var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", funcTag = "[object Function]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", objectTag$3 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", weakMapTag$1 = "[object WeakMap]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$2 = "[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]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] = typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag] = typedArrayTags[mapTag$2] = typedArrayTags[numberTag$1] = typedArrayTags[objectTag$3] = typedArrayTags[regexpTag$1] = typedArrayTags[setTag$2] = typedArrayTags[stringTag$1] = typedArrayTags[weakMapTag$1] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+var freeProcess = moduleExports$1 && freeGlobal.process;
+var nodeUtil = function() {
+  try {
+    var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+}();
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+var objectProto$8 = Object.prototype;
+var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
+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$7.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;
+}
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var nativeKeys = overArg(Object.keys, Object);
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$6.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var objectProto$6 = Object.prototype;
+var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+function baseKeysIn(object) {
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty$5.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function keysIn(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+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);
+}
+var nativeCreate = getNative(Object, "create");
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.size = 0;
+}
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? void 0 : result;
+  }
+  return hasOwnProperty$4.call(data, key) ? data[key] : void 0;
+}
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? data[key] !== void 0 : hasOwnProperty$3.call(data, key);
+}
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+function Hash(entries) {
+  var index2 = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index2 < length) {
+    var entry = entries[index2];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear;
+Hash.prototype["delete"] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index2 = assocIndexOf(data, key);
+  if (index2 < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index2 == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index2, 1);
+  }
+  --this.size;
+  return true;
+}
+function listCacheGet(key) {
+  var data = this.__data__, index2 = assocIndexOf(data, key);
+  return index2 < 0 ? void 0 : data[index2][1];
+}
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+function listCacheSet(key, value) {
+  var data = this.__data__, index2 = assocIndexOf(data, key);
+  if (index2 < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index2][1] = value;
+  }
+  return this;
+}
+function ListCache(entries) {
+  var index2 = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index2 < length) {
+    var entry = entries[index2];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype["delete"] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+var Map$1 = getNative(root, "Map");
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$1 || ListCache)(),
+    "string": new Hash()
+  };
+}
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+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;
+}
+function MapCache(entries) {
+  var index2 = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index2 < length) {
+    var entry = entries[index2];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype["delete"] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+var FUNC_ERROR_TEXT$1 = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT$1);
+  }
+  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;
+}
+memoize.Cache = MapCache;
+var MAX_MEMOIZE_SIZE = 500;
+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;
+}
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+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;
+});
+function toString(value) {
+  return value == null ? "" : baseToString(value);
+}
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+function toKey(value) {
+  if (typeof value == "string" || isSymbol(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
+}
+function baseGet(object, path) {
+  path = castPath(path, object);
+  var index2 = 0, length = path.length;
+  while (object != null && index2 < length) {
+    object = object[toKey(path[index2++])];
+  }
+  return index2 && index2 == length ? object : void 0;
+}
+function get(object, path, defaultValue2) {
+  var result = object == null ? void 0 : baseGet(object, path);
+  return result === void 0 ? defaultValue2 : result;
+}
+function arrayPush(array, values) {
+  var index2 = -1, length = values.length, offset = array.length;
+  while (++index2 < length) {
+    array[offset + index2] = values[index2];
+  }
+  return array;
+}
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+var objectTag$2 = "[object Object]";
+var funcProto = Function.prototype, objectProto$3 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+var objectCtorString = funcToString.call(Object);
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) != objectTag$2) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty$2.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+}
+function stackClear() {
+  this.__data__ = new ListCache();
+  this.size = 0;
+}
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var LARGE_ARRAY_SIZE$1 = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE$1 - 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;
+}
+function Stack$1(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack$1.prototype.clear = stackClear;
+Stack$1.prototype["delete"] = stackDelete;
+Stack$1.prototype.get = stackGet;
+Stack$1.prototype.has = stackHas;
+Stack$1.prototype.set = stackSet;
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer2 = moduleExports ? root.Buffer : void 0;
+Buffer2 ? Buffer2.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  {
+    return buffer.slice();
+  }
+}
+function arrayFilter(array, predicate) {
+  var index2 = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index2 < length) {
+    var value = array[index2];
+    if (predicate(value, index2, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+function stubArray() {
+  return [];
+}
+var objectProto$2 = Object.prototype;
+var propertyIsEnumerable = objectProto$2.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+var DataView = getNative(root, "DataView");
+var Promise$1 = getNative(root, "Promise");
+var Set$1 = getNative(root, "Set");
+var mapTag$1 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$1 = "[object Set]", weakMapTag = "[object WeakMap]";
+var dataViewTag$1 = "[object DataView]";
+var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap$1);
+var getTag$1 = baseGetTag;
+if (DataView && getTag$1(new DataView(new ArrayBuffer(1))) != dataViewTag$1 || Map$1 && getTag$1(new Map$1()) != mapTag$1 || Promise$1 && getTag$1(Promise$1.resolve()) != promiseTag || Set$1 && getTag$1(new Set$1()) != setTag$1 || WeakMap$1 && getTag$1(new WeakMap$1()) != weakMapTag) {
+  getTag$1 = function(value) {
+    var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag$1;
+        case mapCtorString:
+          return mapTag$1;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag$1;
+        case weakMapCtorString:
+          return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+var Uint8Array2 = root.Uint8Array;
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array2(result).set(new Uint8Array2(arrayBuffer));
+  return result;
+}
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = cloneArrayBuffer(typedArray.buffer);
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+function initCloneObject(object) {
+  return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+}
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+function SetCache(values) {
+  var index2 = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache();
+  while (++index2 < length) {
+    this.add(values[index2]);
+  }
+}
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+function arraySome(array, predicate) {
+  var index2 = -1, length = array == null ? 0 : array.length;
+  while (++index2 < length) {
+    if (predicate(array[index2], index2, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index2 = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index2 < arrLength) {
+    var arrValue = array[index2], othValue = other[index2];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index2, other, array, stack) : customizer(arrValue, othValue, index2, array, other, stack);
+    }
+    if (compared !== void 0) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome(other, function(othValue2, othIndex) {
+        if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, 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;
+}
+function mapToArray(map) {
+  var index2 = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index2] = [key, value];
+  });
+  return result;
+}
+function setToArray(set) {
+  var index2 = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index2] = value;
+  });
+  return result;
+}
+var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 2;
+var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]";
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+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 Uint8Array2(object), new Uint8Array2(other))) {
+        return false;
+      }
+      return true;
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      return eq(+object, +other);
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag:
+    case stringTag:
+      return object == other + "";
+    case mapTag:
+      var convert = mapToArray;
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+      convert || (convert = setToArray);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG$2;
+      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;
+}
+var COMPARE_PARTIAL_FLAG$3 = 1;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index2 = objLength;
+  while (index2--) {
+    var key = objProps[index2];
+    if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
+      return false;
+    }
+  }
+  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 (++index2 < objLength) {
+    key = objProps[index2];
+    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);
+    }
+    if (!(compared === void 0 ? 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;
+    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;
+}
+var COMPARE_PARTIAL_FLAG$2 = 1;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag$1(object), othTag = othIsArr ? arrayTag : getTag$1(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$1());
+    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
+    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$1());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack$1());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+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);
+}
+var COMPARE_PARTIAL_FLAG$1 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+  var index2 = matchData.length, length = index2;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index2--) {
+    var data = matchData[index2];
+    if (data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+      return false;
+    }
+  }
+  while (++index2 < length) {
+    data = matchData[index2];
+    var key = data[0], objValue = object[key], srcValue = data[1];
+    if (data[2]) {
+      if (objValue === void 0 && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack$1();
+      var result;
+      if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isStrictComparable(value) {
+  return value === value && !isObject(value);
+}
+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;
+}
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+  };
+}
+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);
+  };
+}
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+function hasPath(object, path, hasFunc) {
+  path = castPath(path, object);
+  var index2 = -1, length = path.length, result = false;
+  while (++index2 < length) {
+    var key = toKey(path[index2]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index2 != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+}
+function hasIn(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? void 0 : object[key];
+  };
+}
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+function property(path) {
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+function baseIteratee(value) {
+  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);
+}
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index2 = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+    while (length--) {
+      var key = props[++index2];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+var baseFor = createBaseFor();
+var now = function() {
+  return root.Date.now();
+};
+var FUNC_ERROR_TEXT = "Expected a function";
+var nativeMax = Math.max, nativeMin = Math.min;
+function debounce(func, wait, options2) {
+  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(options2)) {
+    leading = !!options2.leading;
+    maxing = "maxWait" in options2;
+    maxWait = maxing ? nativeMax(toNumber(options2.maxWait) || 0, wait) : maxWait;
+    trailing = "trailing" in options2 ? !!options2.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    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;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now());
+  }
+  function debounced() {
+    var time = now(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+function assignMergeValue(object, key, value) {
+  if (value !== void 0 && !eq(object[key], value) || value === void 0 && !(key in object)) {
+    baseAssignValue(object, key, value);
+  }
+}
+function isArrayLikeObject(value) {
+  return isObjectLike(value) && isArrayLike(value);
+}
+function safeGet(object, key) {
+  if (key === "constructor" && typeof object[key] === "function") {
+    return;
+  }
+  if (key == "__proto__") {
+    return;
+  }
+  return object[key];
+}
+function toPlainObject(value) {
+  return copyObject(value, keysIn(value));
+}
+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) : void 0;
+  var isCommon = newValue === void 0;
+  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);
+      } else if (isTyped) {
+        isCommon = false;
+        newValue = cloneTypedArray(srcValue);
+      } 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) {
+    stack.set(srcValue, newValue);
+    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack["delete"](srcValue);
+  }
+  assignMergeValue(object, key, newValue);
+}
+function baseMerge(object, source, srcIndex, customizer, stack) {
+  if (object === source) {
+    return;
+  }
+  baseFor(source, function(srcValue, key) {
+    stack || (stack = new Stack$1());
+    if (isObject(srcValue)) {
+      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+    } else {
+      var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
+      if (newValue === void 0) {
+        newValue = srcValue;
+      }
+      assignMergeValue(object, key, newValue);
+    }
+  }, keysIn);
+}
+var merge = createAssigner(function(object, source, srcIndex) {
+  baseMerge(object, source, srcIndex);
+});
+var INFINITY = 1 / 0;
+var createSet = !(Set$1 && 1 / setToArray(new Set$1([, -0]))[1] == INFINITY) ? noop : function(values) {
+  return new Set$1(values);
+};
+var LARGE_ARRAY_SIZE = 200;
+function baseUniq(array, iteratee, comparator) {
+  var index2 = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
+  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 (++index2 < length) {
+      var value = array[index2], computed = iteratee ? iteratee(value) : value;
+      value = 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;
+}
+function uniqBy(array, iteratee) {
+  return array && array.length ? baseUniq(array, baseIteratee(iteratee)) : [];
+}
+var idCounter = 0;
+function uniqueId(prefix) {
+  var id = ++idCounter;
+  return toString(prefix) + id;
+}
 const BANK_TRANSACTIONS_TAG_KEY = "#bank-transactions";
 function keyLoader$8(previousPageData, {
   access_token: accessToken,
@@ -3038,7 +4486,7 @@ const useBankTransactionsGlobalCacheActions = () => {
     [invalidate]
   );
   const debouncedInvalidateBankTransactions = react.useMemo(
-    () => _.debounce(
+    () => debounce(
       invalidateBankTransactions,
       INVALIDATION_DEBOUNCE_OPTIONS$2.wait,
       {
@@ -3073,7 +4521,7 @@ const useBankTransactionsGlobalCacheActions = () => {
   };
 };
 const BANK_ACCOUNTS_TAG_KEY = "#bank-accounts";
-const getBankAccounts = get(
+const getBankAccounts = get$1(
   ({ businessId }) => `/v1/businesses/${businessId}/bank-accounts`
 );
 function buildKey$X({
@@ -4486,7 +5934,7 @@ function usePnlDetailLinesInvalidator() {
     [invalidate]
   );
   const debouncedInvalidatePnlDetailLines = react.useMemo(
-    () => _.debounce(
+    () => debounce(
       invalidatePnlDetailLines,
       INVALIDATION_DEBOUNCE_OPTIONS$1.wait,
       {
@@ -4512,7 +5960,7 @@ const getProfitAndLossDetailLines = (apiUrl, accessToken, params) => {
     tagValues,
     pnlStructure
   });
-  return get(
+  return get$1(
     ({ businessId: businessId2 }) => `/v1/businesses/${businessId2}/reports/profit-and-loss/lines?${queryParams.toString()}`
   )(apiUrl, accessToken, { params: { businessId } });
 };
@@ -4564,7 +6012,7 @@ function buildKey$W({
     };
   }
 }
-const getProfitAndLoss = get(
+const getProfitAndLoss = get$1(
   ({
     businessId,
     startDate,
@@ -4614,7 +6062,7 @@ const useProfitAndLossReportCacheActions = () => {
     [invalidate]
   );
   const debouncedInvalidateProfitAndLossReport = react.useMemo(
-    () => _.debounce(
+    () => debounce(
       invalidateProfitAndLossReport,
       INVALIDATE_DEBOUNCE_OPTIONS$2.wait,
       {
@@ -4676,7 +6124,7 @@ function buildKey$V({
     };
   }
 }
-const getProfitAndLossSummaries = get(
+const getProfitAndLossSummaries = get$1(
   ({
     businessId,
     startYear,
@@ -4728,7 +6176,7 @@ const useProfitAndLossSummariesCacheActions = () => {
     [invalidate]
   );
   const debouncedInvalidateProfitAndLossSummaries = react.useMemo(
-    () => _.debounce(
+    () => debounce(
       invalidateProfitAndLossSummaries,
       INVALIDATE_DEBOUNCE_OPTIONS$1.wait,
       {
@@ -4752,7 +6200,7 @@ const useProfitAndLossGlobalInvalidator = () => {
     yield invalidateProfitAndLossSummaries();
   }), [invalidateProfitAndLossReport, invalidateProfitAndLossSummaries]);
   const debouncedInvalidateProfitAndLoss = react.useMemo(
-    () => _.debounce(
+    () => debounce(
       invalidateProfitAndLossReport,
       INVALIDATE_DEBOUNCE_OPTIONS.wait,
       {
@@ -5192,7 +6640,7 @@ const useAugmentedBankTransactions = (params) => {
       }
     };
   }, [anyAccountSyncing, transactionsNotSynced, pollIntervalMs]);
-  useTriggerOnChange(data, anyAccountSyncing, (_2) => {
+  useTriggerOnChange(data, anyAccountSyncing, (_) => {
     var _a2;
     clearInterval(intervalIdRef.current);
     setPollIntervalMs(POLL_INTERVAL_AFTER_TXNS_RECEIVED_MS);
@@ -7621,7 +9069,7 @@ function useTruncationDetection(elementRef, options2 = {
   }, [elementRef, checkFirstChild, ...dependencies]);
   const DEBOUNCE_TIME_IN_MS = 450;
   const debouncedCheckTruncation = react.useMemo(
-    () => _.debounce(checkTruncation, DEBOUNCE_TIME_IN_MS),
+    () => debounce(checkTruncation, DEBOUNCE_TIME_IN_MS),
     [checkTruncation]
   );
   useResizeObserver(elementRef, debouncedCheckTruncation);
@@ -7631,6 +9079,32 @@ function useTruncationDetection(elementRef, options2 = {
   }, [checkTruncation]);
   return isTruncated;
 }
+function mergeRefsReact16(refs) {
+  return (value) => {
+    for (const ref of refs) assignRef(ref, value);
+  };
+}
+function mergeRefsReact19(refs) {
+  return (value) => {
+    const cleanups = [];
+    for (const ref of refs) {
+      const cleanup = assignRef(ref, value);
+      const isCleanup = typeof cleanup === "function";
+      cleanups.push(isCleanup ? cleanup : () => assignRef(ref, null));
+    }
+    return () => {
+      for (const cleanup of cleanups) cleanup();
+    };
+  };
+}
+function assignRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+}
+var mergeRefs = parseInt(react.version.split(".")[0], 10) >= 19 ? mergeRefsReact19 : mergeRefsReact16;
 const CLASS_NAME$d = "Layer__Stack";
 const Stack = react.forwardRef(
   function Stack2(_na, ref) {
@@ -7841,7 +9315,7 @@ const Span = react.forwardRef(
     const { className, tooltipContentWidth = "md" } = props;
     const internalRef = react.useRef(null);
     const isTruncated = useTruncationDetection(internalRef, { checkFirstChild: true });
-    const mergedRef = reactMergeRefs.mergeRefs([internalRef, forwardedRef]);
+    const mergedRef = mergeRefs([internalRef, forwardedRef]);
     if (props.withTooltip) {
       const dataPropertiesWithEllipsis = __spreadProps(__spreadValues({}, dataProperties), { "data-with-tooltip": true });
       return /* @__PURE__ */ jsxRuntime.jsxs(Tooltip, { disabled: !isTruncated, children: [
@@ -10988,7 +12462,7 @@ function buildKey$Q({
     };
   }
 }
-const getTagDimensionByKey = get(({ businessId, dimensionKey }) => `/v1/businesses/${businessId}/tags/dimensions/key/${dimensionKey}`);
+const getTagDimensionByKey = get$1(({ businessId, dimensionKey }) => `/v1/businesses/${businessId}/tags/dimensions/key/${dimensionKey}`);
 class TagDimensionByKeySWRResponse {
   constructor(swrResponse) {
     __publicField(this, "swrResponse");
@@ -11201,7 +12675,7 @@ const ListCustomersRawResultSchema = effect.Schema.Struct({
     })
   })
 });
-const listCustomers = get(({
+const listCustomers = get$1(({
   businessId,
   cursor,
   limit,
@@ -11309,7 +12783,7 @@ const ListVendorsRawResultSchema = effect.Schema.Struct({
     })
   })
 });
-const listVendors = get(({
+const listVendors = get$1(({
   businessId,
   cursor,
   limit,
@@ -11416,7 +12890,7 @@ function useDebounce(fn) {
     const internalFn = (...args) => {
       internalFnRef.current(...args);
     };
-    return _.debounce(
+    return debounce(
       internalFn,
       DEFAULT_WAIT,
       { maxWait: DEFAULT_MAX_WAIT }
@@ -11682,8 +13156,8 @@ function useTagBankTransaction({ bankTransactionId }) {
       const optimisticTagId = uuid.v4();
       void optimisticallyUpdateBankTransactions((bankTransaction) => {
         if (bankTransaction.id === bankTransactionId) {
-          const now = /* @__PURE__ */ new Date();
-          const nowISOString = now.toISOString();
+          const now2 = /* @__PURE__ */ new Date();
+          const nowISOString = now2.toISOString();
           return __spreadProps(__spreadValues({}, bankTransaction), {
             transaction_tags: [
               ...bankTransaction.transaction_tags,
@@ -11809,7 +13283,7 @@ function useRemoveTagFromBankTransaction({ bankTransactionId }) {
 }
 const range$1 = (start, end) => {
   const length = end - start + 1;
-  return Array.from({ length }, (_2, idx) => idx + start);
+  return Array.from({ length }, (_, idx) => idx + start);
 };
 const sleep = (time) => {
   return new Promise((resolve) => setTimeout(resolve, time));
@@ -11990,7 +13464,7 @@ function constrainToKnownBookkeepingStatus(status) {
   }
   return "NOT_PURCHASED";
 }
-const getBookkeepingStatus = get(({ businessId }) => {
+const getBookkeepingStatus = get$1(({ businessId }) => {
   return `/v1/businesses/${businessId}/bookkeeping/status`;
 });
 const BOOKKEEPING_TAG_KEY = "#bookkeeping";
@@ -13048,7 +14522,7 @@ function buildKey$J({
     };
   }
 }
-const getCategories = get(({ businessId, mode }) => {
+const getCategories = get$1(({ businessId, mode }) => {
   const parameters = toDefinedSearchParameters({ mode });
   return `/v1/businesses/${businessId}/categories?${parameters}`;
 });
@@ -13419,7 +14893,7 @@ const isSplitsValid = (localSplits) => {
   return validateSplit(localSplits).reduce((acc, splitError) => acc && splitError === void 0, true);
 };
 const getSplitsErrorMessage = (localSplits) => {
-  return _.uniqBy(validateSplit(localSplits), (error) => error == null ? void 0 : error.toString()).filter(Boolean)[0] || "";
+  return uniqBy(validateSplit(localSplits), (error) => error == null ? void 0 : error.toString()).filter(Boolean)[0] || "";
 };
 const validateSplit = (localSplits) => {
   const errors = localSplits.map((split) => {
@@ -13431,7 +14905,7 @@ const validateSplit = (localSplits) => {
     }
     return void 0;
   });
-  return _.uniqBy(errors, (error) => error == null ? void 0 : error.toString());
+  return uniqBy(errors, (error) => error == null ? void 0 : error.toString());
 };
 const calculateAddSplit = (initialRowSplits) => {
   const newSplit = {
@@ -14078,7 +15552,7 @@ function constrainToKnownBookkeepingPeriodStatus(status) {
   }
   return "BOOKKEEPING_NOT_ACTIVE";
 }
-const getBookkeepingPeriods = get(({ businessId }) => {
+const getBookkeepingPeriods = get$1(({ businessId }) => {
   return `/v1/businesses/${businessId}/bookkeeping/periods`;
 });
 const BOOKKEEPING_PERIODS_TAG_KEY = "#bookkeeping-periods";
@@ -14242,7 +15716,7 @@ const BookkeepingStatus$1 = ({ status, text, monthNumber, iconOnly }) => {
     )
   ] }));
 };
-const BankTransactionProcessingInfo = () => /* @__PURE__ */ jsxRuntime.jsxs(DeprecatedTooltip, { offset: 12, children: [
+const BankTransactionsProcessingInfo = () => /* @__PURE__ */ jsxRuntime.jsxs(DeprecatedTooltip, { offset: 12, children: [
   /* @__PURE__ */ jsxRuntime.jsx(DeprecatedTooltipTrigger, { children: /* @__PURE__ */ jsxRuntime.jsx(BookkeepingStatus$1, { status: BookkeepingPeriodStatus.IN_PROGRESS_AWAITING_BOOKKEEPER, text: "Processing" }) }),
   /* @__PURE__ */ jsxRuntime.jsx(DeprecatedTooltipContent, { className: "Layer__tooltip", width: "md", children: "Our team will review and categorize this transaction. We'll reach out if we have any questions about it." })
 ] });
@@ -14393,9 +15867,10 @@ const BankTransactionRow = ({
     () => toDataProperties({ "show-receipt-upload-column": showReceiptUploadColumn }),
     [showReceiptUploadColumn]
   );
+  const colSpan = categorizationEnabled ? 7 : 6;
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsxs("tr", { className: rowClassName, children: [
-      /* @__PURE__ */ jsxRuntime.jsx("td", { className: "Layer__table-cell Layer__bank-transactions__checkbox-col", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "Layer__table-cell-content", children: /* @__PURE__ */ jsxRuntime.jsx(
+      categorizationEnabled && /* @__PURE__ */ jsxRuntime.jsx("td", { className: "Layer__table-cell Layer__bank-transactions__checkbox-col", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "Layer__table-cell-content", children: /* @__PURE__ */ jsxRuntime.jsx(
         Checkbox,
         {
           isSelected: isTransactionSelected,
@@ -14559,7 +16034,7 @@ const BankTransactionRow = ({
                     children: categorized ? (stringOverrides == null ? void 0 : stringOverrides.updateButtonText) || "Update" : (stringOverrides == null ? void 0 : stringOverrides.approveButtonText) || "Confirm"
                   }
                 ) : null,
-                !categorizationEnabled && !categorized ? /* @__PURE__ */ jsxRuntime.jsx(VStack, { pis: "xs", fluid: true, children: /* @__PURE__ */ jsxRuntime.jsx(BankTransactionProcessingInfo, {}) }) : null,
+                !categorizationEnabled && !categorized ? /* @__PURE__ */ jsxRuntime.jsx(VStack, { pis: "xs", fluid: true, children: /* @__PURE__ */ jsxRuntime.jsx(BankTransactionsProcessingInfo, {}) }) : null,
                 /* @__PURE__ */ jsxRuntime.jsx(
                   IconButton,
                   {
@@ -14580,7 +16055,7 @@ const BankTransactionRow = ({
         }
       )
     ] }),
-    /* @__PURE__ */ jsxRuntime.jsx("tr", { children: /* @__PURE__ */ jsxRuntime.jsx("td", { colSpan: 7, className: "Layer__bank-transaction-row__expanded-td", children: /* @__PURE__ */ jsxRuntime.jsx(
+    /* @__PURE__ */ jsxRuntime.jsx("tr", { children: /* @__PURE__ */ jsxRuntime.jsx("td", { colSpan, className: "Layer__bank-transaction-row__expanded-td", children: /* @__PURE__ */ jsxRuntime.jsx(
       ExpandedBankTransactionRow,
       {
         ref: expandedRowRef,
@@ -14636,7 +16111,7 @@ const Assignment = ({ bankTransaction }) => {
   }
   return /* @__PURE__ */ jsxRuntime.jsx(Text, { children: (_d = bankTransaction == null ? void 0 : bankTransaction.category) == null ? void 0 : _d.display_name });
 };
-const BankTransactionListItem = ({
+const BankTransactionsListItem = ({
   index: index2,
   dateFormat,
   bankTransaction,
@@ -14728,7 +16203,7 @@ const BankTransactionListItem = ({
     ] }),
     /* @__PURE__ */ jsxRuntime.jsxs(HStack, { className: "Layer__bank-transaction-list-item__body", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(HStack, { gap: "sm", className: "Layer__bank-transaction-list-item__body__name", children: [
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "Layer__bank-transaction-list-item__checkbox", children: /* @__PURE__ */ jsxRuntime.jsx(
+        categorizationEnabled && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "Layer__bank-transaction-list-item__checkbox", children: /* @__PURE__ */ jsxRuntime.jsx(
           Checkbox,
           {
             isSelected: isTransactionSelected,
@@ -14752,7 +16227,7 @@ const BankTransactionListItem = ({
         }
       )
     ] }),
-    !categorizationEnabled && !categorized ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "Layer__bank-transaction-list-item__processing-info", children: /* @__PURE__ */ jsxRuntime.jsx(BankTransactionProcessingInfo, {}) }) : null,
+    !categorizationEnabled && !categorized ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "Layer__bank-transaction-list-item__processing-info", children: /* @__PURE__ */ jsxRuntime.jsx(BankTransactionsProcessingInfo, {}) }) : null,
     /* @__PURE__ */ jsxRuntime.jsx("span", { className: "Layer__bank-transaction-list-item__expanded-row", children: /* @__PURE__ */ jsxRuntime.jsx(
       ExpandedBankTransactionRow,
       {
@@ -14860,7 +16335,7 @@ const useUpsertBankTransactionsDefaultCategories = (bankTransactions) => {
     setOnlyNewTransactionCategories(defaultCategories);
   }, [bankTransactions, setOnlyNewTransactionCategories]);
 };
-const BankTransactionList = ({
+const BankTransactionsList = ({
   bankTransactions,
   editable,
   removeTransaction,
@@ -14872,8 +16347,10 @@ const BankTransactionList = ({
 }) => {
   const { isAllSelected, isPartiallySelected, onHeaderCheckboxChange } = useBankTransactionsTableCheckboxState({ bankTransactions });
   useUpsertBankTransactionsDefaultCategories(bankTransactions);
+  const bookkeepingStatus = useEffectiveBookkeepingStatus();
+  const categorizationEnabled = isCategorizationEnabledForStatus(bookkeepingStatus);
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-    /* @__PURE__ */ jsxRuntime.jsxs(
+    categorizationEnabled && /* @__PURE__ */ jsxRuntime.jsxs(
       HStack,
       {
         gap: "md",
@@ -14897,7 +16374,7 @@ const BankTransactionList = ({
     ),
     /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "Layer__bank-transactions__list", children: bankTransactions == null ? void 0 : bankTransactions.map(
       (bankTransaction, index2) => /* @__PURE__ */ jsxRuntime.jsx(
-        BankTransactionListItem,
+        BankTransactionsListItem,
         {
           index: index2,
           dateFormat: DATE_FORMAT$1,
@@ -16014,7 +17491,7 @@ const getAssignedValue = (bankTransaction, renderInAppLink) => {
   }
   return (_d = bankTransaction.category) == null ? void 0 : _d.display_name;
 };
-const BankTransactionMobileListItem = ({
+const BankTransactionsMobileListItem = ({
   index: index2,
   bankTransaction,
   removeTransaction,
@@ -16137,7 +17614,7 @@ const BankTransactionMobileListItem = ({
               hasReceipts(bankTransaction) ? /* @__PURE__ */ jsxRuntime.jsx(File, { size: 12 }) : null
             ] }),
             categorized && fullAccountName,
-            !categorizationEnabled && !categorized ? /* @__PURE__ */ jsxRuntime.jsx(BankTransactionProcessingInfo, {}) : null
+            !categorizationEnabled && !categorized ? /* @__PURE__ */ jsxRuntime.jsx(BankTransactionsProcessingInfo, {}) : null
           ] }),
           /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `${className}__heading__amount`, children: [
             /* @__PURE__ */ jsxRuntime.jsxs(
@@ -16214,7 +17691,7 @@ const BankTransactionMobileListItem = ({
     )
   ] });
 };
-const BankTransactionMobileList = ({
+const BankTransactionsMobileList = ({
   bankTransactions,
   removeTransaction,
   editable,
@@ -16226,7 +17703,7 @@ const BankTransactionMobileList = ({
   const transactionToOpenContextData = useTransactionToOpen();
   return /* @__PURE__ */ jsxRuntime.jsx(TransactionToOpenContext.Provider, { value: transactionToOpenContextData, children: /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "Layer__bank-transactions__mobile-list", children: bankTransactions == null ? void 0 : bankTransactions.map(
     (bankTransaction, index2) => /* @__PURE__ */ jsxRuntime.jsx(
-      BankTransactionMobileListItem,
+      BankTransactionsMobileListItem,
       {
         index: index2,
         bankTransaction,
@@ -16248,7 +17725,7 @@ const SkeletonTableLoader = ({
   height = 20,
   width = 100
 }) => {
-  return /* @__PURE__ */ jsxRuntime.jsx("tbody", { className: "Layer__skeleton-table-body__loader", children: Array.from({ length: rows }).map((_2, rowIndex) => /* @__PURE__ */ jsxRuntime.jsx("tr", { children: cols.map((col, colIndex) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("tbody", { className: "Layer__skeleton-table-body__loader", children: Array.from({ length: rows }).map((_, rowIndex) => /* @__PURE__ */ jsxRuntime.jsx("tr", { children: cols.map((col, colIndex) => {
     const trim = col.trimLastXRows && rowIndex >= col.trimLastXRows - 1 ? (rowIndex - col.trimLastXRows + 1) * 10 : 0;
     return /* @__PURE__ */ jsxRuntime.jsx(
       "td",
@@ -16340,6 +17817,8 @@ const BankTransactionsTable = ({
   var _a, _b, _c, _d, _e, _f, _g;
   const { isAllSelected, isPartiallySelected, onHeaderCheckboxChange } = useBankTransactionsTableCheckboxState({ bankTransactions });
   useUpsertBankTransactionsDefaultCategories(bankTransactions);
+  const bookkeepingStatus = useEffectiveBookkeepingStatus();
+  const categorizationEnabled = isCategorizationEnabledForStatus(bookkeepingStatus);
   const showReceiptColumn = (_a = showReceiptUploads && (bankTransactions == null ? void 0 : bankTransactions.some(
     (transaction) => {
       var _a2;
@@ -16357,7 +17836,7 @@ const BankTransactionsTable = ({
       className: "Layer__table Layer__bank-transactions__table with-cell-separators",
       children: [
         /* @__PURE__ */ jsxRuntime.jsx("thead", { children: /* @__PURE__ */ jsxRuntime.jsxs("tr", { children: [
-          /* @__PURE__ */ jsxRuntime.jsx("th", { className: "Layer__table-header Layer__bank-transactions__checkbox-col", style: { padding: 0 }, children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "Layer__table-cell-content", children: /* @__PURE__ */ jsxRuntime.jsx(
+          categorizationEnabled && /* @__PURE__ */ jsxRuntime.jsx("th", { className: "Layer__table-header Layer__bank-transactions__checkbox-col", style: { padding: 0 }, children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "Layer__table-cell-content", children: /* @__PURE__ */ jsxRuntime.jsx(
             Checkbox,
             {
               isSelected: isAllSelected,
@@ -16802,7 +18281,7 @@ function buildKey$G({
     };
   }
 }
-const getCustomAccounts = get(({ businessId, userCreated }) => {
+const getCustomAccounts = get$1(({ businessId, userCreated }) => {
   const baseUrl = `/v1/businesses/${businessId}/custom-accounts`;
   if (userCreated !== void 0) {
     return `${baseUrl}?user_created=${userCreated}`;
@@ -19295,7 +20774,7 @@ function buildKey$z({
     };
   }
 }
-const getTagDimensions = get(({ businessId }) => `/v1/businesses/${businessId}/tags/dimensions`);
+const getTagDimensions = get$1(({ businessId }) => `/v1/businesses/${businessId}/tags/dimensions`);
 const TagDimensionsListSchema = effect.Schema.Array(TagDimensionSchema);
 class TagDimensionsSWRResponse {
   constructor(swrResponse) {
@@ -19404,7 +20883,7 @@ class ListCategorizationRulesSWRResponse {
     return this.swrResponse.mutate;
   }
 }
-const listCategorizationRules = get(({ businessId, externalIds, includeArchived, sortBy, sortOrder, cursor, limit, showTotalCount }) => {
+const listCategorizationRules = get$1(({ businessId, externalIds, includeArchived, sortBy, sortOrder, cursor, limit, showTotalCount }) => {
   const parameters = toDefinedSearchParameters({
     externalIds,
     includeArchived,
@@ -20620,10 +22099,10 @@ const BankTransactionsTableView = ({
     return data == null ? void 0 : data.slice(firstPageIndex, lastPageIndex);
   }, [currentPage, data, isMonthlyViewMode, pageSize]);
   const [shiftStickyHeader, setShiftStickyHeader] = react.useState(0);
-  const debounceShiftStickyHeader = _.debounce(setShiftStickyHeader, 500);
+  const debounceShiftStickyHeader = debounce(setShiftStickyHeader, 500);
   const [listView, setListView] = react.useState(false);
   const [containerWidth, setContainerWidth] = react.useState(0);
-  const debounceContainerWidth = _.debounce(setContainerWidth, 500);
+  const debounceContainerWidth = debounce(setContainerWidth, 500);
   const removeTransaction = (bankTransaction) => removeAfterCategorize(bankTransaction);
   const containerRef = useElementSize((_el, _en, size) => {
     if ((size == null ? void 0 : size.height) && (size == null ? void 0 : size.height) >= 90) {
@@ -20699,7 +22178,7 @@ const BankTransactionsTableView = ({
         !isLoadingWithoutData && listView && mobileComponent !== "mobileList" ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "Layer__bank-transactions__list-wrapper", children: [
           rulesSuggestionModal,
           /* @__PURE__ */ jsxRuntime.jsx(
-            BankTransactionList,
+            BankTransactionsList,
             {
               bankTransactions,
               editable,
@@ -20714,7 +22193,7 @@ const BankTransactionsTableView = ({
         ] }) : null,
         !isLoadingWithoutData && listView && mobileComponent === "mobileList" ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
           /* @__PURE__ */ jsxRuntime.jsx(
-            BankTransactionMobileList,
+            BankTransactionsMobileList,
             {
               bankTransactions,
               editable,
@@ -21375,7 +22854,7 @@ const useProfitAndLoss = ({ tagFilter, reportingBasis }) => {
   };
 };
 function range(start, end) {
-  return Array.from({ length: end - start }, (_2, index2) => start + index2);
+  return Array.from({ length: end - start }, (_, index2) => start + index2);
 }
 function isArrayWithAtLeastOne(list) {
   return list.length > 0;
@@ -24341,7 +25820,7 @@ const getProfitAndLossDetailLinesExcel = (apiUrl, accessToken, params) => {
     tagValues,
     pnlStructure
   });
-  return get(
+  return get$1(
     ({ businessId: businessId2 }) => `/v1/businesses/${businessId2}/reports/profit-and-loss/lines/exports/excel?${queryParams.toString()}`
   )(apiUrl, accessToken, { params: { businessId } });
 };
@@ -24683,13 +26162,13 @@ const generateComparisonPeriods = (startDate, numberOfPeriods, rangeDisplayMode)
   }
 };
 const generateComparisonMonths = (startDate, numberOfMonths) => {
-  return Array.from({ length: numberOfMonths }, (_2, index2) => {
+  return Array.from({ length: numberOfMonths }, (_, index2) => {
     const currentMonth = dateFns.subMonths(startDate, numberOfMonths - index2 - 1);
     return { date: currentMonth, label: dateFns.format(currentMonth, "MMM") };
   });
 };
 const generateComparisonYears = (startDate, numberOfYears) => {
-  return Array.from({ length: numberOfYears }, (_2, index2) => {
+  return Array.from({ length: numberOfYears }, (_, index2) => {
     const currentMonth = dateFns.subYears(startDate, numberOfYears - index2 - 1);
     return { date: currentMonth, label: dateFns.format(currentMonth, "yyyy") };
   });
@@ -24841,7 +26320,7 @@ const ProfitAndLossCompareTable = ({
       /* @__PURE__ */ jsxRuntime.jsx(TableCell, { isHeaderCell: true }),
       selectedCompareOptions.map((option, i) => /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
         /* @__PURE__ */ jsxRuntime.jsx(TableCell, { primary: true, isHeaderCell: true, children: option.displayName }, option.displayName + "-" + i),
-        comparePeriods && Array.from({ length: comparePeriods - 1 }, (_2, index2) => /* @__PURE__ */ jsxRuntime.jsx(TableCell, { isHeaderCell: true }, option.displayName + "-" + index2))
+        comparePeriods && Array.from({ length: comparePeriods - 1 }, (_, index2) => /* @__PURE__ */ jsxRuntime.jsx(TableCell, { isHeaderCell: true }, option.displayName + "-" + index2))
       ] }, option.displayName + "-" + i))
     ] }) }),
     /* @__PURE__ */ jsxRuntime.jsxs(TableBody, { children: [
@@ -24895,7 +26374,7 @@ function useEffectOnMount(fn) {
         if (isMounted && typeof maybeCleanup === "function") {
           cleanup = maybeCleanup;
         }
-      } catch (_2) {
+      } catch (_) {
       }
     }))();
     return () => {
@@ -26709,7 +28188,7 @@ class LedgerBalancesSWRResponse {
     return this.swrResponse.mutate;
   }
 }
-const getLedgerAccountBalances = get(
+const getLedgerAccountBalances = get$1(
   ({ businessId, startDate, endDate }) => {
     const parameters = toDefinedSearchParameters({ startDate, endDate });
     return `/v1/businesses/${businessId}/ledger/balances?${parameters}`;
@@ -26772,7 +28251,7 @@ function useLedgerBalancesCacheActions() {
   };
 }
 const LIST_LEDGER_ENTRIES_TAG_KEY = "#list-ledger-entries";
-const listLedgerEntries = get(({ businessId, sort_by, sort_order, cursor, limit, show_total_count }) => {
+const listLedgerEntries = get$1(({ businessId, sort_by, sort_order, cursor, limit, show_total_count }) => {
   const parameters = toDefinedSearchParameters({
     sort_by,
     sort_order,
@@ -26872,7 +28351,7 @@ function useLedgerEntriesCacheActions() {
     [forceReload]
   );
   const debouncedInvalidateLedgerEntries = react.useMemo(
-    () => _.debounce(
+    () => debounce(
       invalidateLedgerEntries,
       INVALIDATION_DEBOUNCE_OPTIONS.wait,
       {
@@ -27198,7 +28677,7 @@ const useChartOfAccounts = ({ withDates, startDate: initialStartDate, endDate: i
   };
 };
 const LIST_LEDGER_ACCOUNT_LINES_TAG_KEY = "#list-ledger-account-lines";
-const listLedgerAccountLines = get(({
+const listLedgerAccountLines = get$1(({
   businessId,
   accountId,
   include_entries_before_activation,
@@ -27848,18 +29327,18 @@ const ChartOfAccountsTableContent = ({
   const { accountingConfiguration } = useLayerContext();
   const enableAccountNumbers = !!(accountingConfiguration == null ? void 0 : accountingConfiguration.enableAccountNumbers);
   const allRowKeys = react.useMemo(() => {
-    const keys = [];
+    const keys2 = [];
     const collect = (accounts) => {
       for (const account of accounts) {
         const key = `coa-row-${account.accountId}`;
         if (account.subAccounts.length > 0) {
-          keys.push(key);
+          keys2.push(key);
           collect(account.subAccounts);
         }
       }
     };
     collect(data.accounts);
-    return keys;
+    return keys2;
   }, [data.accounts]);
   react.useEffect(() => {
     if (expandAll === void 0) return;
@@ -31334,7 +32813,7 @@ function TasksMonthSelector() {
   const activeMonthNumber = dateFns.getMonth(date2) + 1;
   const activeYear = dateFns.getYear(date2);
   const monthsData = react.useMemo(() => {
-    return Array.from({ length: 12 }, (_2, index2) => {
+    return Array.from({ length: 12 }, (_, index2) => {
       var _a, _b;
       const date22 = dateFns.set(
         /* @__PURE__ */ new Date(),
@@ -31383,7 +32862,7 @@ const useBookkeepingYearsStatus = () => {
     const startYear = dateFns.getYear(activationDate != null ? activationDate : /* @__PURE__ */ new Date());
     const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
     const count = currentYear - startYear + 1;
-    return Array.from({ length: count }, (_2, index2) => ({ year: startYear + index2 })).map(({ year }) => {
+    return Array.from({ length: count }, (_, index2) => ({ year: startYear + index2 })).map(({ year }) => {
       const tasks = data == null ? void 0 : data.filter((period) => period.year === year).reduce((acc, period) => acc.concat(period.tasks), []);
       const unresolvedTaskCount = tasks == null ? void 0 : tasks.filter((task) => isIncompleteTask(task)).length;
       return {
@@ -31854,7 +33333,7 @@ const CreateCallBookingBodySchemaDefinition = effect.Schema.Struct({
   )
 });
 effect.Schema.encodeSync(CreateCallBookingBodySchemaDefinition);
-const listCallBookings = get(({ businessId, cursor, limit }) => {
+const listCallBookings = get$1(({ businessId, cursor, limit }) => {
   const parameters = toDefinedSearchParameters({
     cursor,
     limit,
@@ -31990,7 +33469,7 @@ const isCalendlyLink = (link) => {
     if (!link) return false;
     const hostname = new URL(link.url).hostname;
     return ALLOWED_CALENDLY_HOSTS.includes(hostname) || hostname.endsWith(".calendly.com");
-  } catch (_2) {
+  } catch (_) {
     return false;
   }
 };
@@ -32384,10 +33863,10 @@ const LandingPageOffer = ({
   ] }) });
 };
 function mergeHeroContentConfig(defaults, overrides) {
-  return _.merge(defaults, overrides);
+  return merge(defaults, overrides);
 }
 function mergeLandingPageConfig(defaults, overrides) {
-  return _.merge(defaults, overrides);
+  return merge(defaults, overrides);
 }
 const LandingPage = ({
   platform,
@@ -33031,7 +34510,7 @@ function buildKey$g({
     };
   }
 }
-const getBusinessPersonnel = get(({ businessId }) => `/v1/businesses/${businessId}/personnel`);
+const getBusinessPersonnel = get$1(({ businessId }) => `/v1/businesses/${businessId}/personnel`);
 function useBusinessPersonnel() {
   const { data } = useAuth();
   const { businessId } = useLayerContext();
@@ -33817,7 +35296,7 @@ function buildKey$c({
     };
   }
 }
-const getBookkeepingConfiguration = get(({ businessId }) => {
+const getBookkeepingConfiguration = get$1(({ businessId }) => {
   return `/v1/businesses/${businessId}/bookkeeping/config`;
 });
 function useBookkeepingConfiguration() {
@@ -34235,7 +35714,7 @@ const AddToCalendar = ({
     const event = {
       summary: calendarEvent.title,
       description: calendarEvent.description,
-      uid: _.uniqueId("ics-"),
+      uid: uniqueId("ics-"),
       stamp: { date: /* @__PURE__ */ new Date() },
       start: { date: startDate },
       end: { date: effectiveEndDate },
@@ -35165,7 +36644,7 @@ const useBillsRecordPayment = ({ refetchAllBills }) => {
     }));
   };
   const removeBillByIndex = (index2) => {
-    setBillsToPay((prev) => prev.filter((_2, i) => i !== index2));
+    setBillsToPay((prev) => prev.filter((_, i) => i !== index2));
   };
   const setAmount = (billId, amount) => {
     setBillsToPay((prev) => prev.map((bill) => {
@@ -36283,7 +37762,7 @@ const BillsDetails = ({
                 /* @__PURE__ */ jsxRuntime.jsx(form.Field, { name: "line_items", mode: "array", children: (field) => {
                   var _a;
                   return /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
-                    (_a = field.state.value) == null ? void 0 : _a.map((_2, i) => {
+                    (_a = field.state.value) == null ? void 0 : _a.map((_, i) => {
                       return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "Layer__bill-details__category-row", children: [
                         /* @__PURE__ */ jsxRuntime.jsx(form.Field, { name: `line_items[${i}].account_identifier`, children: () => {
                           return null;
@@ -37108,7 +38587,7 @@ function buildKey$9(_Qc) {
     }, dateParams);
   }
 }
-const getUnifiedReport = get((_Sc) => {
+const getUnifiedReport = get$1((_Sc) => {
   var _Tc = _Sc, { businessId, report } = _Tc, dateParams = __objRest(_Tc, ["businessId", "report"]);
   const parameters = toDefinedSearchParameters(__spreadValues({}, dateParams));
   return `/v1/businesses/${businessId}/reports/unified/${report}?${parameters}`;
@@ -38437,7 +39916,7 @@ class ListInvoicesSWRResponse {
     return this.swrResponse.mutate;
   }
 }
-const listInvoices = get(({ businessId, status, query, dueAtStart, dueAtEnd, sortBy, sortOrder, cursor, limit, showTotalCount }) => {
+const listInvoices = get$1(({ businessId, status, query, dueAtStart, dueAtEnd, sortBy, sortOrder, cursor, limit, showTotalCount }) => {
   const parameters = toDefinedSearchParameters({
     status,
     q: query,
@@ -39038,7 +40517,7 @@ function buildKey$7({
     };
   }
 }
-const getInvoiceSummaryStats = get(({ businessId }) => `/v1/businesses/${businessId}/invoices/summary-stats`);
+const getInvoiceSummaryStats = get$1(({ businessId }) => `/v1/businesses/${businessId}/invoices/summary-stats`);
 function useInvoiceSummaryStats() {
   const { data } = useAuth();
   const { businessId } = useLayerContext();
@@ -41529,15 +43008,15 @@ const useDataSync = () => {
     );
   };
   const resetCaches = () => {
-    const now = Date.now();
+    const now2 = Date.now();
     void invalidateProfitAndLoss();
     setSyncTimestamps({
-      [DataModel.BALANCE_SHEET]: now,
-      [DataModel.LEDGER_ACCOUNTS]: now,
-      [DataModel.LINKED_ACCOUNTS]: now,
-      [DataModel.PROFIT_AND_LOSS]: now,
-      [DataModel.STATEMENT_OF_CASH_FLOWS]: now,
-      [DataModel.BANK_TRANSACTIONS]: now
+      [DataModel.BALANCE_SHEET]: now2,
+      [DataModel.LEDGER_ACCOUNTS]: now2,
+      [DataModel.LINKED_ACCOUNTS]: now2,
+      [DataModel.PROFIT_AND_LOSS]: now2,
+      [DataModel.STATEMENT_OF_CASH_FLOWS]: now2,
+      [DataModel.BANK_TRANSACTIONS]: now2
     });
   };
   return {
@@ -41581,8 +43060,8 @@ function stableHash(arg) {
       table.set(arg, result);
     } else if (constructor === Object) {
       result = "#";
-      const keys = Object.keys(arg).sort();
-      while ((index2 = keys.pop()) !== void 0) {
+      const keys2 = Object.keys(arg).sort();
+      while ((index2 = keys2.pop()) !== void 0) {
         if (arg[index2] !== void 0) {
           result += index2 + ":" + stableHash(arg[index2]) + ",";
         }
@@ -41665,7 +43144,7 @@ function buildKey({
     };
   }
 }
-const getAccountingConfiguration = get(
+const getAccountingConfiguration = get$1(
   ({ businessId }) => {
     return `/v1/businesses/${businessId}/accounting-config`;
   }