@andrew_l/toolkit 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -6,7 +6,6 @@ const _cloneDeepWith = require('lodash/cloneDeepWith');
 const _defaultsDeep = require('lodash/defaultsDeep');
 const _set = require('lodash/set');
 const _unset = require('lodash/unset');
-const lodash = require('lodash');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -27,8 +26,21 @@ const isBigInt = (val) => typeof val === "bigint";
 const isBoolean = (val) => typeof val === "boolean";
 const isFunction = (val) => typeof val === "function";
 const isNumber = (val) => typeof val === "number" && !isNaN(val);
+const isInfinity = (val) => val === Infinity || val === -Infinity;
 const isString = (val) => typeof val === "string";
 const isObject = (val) => toString.call(val) === "[object Object]";
+const isPlainObject = (val) => {
+  let ctor, prot;
+  if (!isObject(val)) return false;
+  ctor = val.constructor;
+  if (ctor === void 0) return true;
+  prot = ctor.prototype;
+  if (isObject(prot) === false) return false;
+  if (prot.hasOwnProperty("isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
+};
 const isDate = (val) => val instanceof Date && !isNaN(val);
 const noop = () => {
 };
@@ -43,28 +55,89 @@ function isEqual(a, b) {
   if (Object.is(a, b)) {
     return true;
   }
-  if (a instanceof Date && b instanceof Date) {
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  if (a.constructor !== b.constructor) {
+    return false;
+  }
+  if (Array.isArray(a)) {
+    const { length } = a;
+    if (length !== b.length) {
+      return false;
+    }
+    for (let i = length; i-- !== 0; ) {
+      if (!isEqual(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a instanceof Date) {
     return a.getTime() === b.getTime();
   }
-  if (a instanceof RegExp && b instanceof RegExp) {
+  if (a instanceof RegExp) {
     return a.source === b.source && a.flags === b.flags;
   }
-  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
-    return false;
+  if (a instanceof Set) {
+    if (a.size !== b.size) {
+      return false;
+    }
+    for (const value of a) {
+      if (!b.has(value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a instanceof Map) {
+    if (a.size !== b.size) {
+      return false;
+    }
+    for (const entry of a) {
+      if (!b.has(entry[0]) || !isEqual(entry[1], b.get(entry[0]))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a instanceof DataView) {
+    const { byteLength } = a;
+    if (byteLength !== b.byteLength) {
+      return false;
+    }
+    for (let i = byteLength; i-- !== 0; ) {
+      if (a.getUint8(i) !== b.getUint8(i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a instanceof ArrayBuffer && b instanceof ArrayBuffer) {
+    a = new Uint8Array(a);
+    b = new Uint8Array(b);
+  }
+  if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+    const { length } = a;
+    if (length !== b.length) {
+      return false;
+    }
+    for (let i = length; i-- !== 0; ) {
+      if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
   }
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
   if (aKeys.length !== bKeys.length) {
     return false;
   }
-  if (Array.from(new Set(aKeys.concat(bKeys))).length !== aKeys.length) {
-    return false;
-  }
-  for (let i = 0; i < aKeys.length; i++) {
-    const propKey = aKeys[i];
-    const aProp = a[propKey];
-    const bProp = b[propKey];
-    if (!isEqual(aProp, bProp)) {
+  let key;
+  for (let i = aKeys.length; i-- !== 0; ) {
+    key = aKeys[i];
+    if (!Object.hasOwn(b, key) || !isEqual(a[key], b[key])) {
       return false;
     }
   }
@@ -155,6 +228,35 @@ function chunkSeries(list, step = 1) {
   return result;
 }
 
+function difference(...arrays) {
+  if (arrays.length === 0) return [];
+  if (arrays.length === 1) return [...arrays[0]];
+  const [first, ...rest] = arrays;
+  const blacklist = /* @__PURE__ */ new Set();
+  const set = new Set(first);
+  for (const items of rest) {
+    for (const item of items) {
+      if (blacklist.has(item)) continue;
+      if (set.has(item)) {
+        set.delete(item);
+        blacklist.add(item);
+        continue;
+      }
+      set.add(item);
+    }
+  }
+  return Array.from(set);
+}
+
+function intersection(...arrays) {
+  if (arrays.length === 0) return [];
+  if (arrays.length === 1) return arrays[0];
+  return arrays.reduce((acc, curr) => {
+    const set = new Set(curr);
+    return acc.filter((item) => set.has(item));
+  });
+}
+
 function keyBy(array, keyBy2, objectMode) {
   const getItemKey = isFunction(keyBy2) ? keyBy2 : (item) => item?.[keyBy2];
   if (objectMode === true) {
@@ -205,6 +307,15 @@ function orderBy(array, fields, orders) {
   });
 }
 
+function shuffle(arr) {
+  const result = arr.slice();
+  for (let i = result.length - 1; i >= 1; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+
 const sum = (values) => {
   return values.reduce((a, b) => a + (isNumber(b) ? b : 0), 0);
 };
@@ -216,8 +327,11 @@ function uniq(value) {
   return [...new Set(value)];
 }
 
-function union(arr1, arr2) {
-  return uniq(arr1.concat(arr2));
+function union(...arrays) {
+  if (arrays.length === 0) return [];
+  if (arrays.length === 1) return [...arrays[0]];
+  const [first, ...rest] = arrays;
+  return uniq(first.concat(...rest));
 }
 
 const get = _get__default;
@@ -336,6 +450,202 @@ const assert = {
   string: string
 };
 
+class Base64Encoding {
+  alphabet;
+  padding;
+  decodeMap = /* @__PURE__ */ new Map();
+  constructor(alphabet, options) {
+    if (alphabet.length !== 64) {
+      throw new Error("Invalid alphabet");
+    }
+    this.alphabet = alphabet;
+    this.padding = options?.padding ?? "=";
+    if (this.alphabet.includes(this.padding) || this.padding.length !== 1) {
+      throw new Error("Invalid padding");
+    }
+    for (let i = 0; i < alphabet.length; i++) {
+      this.decodeMap.set(alphabet[i], i);
+    }
+  }
+  encode(data, options) {
+    let result = "";
+    let buffer = 0;
+    let shift = 0;
+    for (let i = 0; i < data.length; i++) {
+      buffer = buffer << 8 | data[i];
+      shift += 8;
+      while (shift >= 6) {
+        shift += -6;
+        result += this.alphabet[buffer >> shift & 63];
+      }
+    }
+    if (shift > 0) {
+      result += this.alphabet[buffer << 6 - shift & 63];
+    }
+    const includePadding = options?.includePadding ?? true;
+    if (includePadding) {
+      const padCount = (4 - result.length % 4) % 4;
+      for (let i = 0; i < padCount; i++) {
+        result += "=";
+      }
+    }
+    return result;
+  }
+  decode(data, options) {
+    const strict = options?.strict ?? true;
+    const chunkCount = Math.ceil(data.length / 4);
+    const result = [];
+    for (let i = 0; i < chunkCount; i++) {
+      let padCount = 0;
+      let buffer = 0;
+      for (let j = 0; j < 4; j++) {
+        const encoded = data[i * 4 + j];
+        if (encoded === "=") {
+          if (i + 1 !== chunkCount) {
+            throw new Error(`Invalid character: ${encoded}`);
+          }
+          padCount += 1;
+          continue;
+        }
+        if (encoded === void 0) {
+          if (strict) {
+            throw new Error("Invalid data");
+          }
+          padCount += 1;
+          continue;
+        }
+        const value = this.decodeMap.get(encoded) ?? null;
+        if (value === null) {
+          throw new Error(`Invalid character: ${encoded}`);
+        }
+        buffer += value << 6 * (3 - j);
+      }
+      result.push(buffer >> 16 & 255);
+      if (padCount < 2) {
+        result.push(buffer >> 8 & 255);
+      }
+      if (padCount < 1) {
+        result.push(buffer & 255);
+      }
+    }
+    return Uint8Array.from(result);
+  }
+}
+
+const base64 = new Base64Encoding(
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+);
+const base64url = new Base64Encoding(
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+);
+
+function base64ToBytes(data, { encoding = "base64", strict } = {}) {
+  if (encoding === "base64") {
+    return base64.decode(data, { strict: strict ?? true });
+  } else if (encoding === "base64url") {
+    return base64url.decode(data, { strict: strict ?? false });
+  }
+  ok(false, "Invalid encoding options: " + encoding);
+}
+
+function bigIntBytes(value) {
+  if (value < 0n) {
+    value = value * -1n;
+  }
+  let byteLength = 1;
+  while (value > 2n ** BigInt(byteLength * 8) - 1n) {
+    byteLength++;
+  }
+  const encoded = new Uint8Array(byteLength);
+  for (let i = 0; i < encoded.byteLength; i++) {
+    encoded[i] = Number(
+      value >> BigInt((encoded.byteLength - i - 1) * 8) & 0xffn
+    );
+  }
+  return encoded;
+}
+
+function bigIntFromBytes(bytes) {
+  ok(bytes.byteLength > 0, "Empty Uint8Array");
+  let decoded = 0n;
+  for (let i = 0; i < bytes.byteLength; i++) {
+    decoded += BigInt(bytes[i]) << BigInt((bytes.byteLength - 1 - i) * 8);
+  }
+  return decoded;
+}
+
+function bytesToBase64(data, { encoding = "base64", padding } = {}) {
+  if (encoding === "base64") {
+    return base64.encode(data, { includePadding: padding ?? true });
+  } else if (encoding === "base64url") {
+    return base64url.encode(data, { includePadding: padding ?? false });
+  }
+  ok(false, "Invalid encoding options: " + encoding);
+}
+
+function compareBytes(a, b) {
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  for (let i = 0; i < b.byteLength; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function concatenateBytes(a, b) {
+  const result = new Uint8Array(a.byteLength + b.byteLength);
+  result.set(a);
+  result.set(b, a.byteLength);
+  return result;
+}
+
+function uint16ToUint8(value) {
+  const uint8Array = new Uint8Array(value.length * 2);
+  for (let i = 0; i < value.length; i++) {
+    uint8Array[i * 2] = value[i] & 255;
+    uint8Array[i * 2 + 1] = value[i] >> 8;
+  }
+  return uint8Array;
+}
+
+function uint32ToUint8(value) {
+  const uint8Array = new Uint8Array(value.length * 4);
+  for (let i = 0; i < value.length; i++) {
+    uint8Array[i * 4] = value[i] & 255;
+    uint8Array[i * 4 + 1] = value[i] >> 8 & 255;
+    uint8Array[i * 4 + 2] = value[i] >> 16 & 255;
+    uint8Array[i * 4 + 3] = value[i] >> 24 & 255;
+  }
+  return uint8Array;
+}
+
+function uint8ToUint16(value) {
+  ok(
+    value.length % 2 === 0,
+    "Uint8Array length must be even for conversion to Uint16Array"
+  );
+  const uint16Array = new Uint16Array(value.length / 2);
+  for (let i = 0; i < uint16Array.length; i++) {
+    uint16Array[i] = value[i * 2] << 8 | value[i * 2 + 1];
+  }
+  return uint16Array;
+}
+
+function uint8ToUint32(value) {
+  ok(
+    value.length % 4 === 0,
+    "Uint8Array length must be a multiple of 4 for conversion to Uint32Array"
+  );
+  const uint32Array = new Uint32Array(value.length / 4);
+  for (let i = 0; i < uint32Array.length; i++) {
+    uint32Array[i] = value[i * 4] << 24 | value[i * 4 + 1] << 16 | value[i * 4 + 2] << 8 | value[i * 4 + 3];
+  }
+  return uint32Array;
+}
+
 const def = (obj, key, value, writable = false) => {
   Object.defineProperty(obj, key, {
     configurable: true,
@@ -1739,18 +2049,6 @@ function percentOf(value, percent, digits) {
   return result;
 }
 
-function timestamp(fromValue = Date.now()) {
-  if (isDate(fromValue)) {
-    fromValue = fromValue.getTime();
-  }
-  return Math.floor(fromValue / 1e3);
-}
-
-function timestampToDate(value) {
-  if (!isNumber(value)) return null;
-  return new Date(value * 1e3);
-}
-
 const rgb3Numbers = new RegExp(
   `^
   rgba?\\(
@@ -2054,6 +2352,664 @@ function crc32(str, seed = 0) {
   return ~C;
 }
 
+function isDateObject(value) {
+  return has(value, ["year", "month", "date"]) && isNumber(value.year) && isNumber(value.month) && isNumber(value.date);
+}
+
+function createDateObject(value, returnsNullWhenInvalid = false) {
+  let result = null;
+  let inputValue = value;
+  if (isNumber(inputValue) || isString(inputValue)) {
+    inputValue = new Date(inputValue);
+  }
+  if (isDate(inputValue)) {
+    result = {
+      year: inputValue.getFullYear(),
+      month: inputValue.getMonth() + 1,
+      date: inputValue.getDate()
+    };
+  } else if (isDateObject(inputValue)) {
+    result = { ...inputValue };
+  }
+  ok(
+    returnsNullWhenInvalid || !!result,
+    `Failed to date parse: ${value}.`
+  );
+  return result;
+}
+
+function isTimeObject(value) {
+  return isPlainObject(value) && "h" in value && "m" in value && isNumber(value.h) && Number.isInteger(value.h) && isNumber(value.m) && Number.isInteger(value.m) && value.h >= 0 && value.h < 24 && value.m >= 0 && value.m < 60;
+}
+
+function createTimeObject(value, returnsNullWhenInvalid = false) {
+  let result = null;
+  let inputValue = value;
+  if (isNumber(inputValue)) {
+    inputValue = new Date(inputValue);
+  } else if (isString(inputValue)) {
+    const [h, m] = inputValue.split(":").map((v) => v.trim().padStart(2, "0")).map((v) => parseInt(v));
+    inputValue = { h, m };
+  }
+  if (isDate(inputValue)) {
+    result = {
+      h: inputValue.getHours(),
+      m: inputValue.getMinutes()
+    };
+  } else if (isTimeObject(inputValue)) {
+    result = { ...inputValue };
+  }
+  ok(
+    returnsNullWhenInvalid || !!result,
+    `Failed to time parse: ${value}.`
+  );
+  return result;
+}
+
+const UNIT_TO_MS = {
+  ms: 1,
+  s: 1e3,
+  m: 1e3 * 60,
+  h: 1e3 * 60 * 60,
+  d: 1e3 * 60 * 60 * 24,
+  w: 1e3 * 60 * 60 * 24 * 7
+};
+class TimeSpan {
+  constructor(value, unit) {
+    this.value = value;
+    this.unit = unit;
+  }
+  /**
+   * The numeric value of the time span
+   */
+  value;
+  /**
+   * The unit of the time span.
+   */
+  unit;
+  /**
+   * Converts the time span to milliseconds.
+   *
+   * @returns {number} The equivalent time span in milliseconds.
+   * @example
+   * const ts = new TimeSpan(2, 'h');
+   * ts.milliseconds(); // Returns 7200000
+   */
+  milliseconds() {
+    const multiplier = UNIT_TO_MS[this.unit];
+    return this.value * multiplier;
+  }
+  /**
+   * Converts the time span to seconds.
+   *
+   * @returns {number} The equivalent time span in seconds.
+   * @example
+   * const ts = new TimeSpan(2, 'm');
+   * ts.seconds(); // Returns 120
+   */
+  seconds() {
+    return this.milliseconds() / UNIT_TO_MS.s;
+  }
+  /**
+   * Converts the time span to minutes.
+   *
+   * @returns {number} The equivalent time span in minutes.
+   * @example
+   * const ts = new TimeSpan(120, 's');
+   * ts.minutes(); // Returns 2
+   */
+  minutes() {
+    return this.milliseconds() / UNIT_TO_MS.m;
+  }
+  /**
+   * Converts the time span to hours.
+   *
+   * @returns {number} The equivalent time span in hours.
+   * @example
+   * const ts = new TimeSpan(120, 'm');
+   * ts.hours(); // Returns 2
+   */
+  hours() {
+    return this.milliseconds() / UNIT_TO_MS.h;
+  }
+  /**
+   * Converts the time span to days.
+   *
+   * @returns {number} The equivalent time span in days.
+   * @example
+   * const ts = new TimeSpan(48, 'h');
+   * ts.days(); // Returns 2
+   */
+  days() {
+    return this.milliseconds() / UNIT_TO_MS.d;
+  }
+  /**
+   * Converts the time span to weeks.
+   *
+   * @returns {number} The equivalent time span in weeks.
+   * @example
+   * const ts = new TimeSpan(14, 'd');
+   * ts.weeks(); // Returns 2
+   */
+  weeks() {
+    return this.milliseconds() / UNIT_TO_MS.w;
+  }
+  /**
+   * Adds a specified value and unit to the current time span.
+   *
+   * Returns new instance.
+   *
+   * @param {number} value - The value to add.
+   * @param {TimeSpanUnit} [unit='ms'] - The unit of the value to add (default is milliseconds).
+   * @returns {TimeSpan} A new TimeSpan instance with the added value.
+   * @example
+   * const ts = new TimeSpan(1, 'h');
+   * ts.add(30, 'm'); // Represents 1.5 hours
+   */
+  add(value, unit = "ms") {
+    const multiplier = UNIT_TO_MS[unit];
+    return new TimeSpan(this.milliseconds() + value * multiplier, "ms");
+  }
+  /**
+   * Subtracts a specified value and unit from the current time span.
+   *
+   * Returns new instance.
+   *
+   * @param {number} value - The value to subtract.
+   * @param {TimeSpanUnit} [unit='ms'] - The unit of the value to subtract (default is milliseconds).
+   * @returns {TimeSpan} A new TimeSpan instance with the subtracted value.
+   * @example
+   * const ts = new TimeSpan(1, 'h');
+   * ts.subtract(30, 'm'); // Represents 30 minutes less than 1 hour
+   */
+  subtract(value, unit = "ms") {
+    const multiplier = UNIT_TO_MS[unit];
+    return new TimeSpan(this.milliseconds() - value * multiplier, "ms");
+  }
+}
+
+function createTimeSpan(value, unit = "ms") {
+  return new TimeSpan(value, unit);
+}
+
+function timestampMs(fromValue = Date.now()) {
+  if (isDate(fromValue)) {
+    fromValue = fromValue.getTime();
+  } else if (isString(fromValue)) {
+    const dt = new Date(fromValue);
+    fromValue = isDate(dt) ? dt.getTime() : 0;
+  }
+  return isNumber(fromValue) ? fromValue : 0;
+}
+
+function dateInDays(days, fromValue = Date.now()) {
+  return new Date(timestampMs(fromValue) + days * 60 * 60 * 24 * 1e3);
+}
+
+function dateInSeconds(seconds, fromValue = Date.now()) {
+  return new Date(timestampMs(fromValue) + seconds * 1e3);
+}
+
+function getRandomTime(startTime = { h: 0, m: 0 }, endTime = { h: 23, m: 59 }) {
+  const h = getRandomInt(startTime.h, endTime.h);
+  if (startTime.h === endTime.h) {
+    return { h, m: getRandomInt(startTime.m, endTime.m) };
+  }
+  if (h === startTime.h) {
+    return { h, m: getRandomInt(startTime.m, 59) };
+  }
+  if (h === endTime.h) {
+    return { h, m: getRandomInt(0, endTime.m) };
+  }
+  return { h, m: getRandomInt(0, 59) };
+}
+
+function hmToSeconds(hm) {
+  hm = Number(hm);
+  number$1(hm, "expected number value");
+  const h = Math.floor(hm);
+  const m = round2digits(hm - h) * 100;
+  return h * 3600 + m * 60;
+}
+
+function isTimeString(value) {
+  if (!isString(value)) return false;
+  const parts = value.split(":").map(Number);
+  if (parts.length !== 2) return false;
+  const [h, m] = parts;
+  return h >= 0 && h < 24 && m >= 0 && m < 60;
+}
+
+function isTimeValue(value) {
+  return isTimeString(value) || isTimeObject(value);
+}
+
+function isValidWeekDay(value) {
+  return isNumber(value) && Number.isInteger(value) && value >= 1 && value <= 7;
+}
+
+function secondsToHm(seconds) {
+  const value = Number(seconds);
+  number$1(value, "expected number value");
+  const h = Math.floor(value / 3600);
+  const m = Math.floor(value % 3600 / 60);
+  return round2digits(h + m / 100, 2);
+}
+
+function timeFromMinutes(value, returnsNullWhenInvalid = false) {
+  if (!isNumber(value)) {
+    ok(
+      returnsNullWhenInvalid,
+      "Failed to time parse from minutes: " + value
+    );
+    return null;
+  }
+  if (value === 0) {
+    return { h: 0, m: 0 };
+  }
+  value = value % 1440;
+  if (value < 0) {
+    value += 1440;
+  }
+  const h = Math.floor(value / 60);
+  const m = value % 60;
+  return { h, m };
+}
+
+function timestamp(fromValue = Date.now()) {
+  if (isDate(fromValue)) {
+    fromValue = fromValue.getTime();
+  }
+  return Math.floor(fromValue / 1e3);
+}
+
+function timestampToDate(value) {
+  if (!isNumber(value)) return null;
+  return new Date(value * 1e3);
+}
+
+function timeStringify(value, returnsNullWhenInvalid = false) {
+  const timeObject = createTimeObject(value, true);
+  if (!timeObject) {
+    ok(
+      returnsNullWhenInvalid,
+      "Failed to stringify time from: " + JSON.stringify(value)
+    );
+    return null;
+  }
+  let { h, m } = timeObject;
+  const hStr = Math.ceil(h).toString().padStart(2, "0").slice(-2);
+  const mStr = Math.ceil(m).toString().padStart(2, "0").slice(-2);
+  return `${hStr}:${mStr}`;
+}
+
+function timeToMinutes(value) {
+  const time = createTimeObject(value);
+  return time.h * 60 + time.m;
+}
+
+function weeksInYear(year) {
+  const target = new Date(Date.UTC(year + 1, 0, 1));
+  const dayNumber = target.getDay();
+  return dayNumber < 4 ? 52 : 53;
+}
+
+const DateType = {
+  placeholder: "$date",
+  encode: (value) => {
+    if (value instanceof Date) {
+      return value.getTime();
+    }
+  },
+  decode(value) {
+    return new Date(value);
+  }
+};
+const BinaryType = {
+  placeholder: "$binary",
+  encode: (value) => {
+    if (value instanceof Uint8Array) {
+      return base64.encode(value, { includePadding: true });
+    } else if (value instanceof Uint16Array) {
+      return {
+        value: base64.encode(uint16ToUint8(value), { includePadding: true }),
+        bit: 16
+      };
+    } else if (value instanceof Uint32Array) {
+      return {
+        value: base64.encode(uint32ToUint8(value), { includePadding: true }),
+        bit: 32
+      };
+    }
+  },
+  decode(value) {
+    if (typeof value === "string") {
+      return base64.decode(value, { strict: true });
+    } else if (value.bit === 16) {
+      return uint8ToUint16(base64.decode(value.value, { strict: true }));
+    } else if (value.bit === 32) {
+      return uint8ToUint32(base64.decode(value.value, { strict: true }));
+    }
+    throw new Error("Unexpected $binary bit value: " + value.bit);
+  }
+};
+const BigIntType = {
+  placeholder: "$bigint",
+  encode: (value) => {
+    if (typeof value === "bigint") {
+      return base64.encode(bigIntBytes(value), { includePadding: false });
+    }
+  },
+  decode(value) {
+    return bigIntFromBytes(base64.decode(value, { strict: false }));
+  }
+};
+const MapType = {
+  placeholder: "$map",
+  encode: (value, encode) => {
+    if (value instanceof Map) {
+      return encode(Array.from(value.entries()));
+    }
+  },
+  decode(value) {
+    return new Map(value);
+  }
+};
+const SetType = {
+  placeholder: "$set",
+  encode: (value, encode) => {
+    if (value instanceof Set) {
+      return encode(Array.from(value.values()));
+    }
+  },
+  decode(value) {
+    return new Set(value);
+  }
+};
+const RegexType = {
+  placeholder: "$regex",
+  encode: (value, encode) => {
+    if (value instanceof RegExp) {
+      const regStr = value.toString();
+      const patternStart = regStr.lastIndexOf("/");
+      return {
+        pattern: value.toString().slice(1, patternStart),
+        flags: regStr.slice(patternStart + 1)
+      };
+    }
+  },
+  decode(value) {
+    return new RegExp(value.pattern, value.flags);
+  }
+};
+const InfinityType = {
+  placeholder: "$inf",
+  encode: (value, encode) => {
+    if (value === Infinity) {
+      return 1;
+    } else if (value === -Infinity) {
+      return -1;
+    }
+  },
+  decode(value) {
+    if (value === 1) return Infinity;
+    if (value === -1) return -Infinity;
+    throw new Error("Unexpected $inf value: " + value);
+  }
+};
+
+class EJSON {
+  /** @internal */
+  typeHandlers = /* @__PURE__ */ new Map();
+  /** @internal */
+  replacerReady;
+  /** @internal */
+  encode;
+  /** @internal */
+  reviewerReady;
+  /** @internal */
+  pure = true;
+  _vendorName = null;
+  /**
+   * MIME type based on the provided vendor name or defaults to 'application/json'.
+   */
+  mimetype = "application/json";
+  Type = {
+    Date: DateType,
+    Map: MapType,
+    Set: SetType,
+    RegExp: RegexType,
+    Infinity: InfinityType,
+    BigInt: BigIntType,
+    Binary: BinaryType
+  };
+  constructor() {
+    this.replacerReady = this._replacer.bind(this);
+    this.reviewerReady = this._reviewer.bind(this);
+    this.encode = (value) => {
+      return deepCloneWith(value, this.replacerReady);
+    };
+  }
+  /**
+   * The vendor name used for the custom MIME type definition.
+   * If null, defaults to 'application/json'.
+   */
+  get vendorName() {
+    return this._vendorName;
+  }
+  set vendorName(value) {
+    this._vendorName = value;
+    if (!value) {
+      this.mimetype = "application/json";
+    } else {
+      const vendorName = value.split(" ").map((v) => v.toLowerCase()).join(".").replace(/\.\.+/g, ".").replace(/\.$/, "");
+      this.mimetype = `application/vnd.${vendorName}+json`;
+    }
+  }
+  /**
+   * Adds a custom type handler for encoding/decoding logic.
+   * Ensures type placeholders are unique and adhere to conventions.
+   */
+  addType(type) {
+    ok(
+      !this.typeHandlers.has(type.placeholder),
+      `type with ${type.placeholder} already taken.`
+    );
+    ok(
+      type.placeholder.startsWith("$"),
+      "type placeholder must starts with $ symbol."
+    );
+    this.pure = false;
+    this.typeHandlers.set(type.placeholder, type);
+    return this;
+  }
+  /**
+   * Stringifies a JavaScript value using custom encoding logic.
+   * @param {any} value - The value to encode and stringify.
+   * @param {string | number} [space] - Optional space for pretty-printing.
+   * @returns {string} - The JSON stringified value.
+   */
+  stringify(value, space) {
+    if (this.pure) {
+      return JSON.stringify(value, void 0, space);
+    }
+    return JSON.stringify(this.encode(value), void 0, space);
+  }
+  /**
+   * Parses a JSON string using custom decoding logic.
+   * @param {string} value - The JSON string to parse.
+   * @returns {any} - The decoded JavaScript object.
+   */
+  parse(value) {
+    if (this.pure) {
+      return JSON.parse(value);
+    }
+    return JSON.parse(value, this.reviewerReady);
+  }
+  /** @internal */
+  _replacer(value, key) {
+    if (isPlainObject(value)) return;
+    if (Array.isArray(value)) return;
+    if (!isInfinity(value) && !isBigInt(value)) {
+      if (isPrimitive(value)) return;
+    }
+    for (const type of this.typeHandlers.values()) {
+      const res = type.encode(value, this.encode);
+      if (res !== void 0) {
+        return type.encodeInline ? res : { [type.placeholder]: res };
+      }
+    }
+    return value;
+  }
+  /** @internal */
+  _reviewer(_, value) {
+    const key = firstKey(value);
+    if (!key || key[0] !== "$") return value;
+    const type = this.typeHandlers.get(key);
+    if (type) {
+      return type.decode(value[key]);
+    }
+    return value;
+  }
+}
+function firstKey(value) {
+  if (!isObject(value)) return null;
+  for (const key in value) {
+    return key;
+  }
+  return null;
+}
+
+function createEJSON(withBasicTypes = false) {
+  const ejson = new EJSON();
+  if (withBasicTypes) {
+    ejson.addType(MapType);
+    ejson.addType(SetType);
+    ejson.addType(DateType);
+    ejson.addType(InfinityType);
+    ejson.addType(BigIntType);
+    ejson.addType(BinaryType);
+    ejson.addType(RegexType);
+  }
+  return ejson;
+}
+
+class EJSONStream extends TransformStream {
+  ejson;
+  constructor({ ejson, cl, op, sep, onFlush, onStart }) {
+    let firstChunk = true;
+    super({
+      async start(controller) {
+        if (onStart) {
+          await onStart(controller);
+        }
+        controller.enqueue(op);
+      },
+      transform(chunk, controller) {
+        const jsonString = ejson.stringify(chunk);
+        if (firstChunk) {
+          firstChunk = false;
+        } else {
+          controller.enqueue(sep);
+        }
+        controller.enqueue(jsonString);
+      },
+      flush(controller) {
+        controller.enqueue(cl);
+        if (onFlush) {
+          return onFlush(controller);
+        }
+      }
+    });
+    this.ejson = ejson;
+  }
+  /**
+   * The vendor name used for the custom MIME type definition.
+   * If null, defaults to 'application/json'.
+   */
+  get vendorName() {
+    return this.ejson.vendorName;
+  }
+  /**
+   * MIME type based on the provided vendor name or defaults to 'application/json'.
+   */
+  get mimetype() {
+    return this.ejson.mimetype;
+  }
+}
+
+const instance = createEJSON(true);
+
+function createEJSONStream(options = {}) {
+  if (options.resultKey || options.append || options.prepend) {
+    return createEJSONStreamPayload(options);
+  }
+  return new EJSONStream(getOptions(options));
+}
+function createEJSONStreamPayload(options) {
+  let { cl, ejson, op, sep } = getOptions(options);
+  const { append, prepend, resultKey } = options;
+  notEmptyString(resultKey, "resultKey required.");
+  const stream = new EJSONStream({
+    ejson,
+    cl,
+    op,
+    sep,
+    async onStart(controller) {
+      if (!prepend) {
+        controller.enqueue(`{"${resultKey}":`);
+        return;
+      }
+      const data = await prepend();
+      if (data === null || data === void 0) {
+        controller.enqueue(`{"${resultKey}":`);
+        return;
+      }
+      ok(
+        isPlainObject(data),
+        "prepend result expected to be plain object"
+      );
+      const dataPart = instance.stringify(data).slice(0, -1);
+      if (dataPart === "{") {
+        controller.enqueue(`{"${resultKey}":`);
+        return;
+      }
+      controller.enqueue(`${dataPart}${sep}"${resultKey}":`);
+    },
+    async onFlush(controller) {
+      if (!append) {
+        controller.enqueue("}");
+        return;
+      }
+      const data = await append();
+      if (data === null || data === void 0) {
+        controller.enqueue("}");
+        return;
+      }
+      ok(
+        isPlainObject(data),
+        "prepend result expected to be plain object"
+      );
+      const dataPart = instance.stringify(data).slice(1);
+      if (dataPart === "}") {
+        controller.enqueue(`}`);
+        return;
+      }
+      controller.enqueue(`${sep}${dataPart}`);
+    }
+  });
+  return stream;
+}
+function getOptions(options) {
+  const { ejson = instance, cl = "]", op = "[", sep = "," } = options;
+  return {
+    cl,
+    ejson,
+    op,
+    sep
+  };
+}
+
 const env = (() => {
   if (globalThis?.process) {
     return createEnvParser(process.env);
@@ -2086,7 +3042,7 @@ function createEnvParser(targetObject) {
       return parseDecimal(targetObject[key], dights) ?? defaultValue;
     },
     string(key, defaultValue = "") {
-      return targetObject[key] || defaultValue;
+      return targetObject[key] ?? defaultValue;
     },
     list(key, type, defaultValue = []) {
       if (!(key in targetObject)) {
@@ -2783,9 +3739,9 @@ function typeOf(value) {
       if (value === null) return "null";
       if (Array.isArray(value)) return "array";
       if (isSet(value)) return "set";
-      if (lodash.isWeakSet(value)) return "weakset";
+      if (isWeakSet(value)) return "weakset";
       if (isMap(value)) return "map";
-      if (lodash.isWeakMap(value)) return "weakmap";
+      if (isWeakMap(value)) return "weakmap";
       if (isDate(value)) return "date";
       if (isObject(value)) return "object";
       return "unknown";
@@ -2995,10 +3951,11 @@ function parseValue(value, asType) {
   return void 0;
 }
 
+const noopShouldRetryBasedOnError = () => true;
 function retryOnError({
   beforeRetryCallback,
+  shouldRetryBasedOnError = noopShouldRetryBasedOnError,
   maxRetriesNumber,
-  shouldRetryBasedOnError,
   delayFactor = 0,
   delayMaxMs = 1e3,
   delayMinMs = 100
@@ -3279,6 +4236,9 @@ exports.AsyncIterableQueue = AsyncIterableQueue;
 exports.BrowserAssertionError = BrowserAssertionError;
 exports.CancellablePromise = CancellablePromise;
 exports.ColorParser = ColorParser;
+exports.EJSON = instance;
+exports.EJSONStream = EJSONStream;
+exports.FindMean = FindMean;
 exports.FixedMap = FixedMap;
 exports.FixedWeakMap = FixedWeakMap;
 exports.LruCache = LruCache;
@@ -3286,6 +4246,7 @@ exports.Queue = Queue;
 exports.SimpleEventEmitter = SimpleEventEmitter;
 exports.TWEMOJI_REGEX = TWEMOJI_REGEX;
 exports.TimeBucket = TimeBucket;
+exports.TimeSpan = TimeSpan;
 exports.alpha = alpha;
 exports.arrayable = arrayable;
 exports.assert = assert;
@@ -3294,8 +4255,12 @@ exports.asyncFind = asyncFind;
 exports.asyncForEach = asyncForEach;
 exports.asyncMap = asyncMap;
 exports.avg = avg;
+exports.base64ToBytes = base64ToBytes;
+exports.bigIntBytes = bigIntBytes;
+exports.bigIntFromBytes = bigIntFromBytes;
 exports.blendColors = blendColors;
 exports.buildCssColor = buildCssColor;
+exports.bytesToBase64 = bytesToBase64;
 exports.cache = cache;
 exports.cacheBucket = cacheBucket;
 exports.cacheFixed = cacheFixed;
@@ -3314,17 +4279,26 @@ exports.clamp = clamp;
 exports.cleanEmpty = cleanEmpty;
 exports.cleanObject = cleanObject;
 exports.colorToChannels = colorToChannels;
+exports.compareBytes = compareBytes;
+exports.concatenateBytes = concatenateBytes;
 exports.contrastRatio = contrastRatio;
 exports.convertToUnit = convertToUnit;
 exports.crc32 = crc32;
 exports.createCustomizer = createCustomizer;
 exports.createCustomizerFactory = createCustomizerFactory;
+exports.createDateObject = createDateObject;
 exports.createDeepCloneWith = createDeepCloneWith;
+exports.createEJSON = createEJSON;
+exports.createEJSONStream = createEJSONStream;
 exports.createEnvParser = createEnvParser;
 exports.createRandomizer = createRandomizer;
 exports.createSecureCustomizer = createSecureCustomizer;
+exports.createTimeObject = createTimeObject;
+exports.createTimeSpan = createTimeSpan;
 exports.createWithCache = createWithCache;
 exports.cssVariable = cssVariable;
+exports.dateInDays = dateInDays;
+exports.dateInSeconds = dateInSeconds;
 exports.deepAssign = deepAssign;
 exports.deepClone = deepClone;
 exports.deepCloneWith = deepCloneWith;
@@ -3333,6 +4307,7 @@ exports.deepFreeze = deepFreeze;
 exports.def = def;
 exports.defer = defer;
 exports.delay = delay;
+exports.difference = difference;
 exports.dropCache = dropCache;
 exports.env = env;
 exports.escapeHtml = escapeHtml;
@@ -3351,16 +4326,19 @@ exports.getFileExtension = getFileExtension;
 exports.getFileName = getFileName;
 exports.getInitials = getInitials;
 exports.getRandomInt = getRandomInt;
+exports.getRandomTime = getRandomTime;
 exports.getWords = getWords;
 exports.has = has;
 exports.hasOwn = hasOwn;
 exports.hasProtocol = hasProtocol;
 exports.hex = hex;
 exports.hexToChannels = hexToChannels;
+exports.hmToSeconds = hmToSeconds;
 exports.hslToChannels = hslToChannels;
 exports.humanFileSize = humanFileSize;
 exports.humanize = humanize;
 exports.interpolateColor = interpolateColor;
+exports.intersection = intersection;
 exports.isBigInt = isBigInt;
 exports.isBoolean = isBoolean;
 exports.isCached = isCached;
@@ -3368,16 +4346,19 @@ exports.isClient = isClient;
 exports.isColorChannels = isColorChannels;
 exports.isCustomizerFactory = isCustomizerFactory;
 exports.isDate = isDate;
+exports.isDateObject = isDateObject;
 exports.isDef = isDef;
 exports.isEmpty = isEmpty;
 exports.isEqual = isEqual;
 exports.isError = isError;
 exports.isFunction = isFunction;
+exports.isInfinity = isInfinity;
 exports.isMap = isMap;
 exports.isNullOrUndefined = isNullOrUndefined;
 exports.isNumber = isNumber;
 exports.isObject = isObject;
 exports.isOneEmoji = isOneEmoji;
+exports.isPlainObject = isPlainObject;
 exports.isPrimitive = isPrimitive;
 exports.isPromise = isPromise;
 exports.isSet = isSet;
@@ -3385,6 +4366,10 @@ exports.isSkip = isSkip;
 exports.isString = isString;
 exports.isSuccess = isSuccess;
 exports.isSymbol = isSymbol;
+exports.isTimeObject = isTimeObject;
+exports.isTimeString = isTimeString;
+exports.isTimeValue = isTimeValue;
+exports.isValidWeekDay = isValidWeekDay;
 exports.isWeakMap = isWeakMap;
 exports.isWeakSet = isWeakSet;
 exports.isWithCache = isWithCache;
@@ -3416,25 +4401,36 @@ exports.removeVS16s = removeVS16s;
 exports.retryOnError = retryOnError;
 exports.rgbToChannels = rgbToChannels;
 exports.round2digits = round2digits;
+exports.secondsToHm = secondsToHm;
 exports.set = set;
+exports.shuffle = shuffle;
 exports.snakeCase = snakeCase;
 exports.sprintf = sprintf;
 exports.startCase = startCase;
 exports.strAssign = strAssign;
 exports.sum = sum;
+exports.timeFromMinutes = timeFromMinutes;
+exports.timeStringify = timeStringify;
+exports.timeToMinutes = timeToMinutes;
 exports.timeout = timeout;
 exports.timestamp = timestamp;
+exports.timestampMs = timestampMs;
 exports.timestampToDate = timestampToDate;
 exports.tintedTextColor = tintedTextColor;
 exports.toError = toError;
 exports.toMap = toMap;
 exports.truncate = truncate;
 exports.typeOf = typeOf;
+exports.uint16ToUint8 = uint16ToUint8;
+exports.uint32ToUint8 = uint32ToUint8;
+exports.uint8ToUint16 = uint8ToUint16;
+exports.uint8ToUint32 = uint8ToUint32;
 exports.unflatten = unflatten;
 exports.union = union;
 exports.uniq = uniq;
 exports.uniqBy = uniqBy;
 exports.unset = unset;
+exports.weeksInYear = weeksInYear;
 exports.withCache = withCache;
 exports.withCacheBucket = withCacheBucket;
 exports.withCacheBucketBatch = withCacheBucketBatch;