@marimo-team/islands 0.21.2-dev92 → 0.21.2-dev93

package/src/plugins/impl/vega/loader.ts

@@ -1,7 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { tableFromIPC } from "@uwdata/flechette";
-import { isNumber } from "lodash-es";
 import { Logger } from "@/utils/Logger";
 import { Objects } from "@/utils/objects";
 import { batchedArrowLoader, createBatchedLoader } from "./batched";
@@ -42,7 +41,9 @@ const BIG_INT_MIDDLEWARE: Middleware = () => {
     }
 
     const parsedInt = Number.parseInt(v, 10);
-    if (isNumber(parsedInt)) {
+    if (Number.isNaN(parsedInt)) {
+      return v;
+    } else {
       const needsBigInt = Math.abs(parsedInt) > Number.MAX_SAFE_INTEGER;
       if (!needsBigInt) {
         return previousIntegerParserWithoutNaN(v);
@@ -54,8 +55,6 @@ const BIG_INT_MIDDLEWARE: Middleware = () => {
         // as BigInt
         return previousIntegerParserWithoutNaN(v);
       }
-    } else {
-      return "";
     }
   };
   typeParsers.number = (v: string) => {

package/src/plugins/impl/vega/params.ts

@@ -1,8 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { uniq } from "lodash-es";
 import type { TopLevelSpec } from "vega-lite";
 import type { NonNormalizedSpec } from "vega-lite/types_unstable/spec/index.js";
+import { uniq } from "@/utils/arrays";
 import { Marks } from "./marks";
 import {
   type Field,

package/src/utils/__tests__/arrays.test.ts

@@ -9,6 +9,10 @@ import {
   arrayShallowEquals,
   arrayToggle,
   getNextIndex,
+  partition,
+  range,
+  sortBy,
+  uniq,
 } from "../arrays";
 
 describe("arrays", () => {
@@ -130,6 +134,120 @@ describe("arrays", () => {
   });
 });
 
+describe("range", () => {
+  it("should create an array of numbers from 0 to length - 1", () => {
+    expect(range(5)).toEqual([0, 1, 2, 3, 4]);
+  });
+
+  it("should return empty array for 0", () => {
+    expect(range(0)).toEqual([]);
+  });
+
+  it("should return single element for 1", () => {
+    expect(range(1)).toEqual([0]);
+  });
+});
+
+describe("uniq", () => {
+  it("should remove duplicate numbers", () => {
+    expect(uniq([1, 2, 2, 3, 1])).toEqual([1, 2, 3]);
+  });
+
+  it("should remove duplicate strings", () => {
+    expect(uniq(["a", "b", "a", "c"])).toEqual(["a", "b", "c"]);
+  });
+
+  it("should handle empty array", () => {
+    expect(uniq([])).toEqual([]);
+  });
+
+  it("should preserve order of first occurrence", () => {
+    expect(uniq([3, 1, 2, 1, 3])).toEqual([3, 1, 2]);
+  });
+});
+
+describe("sortBy", () => {
+  it("should sort by a numeric key", () => {
+    const items = [{ n: 3 }, { n: 1 }, { n: 2 }];
+    expect(sortBy(items, (x) => x.n)).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
+  });
+
+  it("should sort by a string key", () => {
+    const items = [{ name: "charlie" }, { name: "alice" }, { name: "bob" }];
+    expect(sortBy(items, (x) => x.name)).toEqual([
+      { name: "alice" },
+      { name: "bob" },
+      { name: "charlie" },
+    ]);
+  });
+
+  it("should not mutate the original array", () => {
+    const arr = [3, 1, 2];
+    sortBy(arr, (x) => x);
+    expect(arr).toEqual([3, 1, 2]);
+  });
+
+  it("should handle empty array", () => {
+    expect(sortBy([], (x) => x)).toEqual([]);
+  });
+
+  it("should sort null/undefined keys last", () => {
+    const items = [
+      { name: "b", v: undefined },
+      { name: "a", v: 1 },
+      { name: "c", v: null },
+      { name: "d", v: 2 },
+    ];
+    const result = sortBy(items, (x) => x.v);
+    expect(result.map((x) => x.name)).toEqual(["a", "d", "b", "c"]);
+  });
+
+  it("should sort numeric keys correctly", () => {
+    const items = [{ v: 10 }, { v: 2 }, { v: 1 }, { v: 20 }];
+    expect(sortBy(items, (x) => x.v)).toEqual([
+      { v: 1 },
+      { v: 2 },
+      { v: 10 },
+      { v: 20 },
+    ]);
+  });
+});
+
+describe("partition", () => {
+  it("should split array by predicate", () => {
+    const [evens, odds] = partition([1, 2, 3, 4, 5], (n) => n % 2 === 0);
+    expect(evens).toEqual([2, 4]);
+    expect(odds).toEqual([1, 3, 5]);
+  });
+
+  it("should handle all matching", () => {
+    const [pass, fail] = partition([2, 4, 6], (n) => n % 2 === 0);
+    expect(pass).toEqual([2, 4, 6]);
+    expect(fail).toEqual([]);
+  });
+
+  it("should handle none matching", () => {
+    const [pass, fail] = partition([1, 3, 5], (n) => n % 2 === 0);
+    expect(pass).toEqual([]);
+    expect(fail).toEqual([1, 3, 5]);
+  });
+
+  it("should handle empty array", () => {
+    const [pass, fail] = partition([], () => true);
+    expect(pass).toEqual([]);
+    expect(fail).toEqual([]);
+  });
+
+  it("should work with string predicates", () => {
+    const [long, short] = partition(
+      ["hi", "hello", "yo", "greetings"],
+      (s) => s.length > 3,
+    );
+    expect(long).toEqual(["hello", "greetings"]);
+    expect(short).toEqual(["hi", "yo"]);
+  });
+});
+
 describe("getNextIndex", () => {
   it("should return 0 if listLength is 0", () => {
     expect(getNextIndex(null, 0, "up")).toBe(0);

package/src/utils/__tests__/objects.test.ts

@@ -260,4 +260,38 @@ describe("Objects", () => {
       expect(result).toEqual({ a: 1, b: 2 });
     });
   });
+
+  describe("pick", () => {
+    it("should pick specified keys", () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      expect(Objects.pick(obj, ["a", "c"])).toEqual({ a: 1, c: 3 });
+    });
+
+    it("should omit keys not present on the object", () => {
+      const obj = { a: 1, b: 2 };
+      expect(Objects.pick(obj, ["a", "z"])).toEqual({ a: 1 });
+    });
+
+    it("should preserve undefined values for existing keys", () => {
+      const obj = { a: undefined, b: 2 };
+      const result = Objects.pick(obj, ["a", "b"]);
+      expect(result).toEqual({ a: undefined, b: 2 });
+      expect("a" in result).toBe(true);
+    });
+
+    it("should not pick inherited properties", () => {
+      const parent = { inherited: true };
+      const obj = Object.create(parent);
+      obj.own = 1;
+      expect(Objects.pick(obj, ["own", "inherited"])).toEqual({ own: 1 });
+    });
+
+    it("should return empty object when picking no keys", () => {
+      expect(Objects.pick({ a: 1 }, [])).toEqual({});
+    });
+
+    it("should handle empty object", () => {
+      expect(Objects.pick({}, ["a"])).toEqual({});
+    });
+  });
 });

package/src/utils/__tests__/strings.test.ts

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { describe, expect, it } from "vitest";
-import { decodeUtf8, Strings } from "../strings";
+import { capitalize, decodeUtf8, Strings } from "../strings";
 
 describe("Strings", () => {
   describe("startCase", () => {
@@ -58,6 +58,32 @@ describe("Strings", () => {
   });
 });
 
+describe("capitalize", () => {
+  it("capitalizes the first character", () => {
+    expect(capitalize("hello")).toBe("Hello");
+  });
+
+  it("returns empty string for empty input", () => {
+    expect(capitalize("")).toBe("");
+  });
+
+  it("handles already-capitalized strings", () => {
+    expect(capitalize("Hello")).toBe("Hello");
+  });
+
+  it("handles single character", () => {
+    expect(capitalize("a")).toBe("A");
+  });
+
+  it("preserves the rest of the string", () => {
+    expect(capitalize("hELLO")).toBe("HELLO");
+  });
+
+  it("handles non-letter first character", () => {
+    expect(capitalize("123abc")).toBe("123abc");
+  });
+});
+
 describe("decodeUtf8", () => {
   it("decodes UTF-8 array to string", () => {
     const encoder = new TextEncoder();

package/src/utils/arrays.ts

@@ -61,6 +61,73 @@ export const Arrays = {
   },
 };
 
+/**
+ * Create an array of numbers from 0 to length - 1.
+ */
+export function range(length: number): number[] {
+  return Array.from({ length }, (_, i) => i);
+}
+
+/**
+ * Remove duplicate values from an array.
+ */
+export function uniq<T>(arr: readonly T[]): T[] {
+  return [...new Set(arr)];
+}
+
+/**
+ * Sort an array by a key function, returning a new array.
+ */
+export function sortBy<T>(
+  arr: readonly T[],
+  key: (item: T) => string | number | undefined | null,
+): T[] {
+  // Decorate/sort/undecorate to compute keys once per element
+  return arr
+    .map((item) => [key(item), item] as const)
+    .sort(([ka], [kb]) => {
+      // Nullish values sort last
+      if (ka == null && kb == null) {
+        return 0;
+      }
+      if (ka == null) {
+        return 1;
+      }
+      if (kb == null) {
+        return -1;
+      }
+      if (ka < kb) {
+        return -1;
+      }
+      if (ka > kb) {
+        return 1;
+      }
+      return 0;
+    })
+    .map(([, item]) => item);
+}
+
+/**
+ * Split an array into two groups based on a predicate.
+ * Returns [pass, fail] where pass contains items that match
+ * and fail contains items that don't.
+ */
+export function partition<T>(
+  arr: readonly T[],
+  predicate: (item: T) => boolean,
+): [T[], T[]] {
+  const pass: T[] = [];
+  const fail: T[] = [];
+  for (const item of arr) {
+    if (predicate(item)) {
+      pass.push(item);
+    } else {
+      fail.push(item);
+    }
+  }
+  return [pass, fail];
+}
+
 export function arrayToggle<T>(arr: T[], item: T): T[] {
   if (!arr) {
     return [item];

package/src/utils/objects.ts

@@ -105,4 +105,18 @@ export const Objects = {
     const set = new Set<K>(keys);
     return Objects.filter(obj, (_, key) => !set.has(key));
   },
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  pick<V extends Record<string, any>, K extends string>(
+    obj: V,
+    keys: readonly K[],
+  ): Pick<V, K & keyof V> {
+    const result = {} as Record<string, unknown>;
+    for (const key of keys) {
+      if (Object.hasOwn(obj, key)) {
+        result[key] = obj[key];
+      }
+    }
+    return result as Pick<V, K & keyof V>;
+  },
 };

package/src/utils/strings.ts

@@ -1,28 +1,48 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-import { startCase } from "lodash-es";
 import { Logger } from "./Logger";
 
-export const Strings = {
-  /**
-   * startCase that can handle non-letters
-   */
-  startCase: (str: string): string => {
-    if (!str) {
-      return "";
-    }
+/**
+ * Capitalize the first character of a string.
+ */
+export function capitalize(str: string): string {
+  if (!str) {
+    return "";
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
 
-    if (typeof str !== "string") {
-      Logger.error(str);
-      throw new TypeError(`Expected string, got ${typeof str}`);
-    }
+/**
+ * Convert a string to start case (capitalize each word).
+ * Handles camelCase, snake_case, kebab-case, and space-separated strings.
+ * Returns the original string unchanged if it contains no letters.
+ */
+export function startCase(str: string): string {
+  if (!str) {
+    return "";
+  }
 
-    // If has no letters, return the string
-    if (!/[A-Za-z]/.test(str)) {
-      return str;
-    }
+  if (typeof str !== "string") {
+    Logger.error(str);
+    throw new TypeError(`Expected string, got ${typeof str}`);
+  }
 
-    return startCase(str);
-  },
+  // If has no letters, return the string as-is
+  if (!/[A-Za-z]/.test(str)) {
+    return str;
+  }
+
+  return str
+    .replaceAll(/([\da-z])([A-Z])/g, "$1 $2") // camelCase → camel Case
+    .replaceAll(/([A-Z]+)([A-Z][a-z])/g, "$1 $2") // ABCDef → ABC Def
+    .replaceAll(/[\s_-]+/g, " ") // snake_case/kebab-case → spaces
+    .trim()
+    .split(" ")
+    .map(capitalize)
+    .join(" ");
+}
+
+export const Strings = {
+  startCase,
 
   htmlEscape: (str: string | undefined): string | undefined => {
     if (!str) {

package/dist/_arrayReduce-6BJAuN54.js

@@ -1,9 +0,0 @@
-function arrayReduce(e, t, n, r) {
-  var i = -1, a = e == null ? 0 : e.length;
-  for (r && a && (n = e[++i]); ++i < a; ) n = t(n, e[i], i, e);
-  return n;
-}
-var _arrayReduce_default = arrayReduce;
-export {
-  _arrayReduce_default as t
-};

package/dist/_baseIsEqual-QWfxbVqg.js

@@ -1,226 +0,0 @@
-import { B as isArray_default, C as isArrayLike_default, F as _getNative_default, H as _baseGetTag_default, I as _toSource_default, U as _Symbol_default, V as isObjectLike_default, W as _root_default, b as _isPrototype_default, c as _Stack_default, d as _Map_default, h as isTypedArray_default, k as eq_default, m as _arrayLikeKeys_default, o as _Uint8Array_default, p as _overArg_default, u as _MapCache_default, v as isBuffer_default } from "./isArrayLikeObject-C-hFPChh.js";
-var _WeakMap_default = _getNative_default(_root_default, "WeakMap"), _nativeKeys_default = _overArg_default(Object.keys, Object), hasOwnProperty$2 = Object.prototype.hasOwnProperty;
-function baseKeys(a) {
-  if (!_isPrototype_default(a)) return _nativeKeys_default(a);
-  var P = [];
-  for (var F in Object(a)) hasOwnProperty$2.call(a, F) && F != "constructor" && P.push(F);
-  return P;
-}
-var _baseKeys_default = baseKeys;
-function keys(a) {
-  return isArrayLike_default(a) ? _arrayLikeKeys_default(a) : _baseKeys_default(a);
-}
-var keys_default = keys;
-function arrayPush(a, P) {
-  for (var F = -1, I = P.length, L = a.length; ++F < I; ) a[L + F] = P[F];
-  return a;
-}
-var _arrayPush_default = arrayPush;
-function arrayFilter(a, P) {
-  for (var F = -1, I = a == null ? 0 : a.length, L = 0, R = []; ++F < I; ) {
-    var z = a[F];
-    P(z, F, a) && (R[L++] = z);
-  }
-  return R;
-}
-var _arrayFilter_default = arrayFilter;
-function stubArray() {
-  return [];
-}
-var stubArray_default = stubArray, propertyIsEnumerable = Object.prototype.propertyIsEnumerable, nativeGetSymbols = Object.getOwnPropertySymbols, _getSymbols_default = nativeGetSymbols ? function(a) {
-  return a == null ? [] : (a = Object(a), _arrayFilter_default(nativeGetSymbols(a), function(P) {
-    return propertyIsEnumerable.call(a, P);
-  }));
-} : stubArray_default;
-function baseGetAllKeys(P, F, I) {
-  var L = F(P);
-  return isArray_default(P) ? L : _arrayPush_default(L, I(P));
-}
-var _baseGetAllKeys_default = baseGetAllKeys;
-function getAllKeys(a) {
-  return _baseGetAllKeys_default(a, keys_default, _getSymbols_default);
-}
-var _getAllKeys_default = getAllKeys, _DataView_default = _getNative_default(_root_default, "DataView"), _Promise_default = _getNative_default(_root_default, "Promise"), _Set_default = _getNative_default(_root_default, "Set"), mapTag$1 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$1 = "[object Set]", weakMapTag = "[object WeakMap]", dataViewTag$1 = "[object DataView]", dataViewCtorString = _toSource_default(_DataView_default), mapCtorString = _toSource_default(_Map_default), promiseCtorString = _toSource_default(_Promise_default), setCtorString = _toSource_default(_Set_default), weakMapCtorString = _toSource_default(_WeakMap_default), getTag = _baseGetTag_default;
-(_DataView_default && getTag(new _DataView_default(/* @__PURE__ */ new ArrayBuffer(1))) != dataViewTag$1 || _Map_default && getTag(new _Map_default()) != mapTag$1 || _Promise_default && getTag(_Promise_default.resolve()) != promiseTag || _Set_default && getTag(new _Set_default()) != setTag$1 || _WeakMap_default && getTag(new _WeakMap_default()) != weakMapTag) && (getTag = function(a) {
-  var P = _baseGetTag_default(a), F = P == objectTag$1 ? a.constructor : void 0, R = F ? _toSource_default(F) : "";
-  if (R) switch (R) {
-    case dataViewCtorString:
-      return dataViewTag$1;
-    case mapCtorString:
-      return mapTag$1;
-    case promiseCtorString:
-      return promiseTag;
-    case setCtorString:
-      return setTag$1;
-    case weakMapCtorString:
-      return weakMapTag;
-  }
-  return P;
-});
-var _getTag_default = getTag, HASH_UNDEFINED = "__lodash_hash_undefined__";
-function setCacheAdd(a) {
-  return this.__data__.set(a, HASH_UNDEFINED), this;
-}
-var _setCacheAdd_default = setCacheAdd;
-function setCacheHas(a) {
-  return this.__data__.has(a);
-}
-var _setCacheHas_default = setCacheHas;
-function SetCache(a) {
-  var P = -1, F = a == null ? 0 : a.length;
-  for (this.__data__ = new _MapCache_default(); ++P < F; ) this.add(a[P]);
-}
-SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd_default, SetCache.prototype.has = _setCacheHas_default;
-var _SetCache_default = SetCache;
-function arraySome(a, P) {
-  for (var F = -1, I = a == null ? 0 : a.length; ++F < I; ) if (P(a[F], F, a)) return true;
-  return false;
-}
-var _arraySome_default = arraySome;
-function cacheHas(a, P) {
-  return a.has(P);
-}
-var _cacheHas_default = cacheHas, COMPARE_PARTIAL_FLAG$3 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
-function equalArrays(a, P, F, I, L, R) {
-  var z = F & COMPARE_PARTIAL_FLAG$3, B = a.length, V = P.length;
-  if (B != V && !(z && V > B)) return false;
-  var H = R.get(a), U = R.get(P);
-  if (H && U) return H == P && U == a;
-  var W = -1, G = true, K = F & COMPARE_UNORDERED_FLAG$1 ? new _SetCache_default() : void 0;
-  for (R.set(a, P), R.set(P, a); ++W < B; ) {
-    var q = a[W], J = P[W];
-    if (I) var Y = z ? I(J, q, W, P, a, R) : I(q, J, W, a, P, R);
-    if (Y !== void 0) {
-      if (Y) continue;
-      G = false;
-      break;
-    }
-    if (K) {
-      if (!_arraySome_default(P, function(a2, P2) {
-        if (!_cacheHas_default(K, P2) && (q === a2 || L(q, a2, F, I, R))) return K.push(P2);
-      })) {
-        G = false;
-        break;
-      }
-    } else if (!(q === J || L(q, J, F, I, R))) {
-      G = false;
-      break;
-    }
-  }
-  return R.delete(a), R.delete(P), G;
-}
-var _equalArrays_default = equalArrays;
-function mapToArray(a) {
-  var P = -1, F = Array(a.size);
-  return a.forEach(function(a2, I) {
-    F[++P] = [I, a2];
-  }), F;
-}
-var _mapToArray_default = mapToArray;
-function setToArray(a) {
-  var P = -1, F = Array(a.size);
-  return a.forEach(function(a2) {
-    F[++P] = a2;
-  }), F;
-}
-var _setToArray_default = setToArray, COMPARE_PARTIAL_FLAG$2 = 1, COMPARE_UNORDERED_FLAG = 2, 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]", arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", symbolProto = _Symbol_default ? _Symbol_default.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
-function equalByTag(a, P, F, I, L, R, z) {
-  switch (F) {
-    case dataViewTag:
-      if (a.byteLength != P.byteLength || a.byteOffset != P.byteOffset) return false;
-      a = a.buffer, P = P.buffer;
-    case arrayBufferTag:
-      return !(a.byteLength != P.byteLength || !R(new _Uint8Array_default(a), new _Uint8Array_default(P)));
-    case boolTag:
-    case dateTag:
-    case numberTag:
-      return eq_default(+a, +P);
-    case errorTag:
-      return a.name == P.name && a.message == P.message;
-    case regexpTag:
-    case stringTag:
-      return a == P + "";
-    case mapTag:
-      var B = _mapToArray_default;
-    case setTag:
-      var V = I & COMPARE_PARTIAL_FLAG$2;
-      if (B || (B = _setToArray_default), a.size != P.size && !V) return false;
-      var H = z.get(a);
-      if (H) return H == P;
-      I |= COMPARE_UNORDERED_FLAG, z.set(a, P);
-      var U = _equalArrays_default(B(a), B(P), I, L, R, z);
-      return z.delete(a), U;
-    case symbolTag:
-      if (symbolValueOf) return symbolValueOf.call(a) == symbolValueOf.call(P);
-  }
-  return false;
-}
-var _equalByTag_default = equalByTag, COMPARE_PARTIAL_FLAG$1 = 1, hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-function equalObjects(a, P, F, I, L, R) {
-  var z = F & COMPARE_PARTIAL_FLAG$1, B = _getAllKeys_default(a), V = B.length;
-  if (V != _getAllKeys_default(P).length && !z) return false;
-  for (var H = V; H--; ) {
-    var U = B[H];
-    if (!(z ? U in P : hasOwnProperty$1.call(P, U))) return false;
-  }
-  var W = R.get(a), G = R.get(P);
-  if (W && G) return W == P && G == a;
-  var K = true;
-  R.set(a, P), R.set(P, a);
-  for (var q = z; ++H < V; ) {
-    U = B[H];
-    var J = a[U], Y = P[U];
-    if (I) var X = z ? I(Y, J, U, P, a, R) : I(J, Y, U, a, P, R);
-    if (!(X === void 0 ? J === Y || L(J, Y, F, I, R) : X)) {
-      K = false;
-      break;
-    }
-    q || (q = U == "constructor");
-  }
-  if (K && !q) {
-    var Z = a.constructor, Q = P.constructor;
-    Z != Q && "constructor" in a && "constructor" in P && !(typeof Z == "function" && Z instanceof Z && typeof Q == "function" && Q instanceof Q) && (K = false);
-  }
-  return R.delete(a), R.delete(P), K;
-}
-var _equalObjects_default = equalObjects, COMPARE_PARTIAL_FLAG = 1, argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]", hasOwnProperty = Object.prototype.hasOwnProperty;
-function baseIsEqualDeep(P, F, I, L, R, z) {
-  var B = isArray_default(P), V = isArray_default(F), U = B ? arrayTag : _getTag_default(P), G = V ? arrayTag : _getTag_default(F);
-  U = U == argsTag ? objectTag : U, G = G == argsTag ? objectTag : G;
-  var K = U == objectTag, q = G == objectTag, J = U == G;
-  if (J && isBuffer_default(P)) {
-    if (!isBuffer_default(F)) return false;
-    B = true, K = false;
-  }
-  if (J && !K) return z || (z = new _Stack_default()), B || isTypedArray_default(P) ? _equalArrays_default(P, F, I, L, R, z) : _equalByTag_default(P, F, U, I, L, R, z);
-  if (!(I & COMPARE_PARTIAL_FLAG)) {
-    var Y = K && hasOwnProperty.call(P, "__wrapped__"), Z = q && hasOwnProperty.call(F, "__wrapped__");
-    if (Y || Z) {
-      var Q = Y ? P.value() : P, $ = Z ? F.value() : F;
-      return z || (z = new _Stack_default()), R(Q, $, I, L, z);
-    }
-  }
-  return J ? (z || (z = new _Stack_default()), _equalObjects_default(P, F, I, L, R, z)) : false;
-}
-var _baseIsEqualDeep_default = baseIsEqualDeep;
-function baseIsEqual(a, P, F, I, L) {
-  return a === P ? true : a == null || P == null || !isObjectLike_default(a) && !isObjectLike_default(P) ? a !== a && P !== P : _baseIsEqualDeep_default(a, P, F, I, baseIsEqual, L);
-}
-var _baseIsEqual_default = baseIsEqual;
-export {
-  _SetCache_default as a,
-  _getAllKeys_default as c,
-  stubArray_default as d,
-  _arrayFilter_default as f,
-  _baseKeys_default as h,
-  _arraySome_default as i,
-  _baseGetAllKeys_default as l,
-  keys_default as m,
-  _setToArray_default as n,
-  _getTag_default as o,
-  _arrayPush_default as p,
-  _cacheHas_default as r,
-  _Set_default as s,
-  _baseIsEqual_default as t,
-  _getSymbols_default as u
-};

package/dist/_basePickBy-Do49cXgl.js

@@ -1,34 +0,0 @@
-import { O as _assignValue_default, j as _isIndex_default, z as isObject_default } from "./isArrayLikeObject-C-hFPChh.js";
-import { a as _baseGet_default, o as _toKey_default, r as _baseFlatten_default, s as _castPath_default } from "./hasIn-eLCPDloT.js";
-function flatten(e) {
-  return e != null && e.length ? _baseFlatten_default(e, 1) : [];
-}
-var flatten_default = flatten;
-function baseSet(i, o, s, c) {
-  if (!isObject_default(i)) return i;
-  o = _castPath_default(o, i);
-  for (var l = -1, u = o.length, d = u - 1, f = i; f != null && ++l < u; ) {
-    var p = _toKey_default(o[l]), m = s;
-    if (p === "__proto__" || p === "constructor" || p === "prototype") return i;
-    if (l != d) {
-      var h = f[p];
-      m = c ? c(h, p, f) : void 0, m === void 0 && (m = isObject_default(h) ? h : _isIndex_default(o[l + 1]) ? [] : {});
-    }
-    _assignValue_default(f, p, m), f = f[p];
-  }
-  return i;
-}
-var _baseSet_default = baseSet;
-function basePickBy(e, n, r) {
-  for (var a = -1, o = n.length, s = {}; ++a < o; ) {
-    var c = n[a], l = _baseGet_default(e, c);
-    r(l, c) && _baseSet_default(s, _castPath_default(c, e), l);
-  }
-  return s;
-}
-var _basePickBy_default = basePickBy;
-export {
-  _baseSet_default as n,
-  flatten_default as r,
-  _basePickBy_default as t
-};