@andrew_l/toolkit 0.3.2 → 0.3.4

package/dist/index.cjs

@@ -180,6 +180,9 @@ const primitiveTypeofSet = Object.freeze(
 const isPrimitive = (value) => {
   return value === null || primitiveTypeofSet.has(typeof value);
 };
+function isNode() {
+  return typeof globalThis?.process !== "undefined" && process?.versions?.node != null;
+}
 
 function arrayable(value) {
   const result = Array.isArray(value) ? value : value === null ? [] : value === void 0 ? [] : isString(value) ? value.split(",").map((v) => v.trim()).filter(Boolean) : [value];
@@ -291,13 +294,50 @@ function groupBy(array, keyBy, objectMode) {
 
 function intersection(...arrays) {
   if (arrays.length === 0) return [];
-  if (arrays.length === 1) return arrays[0];
+  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 intersectionBy(keyBy, ...arrays) {
+  var arraysLength = arrays.length;
+  if (arraysLength === 0) return [];
+  if (arraysLength === 1) return [...arrays[0]];
+  var getItemKey = isFunction(keyBy) ? keyBy : (item) => item?.[keyBy];
+  arrays = arrays.toSorted((a, b) => a.length - b.length);
+  var arrayLengths = [arraysLength];
+  var arrayIndices = [0];
+  var arraySets = [/* @__PURE__ */ new Set()];
+  var key1, key2;
+  var i;
+  for (i = 1; i < arraysLength; i++) {
+    arrayLengths[i] = arrays[i].length;
+    arrayIndices[i] = 0;
+    arraySets[i] = /* @__PURE__ */ new Set();
+  }
+  return arrays[0].filter((item) => {
+    key1 = getItemKey(item);
+    if (arraySets[0].has(key1)) return false;
+    arraySets[0].add(key1);
+    loop: for (i = 1; i < arraysLength; i++) {
+      if (arraySets[i].has(key1)) {
+        continue loop;
+      }
+      for (; arrayIndices[i] < arrayLengths[i]; arrayIndices[i]++) {
+        key2 = getItemKey(arrays[i][arrayIndices[i]]);
+        arraySets[i].add(key2);
+        if (Object.is(key1, key2)) {
+          continue loop;
+        }
+      }
+      return false;
+    }
+    return true;
+  });
+}
+
 function keyBy(array, keyBy2, objectMode) {
   const getItemKey = isFunction(keyBy2) ? keyBy2 : (item) => item?.[keyBy2];
   if (objectMode === true) {
@@ -824,9 +864,14 @@ class BrowserAssertionError extends Error {
 }
 
 let AssertionError = BrowserAssertionError;
-if (!globalThis.window) {
-  import('node:assert').then((r) => AssertionError = r.AssertionError).catch(() => {
-  });
+if (isNode()) {
+  try {
+    const assert = require("node:assert");
+    if (assert.AssertionError) {
+      AssertionError = assert.AssertionError;
+    }
+  } catch {
+  }
 }
 
 function ok(value, message) {
@@ -896,7 +941,7 @@ function fn(value, message) {
   }
 }
 function greaterThan(value, target, message) {
-  if (!isNumber(value) || value < target) {
+  if (!isNumber(value) || value <= target) {
     throw toError$1(
       greaterThan,
       value,
@@ -1688,6 +1733,433 @@ function bigIntFromBytes(bytes) {
   return decoded;
 }
 
+function toError(value, unknownMessage = "Unknown error") {
+  if (isError(value)) {
+    return value;
+  }
+  const error = new Error(unknownMessage, { cause: value });
+  Error.captureStackTrace(error, toError);
+  return error;
+}
+
+function createFunction(fnName, code, ...args) {
+  try {
+    const fn = new Function(...args, code);
+    fn.code = code;
+    return fn;
+  } catch (err) {
+    throw new Error(
+      `failed to create bitPack.${fnName}()
+Error: ${toError(err).message}
+-- CODE START --
+${code}
+-- CODE END--`
+    );
+  }
+}
+
+function bitPack(options) {
+  notEmpty(options.fields, "fields cannot be empty");
+  greaterThan(options.totalBits, 0, "totalBits must be greater than 0");
+  const fields = buildFieldsInfo$1(options.fields, options.totalBits);
+  const plan = buildPlan(fields);
+  const containersCount = Math.ceil(options.totalBits / 32);
+  const buf = new Uint8Array(containersCount * 4);
+  const baseCode = [
+    "\n// Field init",
+    initFields(fields),
+    "\n// Plan",
+    compilePlan(plan, options.optimize)
+  ];
+  const fnBufferCode = [
+    ...baseCode,
+    "\n// Return result",
+    buildBufferResult(containersCount)
+  ].join("\n");
+  const fnBuffer = createFunction(
+    "buffer",
+    fnBufferCode,
+    "data"
+  );
+  const fnBigIntCode = [
+    ...baseCode,
+    "\n// Return result",
+    buildBigIntResult(containersCount)
+  ].join("\n");
+  const fnBigInt = createFunction(
+    "bigint",
+    fnBigIntCode,
+    "data"
+  );
+  const fnNumberCode = [
+    ...baseCode,
+    "\n// Return result",
+    buildNumberResult()
+  ].join("\n");
+  const fnNumber = createFunction(
+    "number",
+    fnNumberCode,
+    "data"
+  );
+  const fnBitsCode = [
+    ...baseCode,
+    "\n// Return result",
+    buildBitsResult(containersCount, options.totalBits)
+  ].join("\n");
+  const fnBits = createFunction("bits", fnBitsCode, "data");
+  if (!options.debug) {
+    def(fnBuffer, "code", void 0);
+    def(fnBigInt, "code", void 0);
+    def(fnNumber, "code", void 0);
+    def(fnBits, "code", void 0);
+  }
+  return {
+    buffer: fnBuffer,
+    bigint: fnBigInt,
+    number: fnNumber,
+    bits: fnBits,
+    plan: options.debug ? plan : void 0,
+    __buf: buf
+  };
+}
+function initFields(fields) {
+  return fields.map((field) => {
+    if (field.bits > 32) {
+      return [
+        `var ${field.id}_high = (data['${field.name}'] / 0x100000000) | 0;`,
+        `var ${field.id}_low = (data['${field.name}'] >>> 0);`
+      ].join("\n");
+    }
+    if (field.take === "high") {
+      return `var ${field.id} = (data['${field.name}'] / 0x100000000) | 0;`;
+    }
+    return `var ${field.id} = (data['${field.name}'] & 0x${field.mask.toString(16)}) >>> 0;`;
+  }).join("\n");
+}
+function buildBufferResult(containersCount) {
+  const lines = [`var buf = this.__buf;`];
+  for (let i = 0; i < containersCount; i++) {
+    const containerIndex = containersCount - 1 - i;
+    lines.push(
+      `buf[${i * 4}] = c_${containerIndex} >>> 24;`,
+      `buf[${i * 4 + 1}] = c_${containerIndex} >>> 16;`,
+      `buf[${i * 4 + 2}] = c_${containerIndex} >>> 8;`,
+      `buf[${i * 4 + 3}] = c_${containerIndex};`
+    );
+  }
+  lines.push("return buf;");
+  return lines.join("\n");
+}
+function buildBigIntResult(containersCount) {
+  const parts = [];
+  for (let i = 0; i < containersCount; i++) {
+    const containerIndex = containersCount - 1 - i;
+    if (containerIndex > 0) {
+      parts.push(
+        `(BigInt(c_${containerIndex} >>> 0) << ${containerIndex * 32}n)`
+      );
+    } else {
+      parts.push(`BigInt(c_${containerIndex} >>> 0)`);
+    }
+  }
+  return `return (
+  ${parts.join(" |\n  ")}
+);`;
+}
+function buildNumberResult(containersCount) {
+  return `return c_0;`;
+}
+function buildBitsResult(containersCount, totalBits) {
+  const parts = [];
+  for (let i = 0; i < containersCount; i++) {
+    const containerIndex = containersCount - 1 - i;
+    if (containerIndex > 0) {
+      parts.push(
+        `(BigInt(c_${containerIndex} >>> 0) << ${containerIndex * 32}n)`
+      );
+    } else {
+      parts.push(`BigInt(c_${containerIndex} >>> 0)`);
+    }
+  }
+  return `return (
+  ${parts.join(" |\n  ")}
+).toString(2).padStart(${totalBits}, '0');`;
+}
+function compilePlan(plan, optimize) {
+  if (optimize) {
+    plan = optimizePlan(plan);
+  }
+  const assigned = /* @__PURE__ */ new Set();
+  return plan.map((item) => compilePlanItem(item, assigned)).join("\n");
+}
+function optimizePlan(plan) {
+  return plan.reduce((result, item) => {
+    const prev = result.at(-1);
+    if (canMergeSetOperations(prev, item)) {
+      result.pop();
+      result.push({
+        object: "set",
+        container: item.container,
+        child: {
+          object: "value",
+          value: [
+            compilePlanItem(prev.child),
+            compilePlanItem(item.child)
+          ].join(" |\n  ")
+        }
+      });
+    } else {
+      result.push(item);
+    }
+    return result;
+  }, []);
+}
+function canMergeSetOperations(prev, current) {
+  return prev?.object === "set" && current.object === "set" && prev.container === current.container;
+}
+function compilePlanItem(plan, assigned) {
+  switch (plan.object) {
+    case "set":
+      if (assigned && !assigned.has(plan.container)) {
+        assigned.add(plan.container);
+        return `var c_${plan.container} = ${compilePlanItem(plan.child)};`;
+      }
+      return `c_${plan.container} |= ${compilePlanItem(plan.child)};`;
+    case "value":
+      const offset = plan.offset ?? 0;
+      return offset > 0 ? `(${plan.value}) << ${offset}` : `(${plan.value})`;
+    default:
+      throw new Error(`Unknown plan object: ${plan.object}`);
+  }
+}
+function buildPlan(fields) {
+  const result = [];
+  for (const field of fields) {
+    const startContainer = Math.floor(field.startBit / 32);
+    const endContainer = Math.floor(field.endBit / 32);
+    if (startContainer === endContainer) {
+      addSingleContainerField(field, result);
+    } else if (field.bits <= 32) {
+      addSpanningField(field, result);
+    } else {
+      addLargeField(field, result);
+    }
+  }
+  return result;
+}
+function addSingleContainerField(field, result) {
+  result.push({
+    object: "set",
+    container: Math.floor(field.startBit / 32),
+    child: {
+      object: "value",
+      offset: field.startBit % 32,
+      value: field.id
+    }
+  });
+}
+function addSpanningField(field, result) {
+  const startContainer = Math.floor(field.startBit / 32);
+  const endContainer = Math.floor(field.endBit / 32);
+  const firstContainerBits = 32 - field.startBit % 32;
+  result.push({
+    object: "set",
+    container: startContainer,
+    child: {
+      object: "value",
+      offset: field.startBit % 32,
+      value: `(${field.id}) & ${(1 << firstContainerBits) - 1}`
+    }
+  });
+  result.push({
+    object: "set",
+    container: endContainer,
+    child: {
+      object: "value",
+      value: `(${field.id}) >>> ${firstContainerBits}`
+    }
+  });
+}
+function addLargeField(field, result) {
+  const startContainer = Math.floor(field.startBit / 32);
+  const endContainer = Math.floor(field.endBit / 32);
+  const startOffset = field.startBit % 32;
+  ok(
+    startContainer !== endContainer,
+    `Large field ${field.name} fits in single container - logic error`
+  );
+  ok(
+    endContainer - startContainer === 1,
+    `Fields spanning more than 2 containers (${field.bits} bits) not yet supported`
+  );
+  const bitsInLowerContainer = 32 - startOffset;
+  result.push({
+    object: "set",
+    container: endContainer,
+    child: {
+      object: "value",
+      offset: startOffset,
+      value: `${field.id}_high`
+    }
+  });
+  if (bitsInLowerContainer < 32) {
+    result.push({
+      object: "set",
+      container: endContainer,
+      child: {
+        object: "value",
+        value: `${field.id}_low >>> ${bitsInLowerContainer}`
+      }
+    });
+  }
+  if (field.bits > 32) {
+    result.push({
+      object: "set",
+      container: startContainer,
+      child: {
+        object: "value",
+        offset: startOffset,
+        value: `${field.id}_low`
+      }
+    });
+  }
+}
+function buildFieldsInfo$1(fields, totalBits) {
+  const result = [];
+  let currentBitPosition = totalBits;
+  fields.forEach((field, idx) => {
+    const startBit = currentBitPosition - field.bits;
+    const endBit = currentBitPosition - 1;
+    result.push({
+      id: `f_${idx}`,
+      ...field,
+      startBit,
+      endBit,
+      mask: Math.pow(2, field.bits) - 1
+    });
+    currentBitPosition -= field.bits;
+  });
+  return result;
+}
+
+function bitUnpack(options) {
+  notEmpty(options.fields, "fields cannot be empty");
+  greaterThan(options.totalBits, 0, "totalBits must be greater than 0");
+  const fields = buildFieldsInfo(options.fields, options.totalBits);
+  const fnBigIntCode = [`return ${compileFields(fields)};`].join("\n");
+  const fnBigInt = createFunction(
+    "bigint",
+    fnBigIntCode,
+    "data"
+  );
+  const fnNumberCode = [
+    "\n// Extract container from number",
+    "data = BigInt(data);",
+    "\n// Return result",
+    `return ${compileFields(fields)};`
+  ].join("\n");
+  const fnNumber = createFunction(
+    "number",
+    fnNumberCode,
+    "data"
+  );
+  const fnBufferCode = [
+    "\n// Extract bytes from buffer (big-endian)",
+    extractBigIntFromBuffer(options.totalBits),
+    "\n// Return result",
+    `return ${compileFields(fields)};`
+  ].join("\n");
+  const fnBuffer = createFunction(
+    "buffer",
+    fnBufferCode,
+    "data"
+  );
+  const fnBitsCode = [
+    "\n// Convert bits string to bigint",
+    'var data = BigInt("0b" + bits);',
+    "\n// Return result",
+    `return ${compileFields(fields)};`
+  ].join("\n");
+  const fnBits = createFunction("bits", fnBitsCode, "bits");
+  if (!options.debug) {
+    def(fnBuffer, "code", void 0);
+    def(fnBigInt, "code", void 0);
+    def(fnNumber, "code", void 0);
+    def(fnBits, "code", void 0);
+  }
+  return {
+    buffer: fnBuffer,
+    bigint: fnBigInt,
+    number: fnNumber,
+    bits: fnBits
+  };
+}
+function compileFields(fields) {
+  const lines = ["{"];
+  for (const field of fields) {
+    if (field.startBit === 0) {
+      lines.push(
+        `  ['${field.name}']: Number(data & 0x${field.mask.toString(16)}n),`
+      );
+    } else {
+      lines.push(
+        `  ['${field.name}']: Number((data >> ${field.startBit}n) & 0x${field.mask.toString(16)}n),`
+      );
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function extractBigIntFromBuffer(totalBits) {
+  const totalBytes = Math.ceil(totalBits / 8);
+  const chunks = [];
+  let byteIndex = 0;
+  let remainingBytes = totalBytes;
+  while (remainingBytes > 0) {
+    if (remainingBytes >= 4) {
+      const shift = (remainingBytes - 4) * 8;
+      const chunk = `((data[${byteIndex}] << 24) | (data[${byteIndex + 1}] << 16) | (data[${byteIndex + 2}] << 8) | data[${byteIndex + 3}]) >>> 0`;
+      if (shift === 0) {
+        chunks.push(`BigInt(${chunk})`);
+      } else {
+        chunks.push(`(BigInt(${chunk}) << ${shift}n)`);
+      }
+      byteIndex += 4;
+      remainingBytes -= 4;
+    } else {
+      let chunk;
+      if (remainingBytes === 3) {
+        chunk = `(data[${byteIndex}] << 16) | (data[${byteIndex + 1}] << 8) | data[${byteIndex + 2}]`;
+      } else if (remainingBytes === 2) {
+        chunk = `(data[${byteIndex}] << 8) | data[${byteIndex + 1}]`;
+      } else {
+        chunk = `data[${byteIndex}]`;
+      }
+      chunks.push(`BigInt(${chunk})`);
+      remainingBytes = 0;
+    }
+  }
+  return `data =
+    ${chunks.join("\n  | ")};`;
+}
+function buildFieldsInfo(fields, totalBits) {
+  const result = [];
+  let currentBitPosition = totalBits;
+  fields.forEach((field, idx) => {
+    const startBit = currentBitPosition - field.bits;
+    const endBit = currentBitPosition - 1;
+    result.push({
+      id: `f_${idx}`,
+      ...field,
+      mask: (1n << BigInt(field.bits)) - 1n,
+      startBit,
+      endBit
+    });
+    currentBitPosition -= field.bits;
+  });
+  return result;
+}
+
 function bytesToBase64(data, { encoding = "base64", padding } = {}) {
   if (encoding === "base64") {
     return base64.encode(data, { includePadding: padding ?? true });
@@ -1760,92 +2232,453 @@ function uint8ToUint32(value) {
   return uint32Array;
 }
 
-const objectKeys = /* @__PURE__ */ new WeakMap();
-const BSON_TYPES = Object.freeze(/* @__PURE__ */ new Set(["ObjectID", "ObjectId"]));
-const SYM_WITH_CACHE = Symbol();
-const argToKey = (value, options = { objectStrategy: "ref" }) => {
-  let result = "";
-  if (isObject(value)) {
-    if (BSON_TYPES.has(value?._bsontype)) {
-      return String(value);
+const DateType = {
+  placeholder: "$date",
+  encode: (value) => {
+    if (value instanceof Date) {
+      return value.getTime();
     }
-    let key;
-    if (options.objectStrategy === "json") {
-      key = JSON.stringify(value);
-    } else {
-      key = objectKeys.get(value);
-      if (!key) {
-        key = createRadomKey();
-        objectKeys.set(value, key);
-      }
+  },
+  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
+      };
     }
-    return key;
-  } else if (Array.isArray(value)) {
-    result += value.map((v) => argToKey(v, options)).join("/");
-  } else {
-    result = String(value);
+  },
+  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);
   }
-  return result;
 };
-function createRadomKey() {
-  return Date.now() + "_" + randomString(16);
-}
-
-function createWithCache({
-  fn,
-  getPointer,
-  getBucket,
-  objectStrategy = "ref"
-}) {
-  const isAsync = fn.constructor.name === "AsyncFunction";
-  const argToKeyOptions = { objectStrategy };
-  const $cache = {
-    getBucket: () => getBucket(getPointer()),
-    getPointer,
-    argToKeyOptions
-  };
-  const wrapFn = function(...args) {
-    const storage = getBucket(getPointer());
-    const cacheKey = args.map((v) => argToKey(v, argToKeyOptions)).join("_");
-    if (storage.has(cacheKey)) {
-      const value = storage.get(cacheKey);
-      return isAsync ? Promise.resolve(value) : value;
+const BigIntType = {
+  placeholder: "$bigint",
+  encode: (value) => {
+    if (typeof value === "bigint") {
+      return base64.encode(bigIntBytes(value), { includePadding: false });
     }
-    const newValue = fn.apply(this, args);
-    if (isPromise(newValue)) {
-      return newValue.then((value) => {
-        storage.set(cacheKey, value);
-        return value;
-      });
+  },
+  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()));
     }
-    storage.set(cacheKey, newValue);
-    return newValue;
-  };
-  wrapFn.$cache = $cache;
-  def(wrapFn, SYM_WITH_CACHE, true);
-  return wrapFn;
-}
-function isWithCache(value) {
-  return !!value && value[SYM_WITH_CACHE] === true;
-}
-
-const cache = /* @__PURE__ */ new WeakMap();
-function withCache(...args) {
-  let options = {};
-  let fn = noop;
-  if (isFunction(args[0])) {
-    fn = args[0];
-  } else if (isFunction(args[1])) {
-    options = args[0] || {};
-    fn = args[1];
+  },
+  decode(value) {
+    return new Map(value);
   }
-  const pointer = options.cachePointer || fn;
-  const getPointer = () => pointer;
-  const getBucket = (pointer2) => {
-    let fnCache = cache.get(pointer2);
-    if (!fnCache) {
-      fnCache = /* @__PURE__ */ new Map();
-      cache.set(pointer2, fnCache);
+};
+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({
+      start(controller) {
+        return Promise.resolve().then(() => {
+          if (onStart) {
+            return onStart(controller);
+          }
+        }).then(() => {
+          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,
+    onStart(controller) {
+      if (!prepend) {
+        controller.enqueue(`{"${resultKey}":`);
+        return Promise.resolve();
+      }
+      return Promise.resolve().then(() => prepend()).then((data) => {
+        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}":`);
+      });
+    },
+    onFlush(controller) {
+      if (!append) {
+        controller.enqueue("}");
+        return Promise.resolve();
+      }
+      return Promise.resolve().then(() => append()).then((data) => {
+        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 objectKeys = /* @__PURE__ */ new WeakMap();
+const BSON_TYPES = Object.freeze(/* @__PURE__ */ new Set(["ObjectID", "ObjectId"]));
+const SYM_WITH_CACHE = Symbol();
+const argToKey = (value, options = { objectStrategy: "ref" }) => {
+  let result = "";
+  if (isObject(value)) {
+    if (BSON_TYPES.has(value?._bsontype)) {
+      return String(value);
+    }
+    let key;
+    if (options.objectStrategy === "json") {
+      key = instance.stringify(value);
+    } else {
+      key = objectKeys.get(value);
+      if (!key) {
+        key = createRadomKey();
+        objectKeys.set(value, key);
+      }
+    }
+    return key;
+  } else if (Array.isArray(value)) {
+    result += value.map((v) => argToKey(v, options)).join("/");
+  } else {
+    result = String(value);
+  }
+  return result;
+};
+function createRadomKey() {
+  return Date.now() + "_" + randomString(16);
+}
+
+function createWithCache({
+  fn,
+  getPointer,
+  getBucket,
+  objectStrategy = "ref"
+}) {
+  const isAsync = fn.constructor.name === "AsyncFunction";
+  const argToKeyOptions = { objectStrategy };
+  const $cache = {
+    getBucket: () => getBucket(getPointer()),
+    getPointer,
+    argToKeyOptions
+  };
+  const wrapFn = function(...args) {
+    const storage = getBucket(getPointer());
+    const cacheKey = args.map((v) => argToKey(v, argToKeyOptions)).join("_");
+    if (storage.has(cacheKey)) {
+      const value = storage.get(cacheKey);
+      return isAsync ? Promise.resolve(value) : value;
+    }
+    const newValue = fn.apply(this, args);
+    if (isPromise(newValue)) {
+      return newValue.then((value) => {
+        storage.set(cacheKey, value);
+        return value;
+      });
+    }
+    storage.set(cacheKey, newValue);
+    return newValue;
+  };
+  wrapFn.$cache = $cache;
+  def(wrapFn, SYM_WITH_CACHE, true);
+  return wrapFn;
+}
+function isWithCache(value) {
+  return !!value && value[SYM_WITH_CACHE] === true;
+}
+
+const cache = /* @__PURE__ */ new WeakMap();
+function withCache(...args) {
+  let options = {};
+  let fn = noop;
+  if (isFunction(args[0])) {
+    fn = args[0];
+  } else if (isFunction(args[1])) {
+    options = args[0] || {};
+    fn = args[1];
+  }
+  const pointer = options.cachePointer || fn;
+  const getPointer = () => pointer;
+  const getBucket = (pointer2) => {
+    let fnCache = cache.get(pointer2);
+    if (!fnCache) {
+      fnCache = /* @__PURE__ */ new Map();
+      cache.set(pointer2, fnCache);
     }
     return fnCache;
   };
@@ -2459,15 +3292,6 @@ function captureStackTrace(till) {
   return (err.stack || "").slice(6);
 }
 
-function toError(value, unknownMessage = "Unknown error") {
-  if (isError(value)) {
-    return value;
-  }
-  const error = new Error(unknownMessage, { cause: value });
-  Error.captureStackTrace(error, toError);
-  return error;
-}
-
 function catchError(fn) {
   try {
     const res = fn();
@@ -3417,678 +4241,317 @@ var TABLE = new Int32Array([
   755167117
 ]);
 function crc32(value, seed) {
-  if (isString(value)) {
-    return crc32(textEncoder.encode(value), seed);
-  }
-  var crc = seed === 0 ? 0 : ~~seed ^ -1;
-  if (value instanceof Uint8Array) {
-    for (var index = 0; index < value.length; index++) {
-      crc = TABLE[(crc ^ value[index]) & 255] ^ crc >>> 8;
-    }
-  } else {
-    for (var current of value) {
-      for (var index = 0; index < current.length; index++) {
-        crc = TABLE[(crc ^ current[index]) & 255] ^ crc >>> 8;
-      }
-    }
-  }
-  return crc ^ -1;
-}
-
-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");
+  if (isString(value)) {
+    return crc32(textEncoder.encode(value), seed);
   }
-}
-
-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;
+  var crc = seed === 0 ? 0 : ~~seed ^ -1;
+  if (value instanceof Uint8Array) {
+    for (var index = 0; index < value.length; index++) {
+      crc = TABLE[(crc ^ value[index]) & 255] ^ crc >>> 8;
+    }
+  } else {
+    for (var current of value) {
+      for (var index = 0; index < current.length; index++) {
+        crc = TABLE[(crc ^ current[index]) & 255] ^ crc >>> 8;
+      }
+    }
   }
-  return isNumber(fromValue) ? fromValue : 0;
-}
-
-function dateInDays(days, fromValue = Date.now()) {
-  return new Date(timestampMs(fromValue) + days * 60 * 60 * 24 * 1e3);
+  return crc ^ -1;
 }
 
-function dateInSeconds(seconds, fromValue = Date.now()) {
-  return new Date(timestampMs(fromValue) + seconds * 1e3);
+function isDateObject(value) {
+  return has(value, ["year", "month", "date"]) && isNumber(value.year) && isNumber(value.month) && isNumber(value.date);
 }
 
-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) };
+function createDateObject(value, returnsNullWhenInvalid = false) {
+  let result = null;
+  let inputValue = value;
+  if (isNumber(inputValue) || isString(inputValue)) {
+    inputValue = new Date(inputValue);
   }
-  if (h === endTime.h) {
-    return { h, m: getRandomInt(0, endTime.m) };
+  if (isDate(inputValue)) {
+    result = {
+      year: inputValue.getFullYear(),
+      month: inputValue.getMonth() + 1,
+      date: inputValue.getDate()
+    };
+  } else if (isDateObject(inputValue)) {
+    result = { ...inputValue };
   }
-  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;
+  ok(
+    returnsNullWhenInvalid || !!result,
+    `Failed to date parse: ${value}.`
+  );
+  return result;
 }
 
-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 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 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;
+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 };
   }
-  const h = Math.floor(value / 60);
-  const m = value % 60;
-  return { h, m };
-}
-
-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;
+  if (isDate(inputValue)) {
+    result = {
+      h: inputValue.getHours(),
+      m: inputValue.getMinutes()
+    };
+  } else if (isTimeObject(inputValue)) {
+    result = { ...inputValue };
   }
-  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;
+  ok(
+    returnsNullWhenInvalid || !!result,
+    `Failed to time parse: ${value}.`
+  );
+  return result;
 }
 
-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 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
 };
-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);
+class TimeSpan {
+  constructor(value, unit) {
+    this.value = value;
+    this.unit = unit;
   }
-};
-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);
+  /**
+   * 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;
   }
-};
-
-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'.
+   * 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
    */
-  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);
-    };
+  seconds() {
+    return this.milliseconds() / UNIT_TO_MS.s;
   }
   /**
-   * The vendor name used for the custom MIME type definition.
-   * If null, defaults to 'application/json'.
+   * 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
    */
-  get vendorName() {
-    return this._vendorName;
+  minutes() {
+    return this.milliseconds() / UNIT_TO_MS.m;
   }
-  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`;
-    }
+  /**
+   * 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;
   }
   /**
-   * Adds a custom type handler for encoding/decoding logic.
-   * Ensures type placeholders are unique and adhere to conventions.
+   * 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
    */
-  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;
+  days() {
+    return this.milliseconds() / UNIT_TO_MS.d;
   }
   /**
-   * 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.
+   * 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
    */
-  stringify(value, space) {
-    if (this.pure) {
-      return JSON.stringify(value, void 0, space);
-    }
-    return JSON.stringify(this.encode(value), void 0, space);
+  weeks() {
+    return this.milliseconds() / UNIT_TO_MS.w;
   }
   /**
-   * Parses a JSON string using custom decoding logic.
-   * @param {string} value - The JSON string to parse.
-   * @returns {any} - The decoded JavaScript object.
+   * 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
    */
-  parse(value) {
-    if (this.pure) {
-      return JSON.parse(value);
-    }
-    return JSON.parse(value, this.reviewerReady);
+  add(value, unit = "ms") {
+    const multiplier = UNIT_TO_MS[unit];
+    return new TimeSpan(this.milliseconds() + value * multiplier, "ms");
   }
-  /** @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;
+  /**
+   * 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");
   }
-  /** @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 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 firstKey(value) {
-  if (!isObject(value)) return null;
-  for (const key in value) {
-    return key;
+
+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) };
   }
-  return null;
+  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 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;
+function isTimeValue(value) {
+  return isTimeString(value) || isTimeObject(value);
 }
 
-class EJSONStream extends TransformStream {
-  ejson;
-  constructor({ ejson, cl, op, sep, onFlush, onStart }) {
-    let firstChunk = true;
-    super({
-      start(controller) {
-        return Promise.resolve().then(() => {
-          if (onStart) {
-            return onStart(controller);
-          }
-        }).then(() => {
-          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;
+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;
   }
-  /**
-   * The vendor name used for the custom MIME type definition.
-   * If null, defaults to 'application/json'.
-   */
-  get vendorName() {
-    return this.ejson.vendorName;
+  if (value === 0) {
+    return { h: 0, m: 0 };
   }
-  /**
-   * MIME type based on the provided vendor name or defaults to 'application/json'.
-   */
-  get mimetype() {
-    return this.ejson.mimetype;
+  value = value % 1440;
+  if (value < 0) {
+    value += 1440;
   }
+  const h = Math.floor(value / 60);
+  const m = value % 60;
+  return { h, m };
 }
 
-const instance = createEJSON(true);
+function timestampToDate(value) {
+  if (!isNumber(value)) return null;
+  return new Date(value * 1e3);
+}
 
-function createEJSONStream(options = {}) {
-  if (options.resultKey || options.append || options.prepend) {
-    return createEJSONStreamPayload(options);
+function timeStringify(value, returnsNullWhenInvalid = false) {
+  const timeObject = createTimeObject(value, true);
+  if (!timeObject) {
+    ok(
+      returnsNullWhenInvalid,
+      "Failed to stringify time from: " + JSON.stringify(value)
+    );
+    return null;
   }
-  return new EJSONStream(getOptions(options));
+  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 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,
-    onStart(controller) {
-      if (!prepend) {
-        controller.enqueue(`{"${resultKey}":`);
-        return Promise.resolve();
-      }
-      return Promise.resolve().then(() => prepend()).then((data) => {
-        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}":`);
-      });
-    },
-    onFlush(controller) {
-      if (!append) {
-        controller.enqueue("}");
-        return Promise.resolve();
-      }
-      return Promise.resolve().then(() => append()).then((data) => {
-        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 timeToMinutes(value) {
+  const time = createTimeObject(value);
+  return time.h * 60 + time.m;
 }
-function getOptions(options) {
-  const { ejson = instance, cl = "]", op = "[", sep = "," } = options;
-  return {
-    cl,
-    ejson,
-    op,
-    sep
-  };
+
+function weeksInYear(year) {
+  const target = new Date(Date.UTC(year + 1, 0, 1));
+  const dayNumber = target.getDay();
+  return dayNumber < 4 ? 52 : 53;
 }
 
 const env = (() => {
@@ -4153,7 +4616,7 @@ function createEnvParser(targetObject) {
         return defaultValue;
       }
       try {
-        return JSON.parse(targetObject[key]);
+        return instance.parse(targetObject[key]);
       } catch (err) {
         console.warn("Failed to parse json env variable", key);
         return defaultValue;
@@ -4761,28 +5224,6 @@ const logger = (...baseArgs) => {
   return instance;
 };
 
-function asyncFilter(array, predicate) {
-  var i = 0;
-  var result = [];
-  var cooldown = nextTickIteration(10);
-  return new Promise((resolve, reject) => {
-    var processNextBatch = () => {
-      if (i < array.length) {
-        cooldown().then(() => predicate(array[i], i, array)).then((valid) => {
-          if (Boolean(valid)) {
-            result.push(array[i]);
-          }
-          i++;
-          setTimeout(processNextBatch, 0);
-        }).catch(reject);
-      } else {
-        resolve(result);
-      }
-    };
-    processNextBatch();
-  });
-}
-
 function nextTickIteration(amount, delay = "tick") {
   let counter = 0;
   const tickInterval = delay === "tick";
@@ -4802,6 +5243,45 @@ function nextTickIteration(amount, delay = "tick") {
   };
 }
 
+function asyncFilter(array, predicate, { concurrency = 1 } = {}) {
+  concurrency = Math.max(concurrency, 1);
+  if (array.length === 0) {
+    return Promise.resolve([]);
+  }
+  var result = [];
+  var currentIndex = 0;
+  var completed = 0;
+  var hasError = false;
+  var cooldown = nextTickIteration(10);
+  return new Promise((resolve, reject) => {
+    var processItem = (index) => {
+      if (hasError || index >= array.length) return;
+      cooldown().then(() => predicate(array[index], index, array)).then((include) => {
+        if (hasError) return;
+        if (include) {
+          result.push(index);
+        }
+        completed++;
+        if (completed >= array.length) {
+          resolve(result.toSorted((a, b) => a - b).map((idx) => array[idx]));
+        } else {
+          if (currentIndex < array.length) {
+            processItem(currentIndex++);
+          }
+        }
+      }).catch((error) => {
+        if (!hasError) {
+          hasError = true;
+          reject(error);
+        }
+      });
+    };
+    for (; currentIndex < concurrency; currentIndex++) {
+      processItem(currentIndex);
+    }
+  });
+}
+
 function asyncFind(array, callbackfn) {
   var i = 0;
   var cooldown = nextTickIteration(10);
@@ -4826,35 +5306,36 @@ function asyncFind(array, callbackfn) {
 
 function asyncForEach(array, callbackfn, { concurrency = 1 } = {}) {
   concurrency = Math.max(concurrency, 1);
-  var i = 0;
+  if (array.length === 0) {
+    return Promise.resolve();
+  }
+  var hasError = false;
+  var completed = 0;
+  var currentIndex = 0;
   var cooldown = nextTickIteration(10);
-  var tasks = Array(concurrency);
   return new Promise((resolve, reject) => {
-    var processNextBatch = () => {
-      if (i >= array.length) {
-        resolve();
-        return;
-      }
-      cooldown().then(() => {
-        for (var idx = 0; idx < concurrency; idx++) {
-          tasks[idx] = Promise.resolve(i);
-          if (i < array.length) {
-            tasks[idx] = tasks[idx].then(
-              (itemIndex) => callbackfn(array[itemIndex], itemIndex, array)
-            );
+    var processItem = (index) => {
+      if (hasError || index >= array.length) return;
+      cooldown().then(() => callbackfn(array[index], index, array)).then((transformed) => {
+        if (hasError) return;
+        completed++;
+        if (completed >= array.length) {
+          resolve();
+        } else {
+          if (currentIndex < array.length) {
+            processItem(currentIndex++);
           }
-          i++;
         }
-        return Promise.all(tasks);
-      }).then(() => {
-        if (i < array.length) {
-          setTimeout(processNextBatch, 0);
-        } else {
-          resolve();
+      }).catch((error) => {
+        if (!hasError) {
+          hasError = true;
+          reject(error);
         }
-      }).catch(reject);
+      });
     };
-    processNextBatch();
+    for (; currentIndex < concurrency; currentIndex++) {
+      processItem(currentIndex);
+    }
   });
 }
 
@@ -4995,38 +5476,38 @@ class AsyncIterableQueue {
 
 function asyncMap(array, callbackfn, { concurrency = 1 } = {}) {
   concurrency = Math.max(concurrency, 1);
-  var result = [];
-  var i = 0;
+  if (array.length === 0) {
+    return Promise.resolve([]);
+  }
+  var hasError = false;
+  var result = Array(array.length);
+  var completed = 0;
+  var currentIndex = 0;
   var cooldown = nextTickIteration(10);
-  var tasks = Array(concurrency);
   return new Promise((resolve, reject) => {
-    var processNextBatch = () => {
-      if (i >= array.length) {
-        resolve(result);
-      } else {
-        cooldown().then(() => {
-          for (var idx = 0; idx < concurrency; idx++) {
-            tasks[idx] = Promise.resolve(i);
-            if (i < array.length) {
-              tasks[idx] = tasks[idx].then(
-                (itemIndex) => callbackfn(array[itemIndex], itemIndex, array)
-              ).then((transformed) => {
-                result.push(transformed);
-              });
-            }
-            i++;
-          }
-          return Promise.all(tasks);
-        }).then(() => {
-          if (i < array.length) {
-            setTimeout(processNextBatch, 0);
-          } else {
-            resolve(result);
+    var processItem = (index) => {
+      if (hasError || index >= array.length) return;
+      cooldown().then(() => callbackfn(array[index], index, array)).then((transformed) => {
+        if (hasError) return;
+        result[index] = transformed;
+        completed++;
+        if (completed >= array.length) {
+          resolve(result);
+        } else {
+          if (currentIndex < array.length) {
+            processItem(currentIndex++);
           }
-        }).catch(reject);
-      }
+        }
+      }).catch((error) => {
+        if (!hasError) {
+          hasError = true;
+          reject(error);
+        }
+      });
     };
-    processNextBatch();
+    for (; currentIndex < concurrency; currentIndex++) {
+      processItem(currentIndex);
+    }
   });
 }
 
@@ -5470,6 +5951,60 @@ function timeout(ms, promiseOrCallback, timeoutError = new AppError(408)) {
   });
 }
 
+const stringifyArgs = (...args) => {
+  return args.map((v) => argToKey(v, { objectStrategy: "json" })).join("_");
+};
+function withResolve(fn, getCacheKey) {
+  const cache = /* @__PURE__ */ new Map();
+  const cacheKeyVariants = arrayable(getCacheKey);
+  return function(...args) {
+    let cacheKey = stringifyArgs(...args);
+    if (cacheKeyVariants?.length) {
+      for (const getCacheKey2 of cacheKeyVariants) {
+        const newCacheKey = getCacheKey2(args, stringifyArgs);
+        if (newCacheKey === null) {
+          cacheKey = Symbol();
+          break;
+        } else if (isString(newCacheKey) && cache.has(newCacheKey)) {
+          cacheKey = newCacheKey;
+          break;
+        }
+      }
+    }
+    const defers = cache.get(cacheKey) || [];
+    const size = defers.length;
+    const q = defer();
+    defers.push(q);
+    cache.set(cacheKey, defers);
+    if (size) {
+      return q.promise;
+    }
+    resolver(this, cacheKey, args);
+    return q.promise;
+  };
+  function resolver(self, cacheKey, args) {
+    const onSuccess = (r) => {
+      const defers = cache.get(cacheKey) || [];
+      for (const q of defers) {
+        q.resolve(r);
+      }
+      cache.delete(cacheKey);
+    };
+    const onError = (r) => {
+      const defers = cache.get(cacheKey) || [];
+      for (const q of defers) {
+        q.reject(r);
+      }
+      cache.delete(cacheKey);
+    };
+    try {
+      fn.apply(self, args).then(onSuccess).catch(onError);
+    } catch (err) {
+      onError(err);
+    }
+  }
+}
+
 exports.AppError = AppError;
 exports.AsyncIterableQueue = AsyncIterableQueue;
 exports.BrowserAssertionError = BrowserAssertionError;
@@ -5506,6 +6041,8 @@ exports.base64url = base64url;
 exports.basex = basex;
 exports.bigIntBytes = bigIntBytes;
 exports.bigIntFromBytes = bigIntFromBytes;
+exports.bitPack = bitPack;
+exports.bitUnpack = bitUnpack;
 exports.blendColors = blendColors;
 exports.buildCssColor = buildCssColor;
 exports.bytesToBase64 = bytesToBase64;
@@ -5539,6 +6076,7 @@ exports.createDeepCloneWith = createDeepCloneWith;
 exports.createEJSON = createEJSON;
 exports.createEJSONStream = createEJSONStream;
 exports.createEnvParser = createEnvParser;
+exports.createFunction = createFunction;
 exports.createRandomizer = createRandomizer;
 exports.createSecureCustomizer = createSecureCustomizer;
 exports.createTimeObject = createTimeObject;
@@ -5590,6 +6128,7 @@ exports.humanFileSize = humanFileSize;
 exports.humanize = humanize;
 exports.interpolateColor = interpolateColor;
 exports.intersection = intersection;
+exports.intersectionBy = intersectionBy;
 exports.isBigInt = isBigInt;
 exports.isBoolean = isBoolean;
 exports.isCached = isCached;
@@ -5605,6 +6144,7 @@ exports.isError = isError;
 exports.isFunction = isFunction;
 exports.isInfinity = isInfinity;
 exports.isMap = isMap;
+exports.isNode = isNode;
 exports.isNullOrUndefined = isNullOrUndefined;
 exports.isNumber = isNumber;
 exports.isObject = isObject;
@@ -5695,5 +6235,6 @@ exports.withCacheFixed = withCacheFixed;
 exports.withCacheLRU = withCacheLRU;
 exports.withDeepClone = withDeepClone;
 exports.withPointerCache = withPointerCache;
+exports.withResolve = withResolve;
 exports.wrapText = wrapText;
 //# sourceMappingURL=index.cjs.map