@superutils/core 1.0.0

package/dist/index.js

@@ -0,0 +1,931 @@
+// src/forceCast.ts
+var asAny = (x) => x;
+var forceCast = (x) => x;
+var forceCast_default = forceCast;
+
+// src/curry.ts
+function curry(func, ...[arity = func.length]) {
+  const curriedFn = (...args) => {
+    const _args = args;
+    if (_args.length >= arity) return func(...forceCast_default(args));
+    return (...nextArgs) => asAny(curriedFn)(
+      ..._args,
+      ...nextArgs
+    );
+  };
+  return curriedFn;
+}
+
+// src/is/isObj.ts
+var isObj = (x, strict = true) => !!x && typeof x === "object" && (!strict || [
+  Object.prototype,
+  null
+  // when an object is created using `Object.create(null)`
+].includes(Object.getPrototypeOf(x)));
+var isObj_default = isObj;
+
+// src/is/isArr.ts
+var isArr = (x) => Array.isArray(x);
+var isArrObj = (x, strict = true) => isArr(x) && x.every((x2) => isObj(x2, strict));
+var isArr2D = (x) => isArr(x) && x.every(isArr);
+var isArrLike = (x) => isArr(x) || x instanceof Set || x instanceof Map;
+var isArrLikeSafe = (x) => ["[object Array]", "[object Map]", "[object Set]"].includes(
+  Object.prototype.toString.call(x)
+);
+var isArrUnique = (arr) => isArr(arr) && new Set(arr).size === arr.length;
+var isUint8Arr = (arr) => arr instanceof Uint8Array;
+var isArr_default = isArr;
+
+// src/is/isDate.ts
+var isDate = (x) => x instanceof Date;
+var isDateValid = (date) => {
+  const dateIsStr = typeof date === "string";
+  if (!dateIsStr && !isDate(date)) return false;
+  const dateObj = new Date(date);
+  if (Number.isNaN(dateObj.getTime())) return false;
+  if (!dateIsStr) return true;
+  const [original, converted] = [date, dateObj.toISOString()].map(
+    (y) => y.replace(/[TZ]/g, "").substring(0, 10)
+  );
+  return original === converted;
+};
+var isDate_default = isDate;
+
+// src/is/isNumber.ts
+var isInteger = (x) => Number.isInteger(x);
+var isPositiveInteger = (x) => isInteger(x) && x > 0;
+var isPositiveNumber = (x) => isNumber(x) && x > 0;
+var isNumber = (x) => typeof x == "number" && !Number.isNaN(x) && Number.isFinite(x);
+
+// src/is/isEmpty.ts
+var isEmpty = (x, nonNumerable = false, fallback = false) => {
+  if (x === null || x === void 0) return true;
+  switch (typeof x) {
+    case "number":
+      return !isNumber(x);
+    case "string":
+      return !x.replaceAll("	", "").trim().length;
+    case "boolean":
+    case "bigint":
+    case "symbol":
+    case "function":
+      return false;
+  }
+  if (x instanceof Date) return Number.isNaN(x.getTime());
+  if (x instanceof Map || x instanceof Set) return !x.size;
+  if (Array.isArray(x) || x instanceof Uint8Array) return !x.length;
+  if (x instanceof Error) return !x.message.length;
+  const proto = typeof x === "object" && Object.getPrototypeOf(x);
+  if (proto === Object.prototype || proto === null) {
+    return nonNumerable ? !Object.getOwnPropertyNames(x).length : !Object.keys(x).length;
+  }
+  return fallback;
+};
+var isEmptySafe = (x, numberableOnly = false) => {
+  const empty = isEmpty(x, numberableOnly, 0);
+  if (empty !== 0) return empty;
+  switch (Object.prototype.toString.call(x)) {
+    case "[object Uint8Array]":
+      return !x.length;
+    case "[object Date]":
+      return Number.isNaN(x.getTime());
+    case "[object Map]":
+      return !x.size;
+    case "[object Object]":
+      return !Object.keys(x).length;
+    case "[object Set]":
+      return !x.size;
+    default:
+      return false;
+  }
+};
+var isEmpty_default = isEmpty;
+
+// src/is/isEnv.ts
+var isEnvBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
+var isEnvNode = () => {
+  var _a;
+  return typeof process !== "undefined" && ((_a = process == null ? void 0 : process.versions) == null ? void 0 : _a.node) != null;
+};
+var isEnvTouchable = () => {
+  try {
+    return "ontouchstart" in window.document.documentElement;
+  } catch (_) {
+    return false;
+  }
+};
+
+// src/noop.ts
+function noop() {
+}
+async function noopAsync() {
+}
+
+// src/is/isFn.ts
+var isFn = (x) => typeof x === "function";
+var isAsyncFn = (x) => x instanceof noopAsync.constructor && x[Symbol.toStringTag] === "AsyncFunction";
+var isFn_default = isFn;
+
+// src/is/isMap.ts
+var isMap = (x) => x instanceof Map;
+var isMapObj = (x, strict = true) => isMap(x) && [...x.values()].every((value) => isObj_default(value, strict));
+
+// src/is/isUrl.ts
+var isUrl = (x) => x instanceof URL;
+var isUrlValid = (x, strict = true, tldExceptions = ["localhost"]) => {
+  if (!x) return false;
+  try {
+    if (typeof x !== "string" && !isUrl(x)) return false;
+    const url = isUrl(x) ? x : new URL(x);
+    if (!strict) return true;
+    const gotTld = tldExceptions.includes(url.hostname) || url.host.split(".").length > 1;
+    if (!gotTld) return false;
+    let y = `${x}`;
+    if (y.endsWith(url.hostname)) y += "/";
+    return url.href === y;
+  } catch (_) {
+    return false;
+  }
+};
+var isUrl_default = isUrl;
+
+// src/is/index.ts
+var isBool = (x) => typeof x === "boolean" || x instanceof Boolean;
+var isDefined = (x) => x !== void 0 && x !== null;
+var isError = (x) => x instanceof Error;
+var isPromise = (x) => x instanceof Promise;
+var isRegExp = (x) => x instanceof RegExp;
+var isSet = (x) => x instanceof Set;
+var isStr = (x) => typeof x === "string";
+var isSymbol = (x) => typeof x === "symbol";
+var is = {
+  arr: isArr_default,
+  arr2D: isArr2D,
+  arrLike: isArrLike,
+  arrLikeSafe: isArrLikeSafe,
+  arrObj: isArrObj,
+  arrUnique: isArrUnique,
+  asyncFn: isAsyncFn,
+  bool: isBool,
+  date: isDate_default,
+  dateValid: isDateValid,
+  defined: isDefined,
+  empty: isEmpty_default,
+  emptySafe: isEmptySafe,
+  envBrowser: isEnvBrowser,
+  envNode: isEnvNode,
+  envTouchable: isEnvTouchable,
+  error: isError,
+  fn: isFn_default,
+  integer: isInteger,
+  map: isMap,
+  mapObj: isMapObj,
+  number: isNumber,
+  obj: isObj_default,
+  positiveInteger: isPositiveInteger,
+  positiveNumber: isPositiveNumber,
+  promise: isPromise,
+  regExp: isRegExp,
+  set: isSet,
+  str: isStr,
+  // subjectLike: isSubjectLike,
+  symbol: isSymbol,
+  uint8Arr: isUint8Arr,
+  url: isUrl_default,
+  urlValid: isUrlValid
+};
+
+// src/fallbackIfFails.ts
+var fallbackIfFails = (target, args, fallbackValue) => {
+  let result;
+  try {
+    result = !isFn(target) ? target : target(...isFn(args) ? args() : args);
+    if (!isPromise(result)) return result;
+    result = result.catch(getAltValCb(fallbackValue));
+  } catch (error) {
+    result = getAltValCb(fallbackValue)(error);
+  }
+  return result;
+};
+var fallbackIfFails_default = fallbackIfFails;
+var getAltValCb = (fallbackValue) => (error) => isFn(fallbackValue) ? fallbackValue(error) : fallbackValue;
+
+// src/deferred.ts
+var deferred = (callback, delay = 50, config = {}) => {
+  const {
+    leading = deferred.defaults.leading,
+    onError = deferred.defaults.onError,
+    thisArg
+  } = config;
+  let { tid } = config;
+  if (thisArg !== void 0) callback = callback.bind(thisArg);
+  const _callback = (...args) => fallbackIfFails_default(callback, args, onError);
+  let firstArgs = null;
+  const leadingGlobal = leading === "global";
+  return (...args) => {
+    clearTimeout(tid);
+    tid = setTimeout(() => {
+      firstArgs !== args && _callback(...args);
+      firstArgs = leadingGlobal ? true : null;
+    }, delay);
+    if (!leading || firstArgs) return;
+    firstArgs = args;
+    _callback(...args);
+  };
+};
+deferred.defaults = {
+  /**
+   * Set the default value of argument `leading` for the `deferred` function.
+   * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+   */
+  leading: false,
+  /**
+   * Set the default value of argument `onError` for the `deferred` function.
+   * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+   */
+  onError: void 0
+};
+var deferred_default = deferred;
+
+// src/debounce.ts
+function debounce(...args) {
+  return deferred_default(...args);
+}
+
+// src/throttled.ts
+var throttled = (callback, delay = 50, config = {}) => {
+  const { defaults: d } = throttled;
+  const { onError = d.onError, trailing = d.trailing, thisArg } = config;
+  let { tid } = config;
+  if (thisArg !== void 0) callback = callback.bind(thisArg);
+  const _callback = (...args) => fallbackIfFails_default(callback, args, onError);
+  let trailArgs = null;
+  return (...args) => {
+    if (tid) {
+      trailArgs = args;
+      return;
+    }
+    tid = setTimeout(() => {
+      tid = void 0;
+      if (!trailing) return;
+      const cbArgs = trailArgs;
+      trailArgs = null;
+      cbArgs && cbArgs !== args && _callback(...cbArgs);
+    }, delay);
+    _callback(...args);
+  };
+};
+throttled.defaults = {
+  onError: void 0,
+  trailing: true
+};
+
+// src/toDatetimeLocal.ts
+var toDatetimeLocal = (dateStr) => {
+  const date = new Date(dateStr);
+  if (!isDateValid(date)) return "";
+  const year = date.getFullYear();
+  const month = (date.getMonth() + 1).toString().padStart(2, "0");
+  const day = date.getDate().toString().padStart(2, "0");
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  const res = `${year}-${month}-${day}T${hours}:${minutes}`;
+  return res;
+};
+(/* @__PURE__ */ new Date()).getTime();
+
+// src/obj/objClean.ts
+var objClean = (obj, keys, ignoreIfNotExist = true) => {
+  const result = {};
+  if (!isObj(obj) || !isArr(keys)) return result;
+  const uniqKeys = arrUnique(
+    keys.map((x) => isStr(x) ? `${x}`.split(".")[0] : x)
+  ).sort();
+  for (const key of uniqKeys) {
+    if (ignoreIfNotExist && !obj.hasOwnProperty(key)) continue;
+    const value = obj[key];
+    if (!isObj(value) || isSymbol(key)) {
+      result[key] = value;
+      continue;
+    }
+    const childPrefix = `${key}.`;
+    const childKeys = keys.filter((k) => {
+      var _a;
+      return (_a = k == null ? void 0 : k.startsWith) == null ? void 0 : _a.call(k, childPrefix);
+    }).map((k) => k.split(childPrefix)[1]);
+    if (!childKeys.length) {
+      result[key] = value;
+      continue;
+    }
+    result[key] = objClean(
+      value,
+      childKeys
+    );
+  }
+  return result;
+};
+
+// src/obj/objKeys.ts
+var objKeys = (obj, sorted = true, includeSymbols = true) => fallbackIfFails_default(
+  () => [
+    ...includeSymbols && Object.getOwnPropertySymbols(obj) || [],
+    ...sorted ? Object.keys(obj).sort() : Object.keys(obj)
+  ],
+  [],
+  []
+);
+var objKeys_default = objKeys;
+
+// src/obj/objCopy.ts
+var clone = (value, fallback = "null") => JSON.parse(fallbackIfFails_default(JSON.stringify, [value], fallback));
+var objCopy = (input, output, ignoreKeys, override = false, recursive = true) => {
+  if (!isObj(output)) output = {};
+  if (!isObj(input)) return output;
+  const _ignoreKeys = new Set(ignoreKeys != null ? ignoreKeys : []);
+  const inKeys = objKeys_default(input, true, true).filter(
+    (x) => !_ignoreKeys.has(x)
+  );
+  for (const _key of inKeys) {
+    const key = _key;
+    const value = input[key];
+    const skip = output.hasOwnProperty(key) && (!override || override === "empty" && !isEmpty(output[key]));
+    if (skip) continue;
+    const isPrimitive = [void 0, null, Infinity, NaN].includes(asAny(value)) || !isObj(value, false);
+    if (isPrimitive) {
+      output[key] = value;
+      continue;
+    }
+    output[key] = (() => {
+      switch (Object.getPrototypeOf(value)) {
+        case Array.prototype:
+          return clone(value, "[]");
+        case ArrayBuffer.prototype:
+          return asAny(value).slice(0);
+        case Date.prototype:
+          return new Date(asAny(value).getTime());
+        case Map.prototype:
+          return new Map(
+            clone(
+              Array.from(asAny(value)),
+              "[]"
+            )
+          );
+        case RegExp.prototype:
+          return new RegExp(asAny(value));
+        case Set.prototype:
+          return new Set(
+            clone(Array.from(asAny(value)))
+          );
+        case Uint8Array.prototype:
+          return new Uint8Array([...asAny(value)]);
+        case URL.prototype:
+          return new URL(asAny(value));
+        default:
+          break;
+      }
+      if (isSymbol(key) || !recursive) return clone(value);
+      const ignoreChildKeys = [..._ignoreKeys].map(
+        (x) => !isSymbol(x) && x.startsWith(key.concat(".")) && x.split(key.concat("."))[1]
+      ).filter(Boolean);
+      if (!ignoreChildKeys.length) return clone(value);
+      return objCopy(
+        value,
+        output[key],
+        ignoreChildKeys,
+        override,
+        recursive
+      );
+    })();
+  }
+  return output;
+};
+
+// src/obj/objCreate.ts
+var objCreate = (keys = [], values = [], result) => {
+  if (!isObj(result)) result = {};
+  for (let i = 0; i < (isArr(keys) ? keys : []).length; i++) {
+    ;
+    result[keys[i]] = values == null ? void 0 : values[i];
+  }
+  return result;
+};
+
+// src/obj/objReadOnly.ts
+var objReadOnly = (obj, config) => {
+  if (!isObj(obj, false)) obj = {};
+  const { add, revocable, silent = true } = config != null ? config : {};
+  const [typeTitle, keyTitle] = isArr(obj) ? ["array", "index"] : ["object", "property name"];
+  function handleSetProp(obj2, key, value) {
+    const isUpdate = obj2[key] !== void 0;
+    if (isUpdate && silent) return true;
+    const allowAddition = !isUpdate && (!isFn(add) ? add : add(obj2, key, value));
+    const shouldThrow = !silent && (isUpdate || !allowAddition);
+    if (shouldThrow)
+      throw new TypeError(
+        `Mutation not allow on read-only ${typeTitle} ${keyTitle}: ${key.toString()}`
+      );
+    if (!allowAddition) return true;
+    obj2[key] = value;
+    return true;
+  }
+  const proxyHandler = {
+    get: (obj2, key) => obj2[key],
+    set: handleSetProp,
+    defineProperty: (obj2, key, { value }) => handleSetProp(obj2, key, value),
+    // Prevent removal of properties
+    deleteProperty: (obj2, key) => {
+      if (!silent && obj2.hasOwnProperty(key)) {
+        throw new Error(
+          `Mutation not allow on read-only ${typeTitle} ${keyTitle}: ${key.toString()}`
+        );
+      }
+      return true;
+    }
+  };
+  return revocable ? Proxy.revocable(obj, proxyHandler) : new Proxy(obj, proxyHandler);
+};
+
+// src/obj/objSetProp.ts
+var objSetProp = (obj, key, falsyValue, condition, truthyValue) => {
+  var _a;
+  const result = !isObj(obj, false) ? {} : obj;
+  falsyValue != null ? falsyValue : falsyValue = result[key];
+  condition = isFn(condition) ? condition((_a = result[key]) != null ? _a : falsyValue, key, obj) : condition;
+  result[key] = !condition ? falsyValue : truthyValue;
+  return result;
+};
+var objSetPropUndefined = (...[obj, key, ...args]) => (obj == null ? void 0 : obj[key]) === void 0 && objSetProp(obj, key, ...args) || obj;
+
+// src/obj/objSort.ts
+var objSort = (obj, recursive = true, _done = /* @__PURE__ */ new Map()) => {
+  const sorted = {};
+  if (!isObj(obj)) return sorted;
+  for (const key of objKeys_default(obj)) {
+    const value = obj[key];
+    _done.set(value, true);
+    sorted[key] = !recursive || !isObj(value) ? value : objSort(
+      value,
+      recursive,
+      _done
+    );
+  }
+  return sorted;
+};
+
+// src/obj/objWithoutKeys.ts
+var objWithoutKeys = (input, keys, output) => {
+  if (!isObj(input, false)) return {};
+  if (!isArr(keys) || !keys.length) return input;
+  output = {
+    ...isObj(output, false) && output,
+    ...input
+  };
+  for (const key of keys) delete output[key];
+  return output;
+};
+
+// src/arr/arrReadOnly.ts
+var arrReadOnly = (arr, config = {}) => objReadOnly(new ReadOnlyArrayHelper(config, arr), config);
+var ReadOnlyArrayHelper = class extends Array {
+  constructor(config, arr) {
+    var _a;
+    (_a = config.silent) != null ? _a : config.silent = true;
+    super(...arr);
+    this.config = config;
+    this.ignoreOrThrow = (returnValue) => {
+      if (this.config.silent) return returnValue;
+      throw new Error("Mutation not allowed on read-only array");
+    };
+    this.pop = () => this.ignoreOrThrow(this[this.length - 1]);
+    this.push = (...items) => !this.config.add ? this.ignoreOrThrow(this.length) : super.push(...items);
+    this.reverse = () => this.ignoreOrThrow(this);
+    this.shift = () => this.ignoreOrThrow(this[0]);
+    this.splice = (..._ignoredArgs) => this.ignoreOrThrow([]);
+    this.unshift = (..._ignoredArgs) => this.ignoreOrThrow(this.length);
+    // fromAsync = super.fromAsync
+    this.reduce = super.reduce;
+    this.reduceRight = super.reduceRight;
+  }
+};
+
+// src/arr/arrReverse.ts
+var arrReverse = (arr, reverse2 = true, newArray = false) => {
+  if (!isArr(arr)) return [];
+  if (newArray) arr = [...arr];
+  return reverse2 ? arr.reverse() : arr;
+};
+
+// src/arr/arrToMap.ts
+function arrToMap(arr, key, flatDepth = 0) {
+  ;
+  [key, flatDepth] = isNumber(key) ? [void 0, key] : [key, flatDepth];
+  const flatEntries = (!isArr(arr) ? [] : flatDepth > 0 ? arr.flat(flatDepth) : arr).map((item, i, flatArr) => {
+    var _a;
+    return [
+      (_a = isFn(key) ? key(item, i, flatArr) : isObj(item) && isDefined(key) ? item[key] : i) != null ? _a : i,
+      item
+    ];
+  });
+  return new Map(flatEntries);
+}
+
+// src/arr/arrUnique.ts
+var arrUnique = (arr, flatDepth = 0) => !isArr(arr) ? [] : Array.from(new Set(arr.flat(flatDepth)));
+
+// src/iterable/filter.ts
+var filter = (data, predicate, limit = Infinity, asArray = false, result = /* @__PURE__ */ new Map()) => {
+  var _a;
+  if (!isMap(result)) result = /* @__PURE__ */ new Map();
+  for (const [key, item] of ((_a = data == null ? void 0 : data.entries) == null ? void 0 : _a.call(data)) || []) {
+    if (result.size >= limit) break;
+    fallbackIfFails_default(predicate != null ? predicate : item, [item, key, data], false) && result.set(key, item);
+  }
+  return asArray ? [...result.values()] : result;
+};
+var filter_default = filter;
+
+// src/iterable/getSize.ts
+var getSize = (x) => {
+  if (!x) return 0;
+  try {
+    const s = "size" in x ? x.size : "length" in x ? x.length : 0;
+    return isNumber(s) ? s : 0;
+  } catch (_) {
+    return 0;
+  }
+};
+var getSize_default = getSize;
+
+// src/iterable/getValues.ts
+var getValues = (data) => {
+  var _a;
+  return [
+    ...((_a = data == null ? void 0 : data.values) == null ? void 0 : _a.call(data)) || []
+  ];
+};
+var getValues_default = getValues;
+
+// src/iterable/search.ts
+var search = (data, options) => {
+  var _a;
+  const ignore = !getSize_default(data) || isEmpty(options == null ? void 0 : options.query);
+  const result = isMap(options == null ? void 0 : options.result) ? options.result : /* @__PURE__ */ new Map();
+  const asMap = (_a = options == null ? void 0 : options.asMap) != null ? _a : search.defaultOptions.asMap;
+  if (ignore) return asMap ? result : getValues_default(result);
+  options = objCopy(search.defaultOptions, options, [], "empty");
+  const { ignoreCase, limit = Infinity, matchAll, matchExact } = options;
+  let { query } = options;
+  const qIsStr = isStr(query);
+  const qIsRegExp = !qIsStr && isRegExp(query);
+  const qKeys = fallbackIfFails_default(Object.keys, [query], []);
+  if (ignoreCase && !matchExact && !qIsRegExp) {
+    query = qIsStr ? query.toLowerCase() : objCreate(
+      qKeys,
+      Object.values(query).map(
+        (x) => isRegExp(x) ? x : `${x}`.toLowerCase()
+      )
+    );
+  }
+  options.query = query;
+  const entries = data.entries();
+  for (const [dataKey, dataValue] of entries) {
+    if (result.size >= limit) break;
+    const matched = qIsStr || qIsRegExp ? matchItemOrProp(options, dataValue, void 0) : qKeys[matchAll ? "every" : "some"](
+      (key) => matchItemOrProp(options, dataValue, key)
+      // search specific properties
+    );
+    if (!matched) continue;
+    result.set(dataKey, dataValue);
+  }
+  return asMap ? result : getValues_default(result);
+};
+search.defaultOptions = {
+  asMap: true,
+  ignoreCase: true,
+  limit: Infinity,
+  matchAll: false,
+  matchExact: false
+};
+function matchItemOrProp({
+  query,
+  ignoreCase,
+  matchExact,
+  transform
+}, item, propertyName) {
+  var _a, _b;
+  const fuzzy = isStr(query) || isRegExp(query) || propertyName === void 0;
+  const keyword = fuzzy ? query : query[propertyName];
+  const propVal = fuzzy || !isObj(item) ? item : item[propertyName];
+  let value = fallbackIfFails_default(
+    () => {
+      var _a2;
+      return isFn(transform) ? transform(
+        item,
+        fuzzy ? void 0 : propVal,
+        propertyName
+      ) : isObj(propVal, false) ? JSON.stringify(
+        isArrLike(propVal) ? [...propVal.values()] : Object.values(propVal)
+      ) : (_a2 = propVal == null ? void 0 : propVal.toString) == null ? void 0 : _a2.call(propVal);
+    },
+    [],
+    ""
+  );
+  if (!(value == null ? void 0 : value.trim())) return false;
+  if (isRegExp(keyword)) return keyword.test(`${value}`);
+  if (ignoreCase && !matchExact) value = value.toLowerCase();
+  if (value === keyword) return true;
+  return !matchExact && `${value}`.includes((_b = (_a = keyword == null ? void 0 : keyword.toString) == null ? void 0 : _a.call(keyword)) != null ? _b : "");
+}
+var search_default = search;
+
+// src/iterable/find.ts
+function find(data, optsOrCb) {
+  const result = isFn(optsOrCb) ? filter_default(data, optsOrCb, 1) : search_default(data, { ...optsOrCb, asMap: true, limit: 1 });
+  return result[
+    (optsOrCb == null ? void 0 : optsOrCb.includeKey) ? "entries" : "values"
+    // returns: value
+  ]().next().value;
+}
+
+// src/iterable/getEntries.ts
+var getEntries = (map) => {
+  var _a;
+  return [
+    ...((_a = map == null ? void 0 : map.entries) == null ? void 0 : _a.call(map)) || []
+  ];
+};
+
+// src/iterable/getKeys.ts
+var getKeys = (data) => {
+  var _a;
+  return [
+    ...((_a = data == null ? void 0 : data.keys) == null ? void 0 : _a.call(data)) || []
+  ];
+};
+
+// src/iterable/reverse.ts
+var reverse = (data, reverse2 = true, newInstance = false) => {
+  var _a, _b, _c;
+  const dataType = isArr(data) ? 1 : isMap(data) ? 2 : isSet(data) ? 3 : 0;
+  if (!dataType) return [];
+  const arr = dataType === 1 ? !newInstance ? data : [...data] : dataType === 2 ? [...data.entries()] : [...data.values()];
+  if (reverse2) arr.reverse();
+  if (dataType === 1) return arr;
+  if (newInstance || !("clear" in data && isFn(data.clear))) {
+    return dataType === 2 ? new Map(arr) : dataType === 3 && new Set(arr) || [];
+  }
+  (_a = data == null ? void 0 : data.clear) == null ? void 0 : _a.call(data);
+  for (const item of arr)
+    "set" in data ? (_b = data.set) == null ? void 0 : _b.call(data, ...item) : "add" in data && ((_c = data == null ? void 0 : data.add) == null ? void 0 : _c.call(data, item));
+  return data;
+};
+
+// src/iterable/sliceMap.ts
+var sliceMap = (data, options) => {
+  var _a;
+  const {
+    asMap = false,
+    end,
+    start = 0,
+    transform,
+    ignoreEmpty = true
+  } = isFn(options) ? { transform: options } : isObj(options) ? options : {};
+  const result = /* @__PURE__ */ new Map();
+  const subset = [...((_a = data == null ? void 0 : data.entries) == null ? void 0 : _a.call(data)) || []].slice(start, end);
+  for (const [_, [key, value]] of subset.entries()) {
+    if (ignoreEmpty && isEmpty(value)) continue;
+    const newValue = fallbackIfFails_default(
+      transform != null ? transform : value,
+      [value, key, data],
+      void 0
+    );
+    newValue !== void 0 && result.set(key, newValue);
+  }
+  return asMap ? result : [...result.values()];
+};
+
+// src/iterable/sort.ts
+function sort(data, keyOrFn, options) {
+  const dataType = isArr(data) ? 1 : isMap(data) ? 2 : isSet(data) ? 3 : 0;
+  if (!dataType) return data;
+  const { ignoreCase, newInstance, reverse: reverse2, undefinedFirst } = {
+    ...sort.defaultOptions,
+    ...isObj(options) ? options : isObj(keyOrFn) ? keyOrFn : {}
+  };
+  if (dataType === 1 && isFn(keyOrFn)) {
+    return arrReverse(
+      data.sort(keyOrFn),
+      // use provided comparator function
+      reverse2,
+      newInstance
+    );
+  }
+  const alt = undefinedFirst ? "" : "Z".repeat(10);
+  const sorted = isFn(keyOrFn) ? arrReverse(
+    // handle Set with comparator function
+    [...data.entries()].sort(keyOrFn),
+    reverse2,
+    false
+    // not required because of entries() & spread
+  ) : (() => {
+    const key = keyOrFn;
+    const getVal = (obj) => {
+      var _a;
+      const value = `${(_a = isObj(obj) && key ? obj[key] : obj) != null ? _a : alt}`;
+      return ignoreCase ? value.toLowerCase() : value;
+    };
+    const index = keyOrFn === true ? 0 : 1;
+    const [gt, lt] = reverse2 ? [-1, 1] : [1, -1];
+    if ([1, 3].includes(dataType)) {
+      return (dataType === 3 || newInstance ? [...data] : data).sort((a, b) => getVal(a) > getVal(b) ? gt : lt);
+    }
+    return [...data.entries()].sort(
+      (a, b) => getVal(a == null ? void 0 : a[index]) > getVal(b == null ? void 0 : b[index]) ? gt : lt
+    );
+  })();
+  if (dataType === 1) return sorted;
+  if (newInstance) {
+    return dataType === 2 ? new Map(sorted) : new Set(sorted);
+  }
+  ;
+  data.clear();
+  for (const entry of sorted)
+    dataType === 2 ? data.set(...entry) : data.add(entry);
+  return data;
+}
+sort.defaultOptions = {
+  ignoreCase: true,
+  newInstance: false,
+  reverse: false,
+  undefinedFirst: false
+};
+
+// src/map/mapJoin.ts
+var mapJoin = (...inputs) => {
+  var _a;
+  return new Map(
+    (_a = inputs == null ? void 0 : inputs.flatMap) == null ? void 0 : _a.call(
+      inputs,
+      (input) => isMap(input) ? Array.from(input.entries()) : isArr2D(input) ? input : []
+    )
+  );
+};
+
+// src/number/randomInt.ts
+var randomInt = (min = 0, max = Number.MAX_SAFE_INTEGER) => parseInt(`${Math.random() * (max - min) + min}`);
+
+// src/str/clearClutter.ts
+var clearClutter = (text, lineSeparator = " ") => `${text}`.split("\n").map((ln) => ln.trim()).filter(Boolean).join(lineSeparator);
+
+// src/str/copyToClipboard.ts
+var copyToClipboard = (str) => fallbackIfFails(
+  // First attempt: modern clipboard API
+  () => navigator.clipboard.writeText(str).then(() => 1),
+  [],
+  // If clipboard API is not available or fails, use the fallback method
+  () => fallbackIfFails(
+    () => {
+      const el = document.createElement("textarea");
+      el.value = str;
+      el.setAttribute("readonly", "");
+      el.style.position = "absolute";
+      el.style.left = "-9999px";
+      document.body.appendChild(el);
+      el.select();
+      const result = document.execCommand("copy");
+      document.body.removeChild(el);
+      return Promise.resolve(result ? 2 : 0);
+    },
+    [],
+    () => Promise.resolve(0)
+  )
+);
+
+// src/str/getUrlParam.ts
+var getUrlParam = (name, url, asArray) => {
+  var _a;
+  url != null ? url : url = fallbackIfFails_default(() => window.location.href, [], "");
+  const _asArray = isArr(asArray) ? asArray : asArray === true && isStr(name) ? [name] : [];
+  const prepareResult = (value = "", values = {}) => name ? isArr(value) || !_asArray.includes(name) ? value : [value].filter(Boolean) : values;
+  if (!url) return prepareResult();
+  if (typeof URLSearchParams === "undefined" || !URLSearchParams) {
+    const r = getUrlParamRegex(name, url, _asArray);
+    return prepareResult(r, r);
+  }
+  const search2 = isUrl(url) ? url.search : ((_a = url.split("?")) == null ? void 0 : _a[1]) || "";
+  if (search2 === "?" || !search2) return prepareResult();
+  const params = new URLSearchParams(search2);
+  const getValue = (paramName) => {
+    const value = arrUnique(params.getAll(paramName));
+    return value.length > 1 || _asArray.includes(paramName) ? value : value[0];
+  };
+  if (name) return prepareResult(getValue(name));
+  const result = {};
+  for (const name2 of arrUnique([...params.keys()])) {
+    result[name2] = getValue(name2);
+  }
+  return result;
+};
+var getUrlParamRegex = (name, url, asArray = []) => {
+  url != null ? url : url = fallbackIfFails_default(() => window.location.href, [], "");
+  if (isUrl(url)) url = url.toString();
+  const params = {};
+  const regex = /[?&]+([^=&]+)=([^&]*)/gi;
+  url.replace(regex, (_, name2, value) => {
+    value = decodeURIComponent(value);
+    if (asArray.includes(name2) || params[name2] !== void 0) {
+      params[name2] = isArr(params[name2]) ? params[name2] : [params[name2]];
+      params[name2] = arrUnique([...params[name2], value]).filter(Boolean);
+    } else {
+      params[name2] = value;
+    }
+    return "";
+  });
+  return name ? params[name] : params;
+};
+
+// src/str/regex.ts
+var EMAIL_REGEX = new RegExp(
+  /^(("[\w-\s]+")|([\w-]+(?:\.[\w-]+)*)|("[\w-\s]+")([\w-]+(?:\.[\w-]+)*))(@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,9}(?:\.[a-z]{2})?)$)|(@\[?((25[0-5]\.|2[0-4][0-9]\.|1[0-9]{2}\.|[0-9]{1,2}\.))((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})\.){2}(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})\]?$)/i
+);
+var HEX_REGEX = /^0x[0-9a-f]+$/i;
+var HASH_REGEX = /^0x[0-9a-f]{64}$/i;
+export {
+  EMAIL_REGEX,
+  HASH_REGEX,
+  HEX_REGEX,
+  ReadOnlyArrayHelper,
+  arrReadOnly,
+  arrReverse,
+  arrToMap,
+  arrUnique,
+  asAny,
+  clearClutter,
+  copyToClipboard,
+  curry,
+  debounce,
+  deferred,
+  fallbackIfFails,
+  filter,
+  find,
+  forceCast,
+  getEntries,
+  getKeys,
+  getSize,
+  getUrlParam,
+  getValues,
+  is,
+  isArr,
+  isArr2D,
+  isArrLike,
+  isArrLikeSafe,
+  isArrObj,
+  isArrUnique,
+  isAsyncFn,
+  isBool,
+  isDate,
+  isDateValid,
+  isDefined,
+  isEmpty,
+  isEmptySafe,
+  isEnvBrowser,
+  isEnvNode,
+  isEnvTouchable,
+  isError,
+  isFn,
+  isInteger,
+  isMap,
+  isMapObj,
+  isNumber,
+  isObj,
+  isPositiveInteger,
+  isPositiveNumber,
+  isPromise,
+  isRegExp,
+  isSet,
+  isStr,
+  isSymbol,
+  isUint8Arr,
+  isUrl,
+  isUrlValid,
+  mapJoin,
+  matchItemOrProp,
+  noop,
+  noopAsync,
+  objClean,
+  objCopy,
+  objCreate,
+  objKeys,
+  objReadOnly,
+  objSetProp,
+  objSetPropUndefined,
+  objSort,
+  objWithoutKeys,
+  randomInt,
+  reverse,
+  search,
+  sliceMap,
+  sort,
+  throttled,
+  toDatetimeLocal
+};