@web-ts-toolkit/utils 0.43.0 → 0.45.0

package/index.js

@@ -1,3 +1,4 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -85,11 +86,24 @@ function addLeadingSlash(value) {
   return value.startsWith("/") ? value : `/${value}`;
 }
 
+// src/dictionary.ts
+function defineOwnDataProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function hasOwnDataProperty(target, key) {
+  return Object.prototype.hasOwnProperty.call(target, key);
+}
+
 // src/arrayToRecord.ts
 function arrayToRecord(arr) {
   const obj = {};
   for (let x = 0; x < arr.length; x++) {
-    obj[arr[x]] = true;
+    defineOwnDataProperty(obj, arr[x], true);
   }
   return obj;
 }
@@ -118,10 +132,16 @@ function isPlainObject(value) {
   return prototype === null || prototype === Object.prototype;
 }
 function normalizePathPart(part) {
-  if (typeof part === "number") {
-    return part;
+  return part;
+}
+function isArrayIndexKey(key) {
+  if (typeof key === "number") {
+    return Number.isInteger(key) && key >= 0 && key < 4294967295;
+  }
+  if (!/^(0|[1-9]\d*)$/.test(key)) {
+    return false;
   }
-  return /^\d+$/.test(part) ? Number(part) : part;
+  return Number(key) < 4294967295;
 }
 function toPath(path) {
   if (Array.isArray(path)) {
@@ -139,6 +159,17 @@ function toPath(path) {
   });
   return result.length > 0 ? result : [input];
 }
+function hasOwnKey(target, key) {
+  return Object.prototype.hasOwnProperty.call(target, key);
+}
+function defineOwnValue(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
 function hasUnsafePathPart(parts) {
   for (let index = 0; index < parts.length; index++) {
     const part = parts[index];
@@ -189,13 +220,16 @@ function setPath(target, path, value) {
   for (let index = 0; index < parts.length - 1; index++) {
     const key = parts[index];
     const nextKey = parts[index + 1];
-    const existing = current[key];
+    const existing = hasOwnKey(current, key) ? current[key] : void 0;
     if (!isObject(existing)) {
-      current[key] = typeof nextKey === "number" ? [] : {};
+      const container = isArrayIndexKey(nextKey) ? [] : {};
+      defineOwnValue(current, key, container);
+      current = container;
+    } else {
+      current = existing;
     }
-    current = current[key];
   }
-  current[parts[parts.length - 1]] = value;
+  defineOwnValue(current, parts[parts.length - 1], value);
   return target;
 }
 function deletePath(target, path) {
@@ -209,6 +243,9 @@ function deletePath(target, path) {
   let current = target;
   for (let index = 0; index < parts.length - 1; index++) {
     const key = parts[index];
+    if (!hasOwnKey(current, key)) {
+      return;
+    }
     const nextValue = current[key];
     if (!isObject(nextValue)) {
       return;
@@ -220,19 +257,14 @@ function deletePath(target, path) {
 function sameValueZero(left, right) {
   return left === right || left !== left && right !== right;
 }
-function arrayIncludes(array, value) {
-  for (let index = 0; index < array.length; index++) {
-    if (sameValueZero(array[index], value)) {
-      return true;
-    }
-  }
-  return false;
-}
 function baseUniq(array) {
+  const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (let index = 0; index < array.length; index++) {
-    if (!arrayIncludes(result, array[index])) {
-      result.push(array[index]);
+    const value = array[index];
+    if (!seen.has(value)) {
+      seen.add(value);
+      result.push(value);
     }
   }
   return result;
@@ -287,14 +319,29 @@ function compareAscending(left, right) {
   return leftString > rightString ? 1 : -1;
 }
 function cloneValue(value) {
-  if (typeof structuredClone === "function") {
-    try {
-      return structuredClone(value);
-    } catch {
-    }
+  if (isExoticRoot(value)) {
+    throw exoticTypeError(value);
   }
-  if (Array.isArray(value)) {
-    return value.map((item) => cloneValue(item));
+  return cloneInner(value, /* @__PURE__ */ new Map());
+}
+function isExoticRoot(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof Date || value instanceof RegExp || Array.isArray(value)) {
+    return false;
+  }
+  return !isPlainObject(value) && !isInheritedPlainLike(value);
+}
+function exoticTypeError(value) {
+  const name = typeof value.constructor?.name === "string" && value.constructor.name.length > 0 ? value.constructor.name : typeof value;
+  return new TypeError(
+    `cloneDeep: unsupported value of type ${name}; only plain objects, arrays, Date, and RegExp can be cloned`
+  );
+}
+function cloneInner(value, seen) {
+  if (value === null || typeof value !== "object") {
+    return value;
   }
   if (value instanceof Date) {
     return new Date(value.getTime());
@@ -302,55 +349,205 @@ function cloneValue(value) {
   if (value instanceof RegExp) {
     return new RegExp(value.source, value.flags);
   }
-  if (isPlainObject(value)) {
-    const result = {};
-    const keys2 = Object.keys(value);
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      return seen.get(value);
+    }
+    const result = [];
+    seen.set(value, result);
+    for (let index = 0; index < value.length; index++) {
+      if (hasOwnKey(value, index)) {
+        defineOwnValue(result, index, cloneInner(value[index], seen));
+      }
+    }
+    copyOwnEnumerableExtras(value, result, seen);
+    return result;
+  }
+  if (isPlainObject(value) || isInheritedPlainLike(value)) {
+    if (seen.has(value)) {
+      return seen.get(value);
+    }
+    const source = value;
+    const prototype = Object.getPrototypeOf(source);
+    const result = Object.create(prototype);
+    seen.set(source, result);
+    const keys2 = ownEnumerableKeys(source);
     for (let index = 0; index < keys2.length; index++) {
       const key = keys2[index];
-      result[key] = cloneValue(value[key]);
+      const child = source[key];
+      defineOwnValue(result, key, cloneInner(child, seen));
     }
     return result;
   }
   return value;
 }
+function isInheritedPlainLike(value) {
+  let current = value;
+  while (current !== null) {
+    const prototype = Object.getPrototypeOf(current);
+    if (prototype === null || prototype === Object.prototype) {
+      return true;
+    }
+    const constructor = prototype.constructor;
+    if (constructor !== void 0 && constructor !== Object) {
+      return false;
+    }
+    current = prototype;
+  }
+  return true;
+}
+function ownEnumerableKeys(source) {
+  const keys2 = Object.keys(source);
+  const symbols = Object.getOwnPropertySymbols(source);
+  for (let index = 0; index < symbols.length; index++) {
+    if (Object.prototype.propertyIsEnumerable.call(source, symbols[index])) {
+      keys2.push(symbols[index]);
+    }
+  }
+  return keys2;
+}
+function copyOwnEnumerableExtras(source, target, seen) {
+  const keys2 = ownEnumerableKeys(source);
+  for (let index = 0; index < keys2.length; index++) {
+    const key = keys2[index];
+    if (typeof key === "string" && /^(0|[1-9]\d*)$/.test(key)) {
+      const numeric = Number(key);
+      if (Number.isInteger(numeric) && numeric >= 0 && numeric < source.length) {
+        continue;
+      }
+    }
+    if (hasOwnKey(target, key)) {
+      continue;
+    }
+    defineOwnValue(target, key, cloneInner(source[key], seen));
+  }
+}
 function deepEqual(left, right) {
+  return deepEqualInner(left, right, /* @__PURE__ */ new Map());
+}
+function pairsHas(pairs, left, right) {
+  return pairs.get(left)?.has(right) ?? false;
+}
+function pairsAdd(pairs, left, right) {
+  let set2 = pairs.get(left);
+  if (set2 === void 0) {
+    set2 = /* @__PURE__ */ new Set();
+    pairs.set(left, set2);
+  }
+  set2.add(right);
+}
+function pairsDelete(pairs, left, right) {
+  const set2 = pairs.get(left);
+  if (set2 === void 0) {
+    return;
+  }
+  set2.delete(right);
+  if (set2.size === 0) {
+    pairs.delete(left);
+  }
+}
+function isComparableObject(value) {
+  return typeof value === "object" && value !== null && (isPlainObject(value) || isInheritedPlainLike(value));
+}
+function isExtraArrayKey(key, length) {
+  if (typeof key === "symbol") {
+    return true;
+  }
+  if (/^(0|[1-9]\d*)$/.test(key)) {
+    const numeric = Number(key);
+    if (Number.isInteger(numeric) && numeric >= 0 && numeric < length) {
+      return false;
+    }
+  }
+  return true;
+}
+function deepEqualInner(left, right, pairs) {
   if (sameValueZero(left, right)) {
     return true;
   }
-  if (left instanceof Date && right instanceof Date) {
-    return left.getTime() === right.getTime();
+  if (left instanceof Date || right instanceof Date) {
+    return left instanceof Date && right instanceof Date && sameValueZero(left.getTime(), right.getTime());
   }
-  if (left instanceof RegExp && right instanceof RegExp) {
-    return left.source === right.source && left.flags === right.flags;
+  if (left instanceof RegExp || right instanceof RegExp) {
+    return left instanceof RegExp && right instanceof RegExp && left.source === right.source && left.flags === right.flags;
   }
   if (Array.isArray(left) || Array.isArray(right)) {
     if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
       return false;
     }
-    for (let index = 0; index < left.length; index++) {
-      if (!deepEqual(left[index], right[index])) {
+    if (pairsHas(pairs, left, right)) {
+      return true;
+    }
+    pairsAdd(pairs, left, right);
+    try {
+      for (let index = 0; index < left.length; index++) {
+        const leftHas = hasOwnKey(left, index);
+        const rightHas = hasOwnKey(right, index);
+        if (leftHas !== rightHas) {
+          return false;
+        }
+        if (leftHas && !deepEqualInner(left[index], right[index], pairs)) {
+          return false;
+        }
+      }
+      const leftExtras = ownEnumerableKeys(left).filter((key) => isExtraArrayKey(key, left.length));
+      const rightExtras = ownEnumerableKeys(right).filter((key) => isExtraArrayKey(key, right.length));
+      if (leftExtras.length !== rightExtras.length) {
         return false;
       }
+      for (let index = 0; index < leftExtras.length; index++) {
+        const key = leftExtras[index];
+        if (!hasOwnKey(right, key)) {
+          return false;
+        }
+        if (!deepEqualInner(
+          left[key],
+          right[key],
+          pairs
+        )) {
+          return false;
+        }
+      }
+      return true;
+    } finally {
+      pairsDelete(pairs, left, right);
     }
-    return true;
   }
-  if (!isObject(left) || !isObject(right)) {
+  if (!isComparableObject(left) || !isComparableObject(right)) {
     return false;
   }
-  const leftKeys = Object.keys(left);
-  const rightKeys = Object.keys(right);
-  if (leftKeys.length !== rightKeys.length) {
-    return false;
+  if (pairsHas(pairs, left, right)) {
+    return true;
   }
-  for (let index = 0; index < leftKeys.length; index++) {
-    const key = leftKeys[index];
-    if (!(key in right) || !deepEqual(left[key], right[key])) {
+  pairsAdd(pairs, left, right);
+  try {
+    const leftKeys = ownEnumerableKeys(left);
+    const rightKeys = ownEnumerableKeys(right);
+    if (leftKeys.length !== rightKeys.length) {
       return false;
     }
+    for (let index = 0; index < leftKeys.length; index++) {
+      const key = leftKeys[index];
+      if (!hasOwnKey(right, key)) {
+        return false;
+      }
+      if (!deepEqualInner(
+        left[key],
+        right[key],
+        pairs
+      )) {
+        return false;
+      }
+    }
+    return true;
+  } finally {
+    pairsDelete(pairs, left, right);
   }
-  return true;
 }
 function partialMatch(object, source) {
+  return partialMatchInner(object, source, /* @__PURE__ */ new Map());
+}
+function partialMatchInner(object, source, pairs) {
   if (sameValueZero(object, source)) {
     return true;
   }
@@ -358,27 +555,70 @@ function partialMatch(object, source) {
     if (!Array.isArray(object) || object.length < source.length) {
       return false;
     }
-    for (let index = 0; index < source.length; index++) {
-      if (!partialMatch(object[index], source[index])) {
-        return false;
+    if (pairsHas(pairs, source, object)) {
+      return true;
+    }
+    pairsAdd(pairs, source, object);
+    try {
+      for (let index = 0; index < source.length; index++) {
+        if (!hasOwnKey(source, index)) {
+          continue;
+        }
+        if (!hasOwnKey(object, index)) {
+          return false;
+        }
+        if (!partialMatchInner(object[index], source[index], pairs)) {
+          return false;
+        }
+      }
+      const sourceExtras = ownEnumerableKeys(source).filter((key) => isExtraArrayKey(key, source.length));
+      for (let index = 0; index < sourceExtras.length; index++) {
+        const key = sourceExtras[index];
+        if (!hasOwnKey(object, key)) {
+          return false;
+        }
+        if (!partialMatchInner(
+          object[key],
+          source[key],
+          pairs
+        )) {
+          return false;
+        }
       }
+      return true;
+    } finally {
+      pairsDelete(pairs, source, object);
     }
-    return true;
   }
-  if (isPlainObject(source)) {
+  if (isPlainObject(source) || typeof source === "object" && source !== null && isInheritedPlainLike(source)) {
     if (!isObject(object)) {
       return false;
     }
-    const keys2 = Object.keys(source);
-    for (let index = 0; index < keys2.length; index++) {
-      const key = keys2[index];
-      if (!partialMatch(object[key], source[key])) {
-        return false;
+    if (pairsHas(pairs, source, object)) {
+      return true;
+    }
+    pairsAdd(pairs, source, object);
+    try {
+      const keys2 = ownEnumerableKeys(source);
+      for (let index = 0; index < keys2.length; index++) {
+        const key = keys2[index];
+        if (!hasOwnKey(object, key)) {
+          return false;
+        }
+        if (!partialMatchInner(
+          object[key],
+          source[key],
+          pairs
+        )) {
+          return false;
+        }
       }
+      return true;
+    } finally {
+      pairsDelete(pairs, source, object);
     }
-    return true;
   }
-  return deepEqual(object, source);
+  return deepEqualInner(object, source, pairs);
 }
 
 // src/cloneDeep.ts
@@ -400,7 +640,8 @@ function difference(array, ...values) {
     return [];
   }
   const excluded = values.flatMap((value) => Array.isArray(value) ? value : []);
-  return array.filter((item) => !arrayIncludes(excluded, item));
+  const excludedSet = new Set(excluded);
+  return array.filter((item) => !excludedSet.has(item));
 }
 
 // src/eachRight.ts
@@ -501,10 +742,23 @@ function flattenDeep(array) {
     return [];
   }
   const result = [];
-  for (let index = 0; index < array.length; index++) {
-    const value = array[index];
+  const stack = [{ values: array, index: 0 }];
+  const ancestors = /* @__PURE__ */ new Set([array]);
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (frame.index >= frame.values.length) {
+      stack.pop();
+      ancestors.delete(frame.values);
+      continue;
+    }
+    const value = frame.values[frame.index];
+    frame.index += 1;
     if (Array.isArray(value)) {
-      result.push(...flattenDeep(value));
+      if (ancestors.has(value)) {
+        throw new TypeError("flattenDeep: cyclic array reference is not supported");
+      }
+      ancestors.add(value);
+      stack.push({ values: value, index: 0 });
     } else {
       result.push(value);
     }
@@ -552,7 +806,12 @@ function groupBy(collection, iteratee) {
     for (let index = 0; index < collection.length; index++) {
       const value = collection[index];
       const key = String(callback(value, index, collection));
-      (result[key] ??= []).push(value);
+      let bucket = hasOwnDataProperty(result, key) ? result[key] : void 0;
+      if (bucket === void 0) {
+        bucket = [];
+        defineOwnDataProperty(result, key, bucket);
+      }
+      bucket.push(value);
     }
     return result;
   }
@@ -561,7 +820,12 @@ function groupBy(collection, iteratee) {
     const key = keys2[index];
     const value = collection[key];
     const group = String(callback(value, key, collection));
-    (result[group] ??= []).push(value);
+    let bucket = hasOwnDataProperty(result, group) ? result[group] : void 0;
+    if (bucket === void 0) {
+      bucket = [];
+      defineOwnDataProperty(result, group, bucket);
+    }
+    bucket.push(value);
   }
   return result;
 }
@@ -581,7 +845,8 @@ function intersection(...arrays) {
     return [];
   }
   const uniqueValues = baseUniq(first);
-  return uniqueValues.filter((value) => rest.every((array) => Array.isArray(array) && arrayIncludes(array, value)));
+  const restSets = rest.map((array) => Array.isArray(array) ? new Set(array) : null);
+  return uniqueValues.filter((value) => restSets.every((set2) => set2 !== null && set2.has(value)));
 }
 
 // src/intersectionBy.ts
@@ -596,17 +861,16 @@ function intersectionBy(...args) {
   }
   const [first, ...rest] = sources;
   const result = [];
-  const seen = [];
+  const seen = /* @__PURE__ */ new Set();
+  const restSets = rest.map((array) => new Set(array.map((value) => callback(value))));
   for (let index = 0; index < first.length; index++) {
     const item = first[index];
     const computed = callback(item);
-    if (seen.some((entry) => sameValueZero(entry, computed))) {
+    if (seen.has(computed)) {
       continue;
     }
-    if (rest.every(
-      (array) => baseUniq(array.map((value) => callback(value))).some((entry) => sameValueZero(entry, computed))
-    )) {
-      seen.push(computed);
+    if (restSets.every((set2) => set2.has(computed))) {
+      seen.add(computed);
       result.push(item);
     }
   }
@@ -620,7 +884,7 @@ function isArray(value) {
 
 // src/isBoolean.ts
 function isBoolean(value) {
-  return value === true || value === false || value instanceof Boolean;
+  return typeof value === "boolean";
 }
 
 // src/isEmpty.ts
@@ -670,7 +934,7 @@ function isNil(value) {
 
 // src/isNumber.ts
 function isNumber(value) {
-  return typeof value === "number" || value instanceof Number;
+  return typeof value === "number";
 }
 
 // src/isObject.ts
@@ -690,7 +954,7 @@ function isPromise(value) {
 
 // src/isString.ts
 function isString(value) {
-  return typeof value === "string" || value instanceof String;
+  return typeof value === "string";
 }
 
 // src/isUndefined.ts
@@ -744,7 +1008,8 @@ function mapKeys(object, iteratee) {
   const keys2 = Object.keys(object);
   for (let index = 0; index < keys2.length; index++) {
     const key = keys2[index];
-    result[String(iteratee(object[key], key, object))] = object[key];
+    const mappedKey = String(iteratee(object[key], key, object));
+    defineOwnDataProperty(result, mappedKey, object[key]);
   }
   return result;
 }
@@ -758,7 +1023,7 @@ function mapValues(object, iteratee) {
   const keys2 = Object.keys(object);
   for (let index = 0; index < keys2.length; index++) {
     const key = keys2[index];
-    result[key] = iteratee(object[key], key, object);
+    defineOwnDataProperty(result, key, iteratee(object[key], key, object));
   }
   return result;
 }
@@ -782,6 +1047,9 @@ function omit(object, paths) {
     return {};
   }
   const result = cloneDeep(object);
+  if (result === object) {
+    throw new TypeError("omit: unsupported object type; input cannot be cloned without aliasing");
+  }
   const pathList = Array.isArray(paths) ? paths : [paths];
   for (let index = 0; index < pathList.length; index++) {
     deletePath(result, pathList[index]);
@@ -800,7 +1068,7 @@ function omitBy(object, predicate) {
     const key = keys2[index];
     const value = object[key];
     if (!predicate(value, key, object)) {
-      result[key] = value;
+      defineOwnDataProperty(result, key, value);
     }
   }
   return result;
@@ -816,7 +1084,9 @@ function orderBy(collection, iteratees = [], orders = []) {
   if (!Array.isArray(collection)) {
     return [];
   }
-  const callbacks = (iteratees.length > 0 ? iteratees : [void 0]).map((iteratee) => getIteratee(iteratee));
+  const callbacks = (iteratees.length > 0 ? iteratees : [void 0]).map(
+    (iteratee) => getIteratee(iteratee)
+  );
   return [...collection].map((value, index) => ({ value, index })).sort((left, right) => {
     for (let index = 0; index < callbacks.length; index++) {
       const callback = callbacks[index];
@@ -862,7 +1132,7 @@ function pickBy(object, predicate) {
     const key = keys2[index];
     const value = object[key];
     if (predicate(value, key, object)) {
-      result[key] = value;
+      defineOwnDataProperty(result, key, value);
     }
   }
   return result;
@@ -968,7 +1238,7 @@ function toStringRecord(value) {
   const entries = Object.entries(value);
   for (let index = 0; index < entries.length; index++) {
     const [key, entryValue] = entries[index];
-    result[key] = String(entryValue);
+    defineOwnDataProperty(result, key, String(entryValue));
   }
   return entries.length > 0 ? result : void 0;
 }
@@ -988,14 +1258,14 @@ function uniqBy(array, iteratee) {
   }
   const callback = getIteratee(iteratee);
   const result = [];
-  const seen = [];
+  const seen = /* @__PURE__ */ new Set();
   for (let index = 0; index < array.length; index++) {
     const value = array[index];
     const computed = callback(value, index, array);
-    if (seen.some((entry) => sameValueZero(entry, computed))) {
+    if (seen.has(computed)) {
       continue;
     }
-    seen.push(computed);
+    seen.add(computed);
     result.push(value);
   }
   return result;