es-toolkit 1.13.0 → 1.13.1-dev.297

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # es-toolkit Changelog
 
+## Version v1.13.1
+
+Released on July 20th, 2024.
+
+- Use the compatibility layer `es-toolkit/compat` in legacy CDN builds.
+
 ## Version v1.13.0
 
 Released on July 20th, 2024.

package/dist/browser.js

@@ -40,33 +40,37 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// src/compat/index.ts
+var compat_exports = {};
+__export(compat_exports, {
   AbortError: () => AbortError,
   TimeoutError: () => TimeoutError,
   camelCase: () => camelCase,
   capitalize: () => capitalize,
-  chunk: () => chunk,
+  chunk: () => chunk2,
   clamp: () => clamp,
   clone: () => clone,
   compact: () => compact,
+  concat: () => concat,
   countBy: () => countBy,
   debounce: () => debounce,
   delay: () => delay,
-  difference: () => difference,
+  difference: () => difference2,
   differenceBy: () => differenceBy,
   differenceWith: () => differenceWith,
   drop: () => drop,
   dropRight: () => dropRight,
   dropRightWhile: () => dropRightWhile,
   dropWhile: () => dropWhile,
+  endsWith: () => endsWith,
   fill: () => fill,
+  first: () => head,
   flatMap: () => flatMap,
   flatten: () => flatten,
   flattenDeep: () => flattenDeep,
   flattenObject: () => flattenObject,
   forEachRight: () => forEachRight,
+  get: () => get,
   groupBy: () => groupBy,
   head: () => head,
   inRange: () => inRange,
@@ -80,15 +84,17 @@ __export(src_exports, {
   isNil: () => isNil,
   isNotNil: () => isNotNil,
   isNull: () => isNull,
-  isPlainObject: () => isPlainObject,
+  isPlainObject: () => isPlainObject2,
   isUndefined: () => isUndefined,
   kebabCase: () => kebabCase,
   keyBy: () => keyBy,
   last: () => last,
   lowerCase: () => lowerCase,
+  max: () => max,
   maxBy: () => maxBy,
   mean: () => mean,
   meanBy: () => meanBy,
+  min: () => min,
   minBy: () => minBy,
   negate: () => negate,
   noop: () => noop,
@@ -105,9 +111,11 @@ __export(src_exports, {
   round: () => round,
   sample: () => sample,
   sampleSize: () => sampleSize,
+  set: () => set,
   shuffle: () => shuffle,
   snakeCase: () => snakeCase,
   startCase: () => startCase,
+  startsWith: () => startsWith,
   sum: () => sum,
   sumBy: () => sumBy,
   tail: () => tail,
@@ -132,6 +140,7 @@ __export(src_exports, {
   xorWith: () => xorWith,
   zip: () => zip,
   zipObject: () => zipObject,
+  zipObjectDeep: () => zipObjectDeep,
   zipWith: () => zipWith
 });
 
@@ -324,11 +333,11 @@ function keyBy(arr, getKeyFromItem) {
 // src/array/maxBy.ts
 function maxBy(items, getValue) {
   let maxElement = items[0];
-  let max = -Infinity;
+  let max2 = -Infinity;
   for (const element of items) {
     const value = getValue(element);
-    if (value > max) {
-      max = value;
+    if (value > max2) {
+      max2 = value;
       maxElement = element;
     }
   }
@@ -338,11 +347,11 @@ function maxBy(items, getValue) {
 // src/array/minBy.ts
 function minBy(items, getValue) {
   let minElement = items[0];
-  let min = Infinity;
+  let min2 = Infinity;
   for (const element of items) {
     const value = getValue(element);
-    if (value < min) {
-      min = value;
+    if (value < min2) {
+      min2 = value;
       minElement = element;
     }
   }
@@ -1103,6 +1112,214 @@ function startCase(str) {
   return result;
 }
 
+// src/compat/array/chunk.ts
+function chunk2(arr, size = 1) {
+  size = Math.max(Math.floor(size), 0);
+  if (size === 0) {
+    return [];
+  }
+  return chunk(arr, size);
+}
+
+// src/compat/array/concat.ts
+function concat(...values) {
+  return flatten(values);
+}
+
+// src/compat/array/difference.ts
+function difference2(arr, ...values) {
+  const arr1 = arr;
+  const arr2 = flatten(values);
+  return difference(arr1, arr2);
+}
+
+// src/compat/_internal/isIndex.ts
+var IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value) {
+  switch (typeof value) {
+    case "number": {
+      return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+    }
+    case "symbol": {
+      return false;
+    }
+    case "string": {
+      return IS_UNSIGNED_INTEGER.test(value);
+    }
+  }
+}
+
+// src/compat/_internal/toPath.ts
+function toPath(deepKey) {
+  const ESCAPE_REGEXP = /\\(\\)?/g;
+  const PROPERTY_REGEXP = RegExp(
+    // Match anything that isn't a dot or bracket.
+    `[^.[\\]]+|\\[(?:([^"'][^[]*)|(["'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))`,
+    "g"
+  );
+  const result = [];
+  if (deepKey[0] === ".") {
+    result.push("");
+  }
+  let match;
+  let lastIndex = 0;
+  let count = 0;
+  while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {
+    let [key, expr, quote, substr] = match;
+    if (quote) {
+      key = substr.replace(ESCAPE_REGEXP, "$1");
+    } else if (expr) {
+      key = expr;
+    }
+    result.push(key);
+    if (PROPERTY_REGEXP.lastIndex === lastIndex) {
+      PROPERTY_REGEXP.lastIndex++;
+    } else {
+      lastIndex = PROPERTY_REGEXP.lastIndex;
+    }
+  }
+  return result;
+}
+
+// src/compat/object/set.ts
+function set(obj, path, value) {
+  const resolvedPath = Array.isArray(path) ? path : typeof path === "string" ? toPath(path) : [path];
+  let current = obj;
+  for (let i = 0; i < resolvedPath.length - 1; i++) {
+    const key = resolvedPath[i];
+    const nextKey = resolvedPath[i + 1];
+    if (current[key] == null) {
+      current[key] = isIndex(nextKey) ? [] : {};
+    }
+    current = current[key];
+  }
+  const lastKey = resolvedPath[resolvedPath.length - 1];
+  current[lastKey] = value;
+  return obj;
+}
+
+// src/compat/array/zipObjectDeep.ts
+function zipObjectDeep(keys, values) {
+  const result = {};
+  const zipped = zip(keys, values);
+  for (let i = 0; i < zipped.length; i++) {
+    const [key, value] = zipped[i];
+    if (key != null) {
+      set(result, key, value);
+    }
+  }
+  return result;
+}
+
+// src/compat/_internal/isDeepKey.ts
+var IS_PLAIN = /^\w*$/;
+var IS_DEEP = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+function isDeepKey(key) {
+  switch (typeof key) {
+    case "number":
+    case "symbol": {
+      return false;
+    }
+    case "string": {
+      return !IS_PLAIN.test(key) && IS_DEEP.test(key);
+    }
+  }
+}
+
+// src/compat/object/get.ts
+function get(object, path, defaultValue) {
+  let resolvedPath;
+  if (Array.isArray(path)) {
+    resolvedPath = path;
+  } else if (typeof path === "string" && isDeepKey(path) && (object == null ? void 0 : object[path]) == null) {
+    resolvedPath = toPath(path);
+  } else {
+    resolvedPath = [path];
+  }
+  if (resolvedPath.length === 0) {
+    return defaultValue;
+  }
+  let current = object;
+  let index;
+  for (index = 0; index < resolvedPath.length && current != null; index++) {
+    let key = resolvedPath[index];
+    if (Object.is(key.valueOf(), -0)) {
+      key = "-0";
+    }
+    current = current[key];
+  }
+  if (current === null && index === resolvedPath.length) {
+    return current;
+  }
+  return current != null ? current : defaultValue;
+}
+
+// src/compat/predicate/isPlainObject.ts
+function isPlainObject2(object) {
+  var _a;
+  if (typeof object !== "object") {
+    return false;
+  }
+  if (object == null) {
+    return false;
+  }
+  if (Object.getPrototypeOf(object) === null) {
+    return true;
+  }
+  if (object.toString() !== "[object Object]") {
+    const tag = object[Symbol.toStringTag];
+    if (tag == null) {
+      return false;
+    }
+    const isTagReadonly = !((_a = Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)) == null ? void 0 : _a.writable);
+    if (isTagReadonly) {
+      return false;
+    }
+    return object.toString() === `[object ${tag}]`;
+  }
+  let proto = object;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(object) === proto;
+}
+
+// src/compat/string/startsWith.ts
+var startsWith = (str, target, position = 0) => {
+  return str.startsWith(target, position);
+};
+
+// src/compat/string/endsWith.ts
+var endsWith = (str, target, position = str.length) => {
+  return str.endsWith(target, position);
+};
+
+// src/compat/math/max.ts
+function max(items = []) {
+  let maxElement = items[0];
+  let max2 = void 0;
+  for (const element of items) {
+    if (max2 == null || element > max2) {
+      max2 = element;
+      maxElement = element;
+    }
+  }
+  return maxElement;
+}
+
+// src/compat/math/min.ts
+function min(items = []) {
+  let minElement = items[0];
+  let min2 = void 0;
+  for (const element of items) {
+    if (min2 == null || element < min2) {
+      min2 = element;
+      minElement = element;
+    }
+  }
+  return minElement;
+}
+
 // src/browser.ts
-window._ = src_exports;
+window._ = compat_exports;
 //# sourceMappingURL=browser.js.map