@yorozu/utils 0.1.1

package/lib/index.js

@@ -0,0 +1,1990 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/arrays/typed/index.ts
+var typed_exports = {};
+__export(typed_exports, {
+  compare: () => compare,
+  equal: () => equal,
+  getPlatformByteOrder: () => getPlatformByteOrder,
+  includes: () => includes,
+  includesArray: () => includesArray,
+  indexOf: () => indexOf,
+  indexOfArray: () => indexOfArray,
+  lastIndexOf: () => lastIndexOf,
+  lastIndexOfArray: () => lastIndexOfArray,
+  toDataView: () => toDataView,
+  view: () => view
+});
+
+// src/arrays/typed/compare.ts
+function compare(a, b) {
+  if (a.length < b.length) return -1;
+  if (a.length > b.length) return 1;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] < b[i]) return -1;
+    if (a[i] > b[i]) return 1;
+  }
+  return 0;
+}
+function equal(a, b) {
+  return compare(a, b) === 0;
+}
+
+// src/arrays/typed/find.ts
+function indexOf(haystack, needle, start = 0) {
+  for (let i = start; i < haystack.length; i++) {
+    if (haystack[i] === needle) return i;
+  }
+  return -1;
+}
+function lastIndexOf(haystack, needle, start = haystack.length - 1) {
+  for (let i = start; i >= 0; i--) {
+    if (haystack[i] === needle) return i;
+  }
+  return -1;
+}
+function indexOfArray(haystack, needle, start = 0) {
+  if (needle.length === 0) return start;
+  if (needle.length === 1) return indexOf(haystack, needle[0], start);
+  let max3 = haystack.length - needle.length;
+  for (let i = start; i <= max3; i++) {
+    if (haystack[i] === needle[0]) {
+      let j = 1;
+      for (; j < needle.length; j++) {
+        if (haystack[i + j] !== needle[j]) break;
+      }
+      if (j === needle.length) return i;
+    }
+  }
+  return -1;
+}
+function lastIndexOfArray(haystack, needle, start = haystack.length - 1) {
+  if (needle.length === 0) return start;
+  if (needle.length === 1) return lastIndexOf(haystack, needle[0], start);
+  let maxStart = haystack.length - needle.length;
+  let effectiveStart = start > maxStart ? maxStart : start;
+  for (let i = effectiveStart; i >= 0; i--) {
+    let j = 0;
+    for (; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) break;
+    }
+    if (j === needle.length) return i;
+  }
+  return -1;
+}
+function includes(haystack, needle) {
+  return indexOf(haystack, needle) !== -1;
+}
+function includesArray(haystack, needle) {
+  return indexOfArray(haystack, needle) !== -1;
+}
+
+// src/arrays/typed/misc.ts
+function toDataView(buf) {
+  return new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function view(ctor, buf) {
+  let byteLength = buf.byteLength;
+  let bytesPerElement = ctor.BYTES_PER_ELEMENT;
+  if (byteLength % bytesPerElement !== 0) {
+    throw new RangeError(`byteLength (${byteLength}) is not a multiple of ${bytesPerElement} for ${ctor.name}`);
+  }
+  let length = byteLength / bytesPerElement;
+  return new ctor(buf.buffer, buf.byteOffset, length);
+}
+function getPlatformByteOrder() {
+  if (getPlatformByteOrder._cachedByteOrder === null) {
+    let buffer = new ArrayBuffer(2);
+    let view2 = new DataView(buffer);
+    view2.setUint16(0, 4660, true);
+    getPlatformByteOrder._cachedByteOrder = new Uint16Array(buffer)[0] === 4660;
+  }
+  return getPlatformByteOrder._cachedByteOrder ? "little" : "big";
+}
+getPlatformByteOrder._cachedByteOrder = null;
+
+// src/arrays/u8/index.ts
+var u8_exports = {};
+__export(u8_exports, {
+  BufferPool: () => BufferPool,
+  allocate: () => allocate,
+  allocateWith: () => allocateWith,
+  clone: () => clone,
+  concat: () => concat,
+  concat2: () => concat2,
+  concat3: () => concat3,
+  empty: () => empty,
+  readNthBit: () => readNthBit,
+  reverse: () => reverse,
+  setDefaultPool: () => setDefaultPool,
+  swap16: () => swap16,
+  swap32: () => swap32,
+  swap64: () => swap64,
+  swapNibbles: () => swapNibbles,
+  toReversed: () => toReversed,
+  xor: () => xor,
+  xorInPlace: () => xorInPlace
+});
+
+// src/arrays/u8/misc.ts
+var empty = new Uint8Array(0);
+function clone(buf) {
+  return new Uint8Array(buf);
+}
+function readNthBit(byte, bit) {
+  return (byte & 1 << bit) >> bit;
+}
+
+// src/arrays/u8/pool.ts
+var BufferPool = class {
+  size;
+  maxAllocSize;
+  #pool;
+  #offset = 0;
+  constructor(size = 16 * 1024) {
+    this.size = size;
+    this.maxAllocSize = size >>> 1;
+    this.#reallocate();
+  }
+  get #remaining() {
+    return this.size - this.#offset;
+  }
+  allocate(size) {
+    if (size === 0) return empty;
+    if (size > this.maxAllocSize) {
+      return new Uint8Array(size);
+    }
+    if (size > this.#remaining) {
+      this.#reallocate();
+    }
+    let start = this.#offset;
+    this.#offset += size;
+    this.#align();
+    return new Uint8Array(this.#pool, start, size);
+  }
+  reset() {
+    this.#reallocate();
+  }
+  #reallocate() {
+    this.#pool = new ArrayBuffer(this.size);
+    this.#offset = 0;
+  }
+  #align() {
+    let misalignment = this.#offset & 7;
+    if (misalignment !== 0) {
+      this.#offset += 8 - misalignment;
+    }
+  }
+};
+var defaultPool = new BufferPool(16 * 1024);
+function setDefaultPool(size) {
+  defaultPool = new BufferPool(size);
+}
+function allocate(size) {
+  return defaultPool.allocate(size);
+}
+function allocateWith(init) {
+  let buf = allocate(init.length);
+  buf.set(init);
+  return buf;
+}
+
+// src/arrays/u8/concat.ts
+function concat(bufs) {
+  if (bufs.length === 0) {
+    return allocate(0);
+  }
+  if (bufs.length === 1) {
+    return bufs[0];
+  }
+  if (typeof Buffer !== "undefined") {
+    let buf = Buffer.concat(bufs);
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  let length = 0;
+  for (let i = 0; i < bufs.length; i++) {
+    length += bufs[i].length;
+  }
+  let ret = allocate(length);
+  let offset = 0;
+  for (let i = 0; i < bufs.length; i++) {
+    ret.set(bufs[i], offset);
+    offset += bufs[i].length;
+  }
+  return ret;
+}
+function concat2(a, b) {
+  let ret = allocate(a.length + b.length);
+  ret.set(a);
+  ret.set(b, a.length);
+  return ret;
+}
+function concat3(a, b, c) {
+  let ret = allocate(a.length + b.length + c.length);
+  ret.set(a);
+  ret.set(b, a.length);
+  ret.set(c, a.length + b.length);
+  return ret;
+}
+
+// src/arrays/u8/reverse.ts
+function reverse(buffer) {
+  if (buffer.length < 2) return;
+  let left = 0;
+  let right = buffer.length - 1;
+  while (left < right) {
+    let tmp = buffer[left];
+    buffer[left] = buffer[right];
+    buffer[right] = tmp;
+    left++;
+    right--;
+  }
+}
+function toReversed(buffer) {
+  let len = buffer.length;
+  if (len === 0) return allocate(0);
+  if (len === 1) {
+    let result2 = allocate(1);
+    result2[0] = buffer[0];
+    return result2;
+  }
+  let result = allocate(len);
+  let last = len - 1;
+  for (let i = 0; i < len; i++) {
+    result[i] = buffer[last - i];
+  }
+  return result;
+}
+
+// src/arrays/u8/swap.ts
+function swap16(buf) {
+  if (buf.length % 2 !== 0) throw new RangeError(`Buffer length must be a multiple of 2`);
+  for (let i = 0; i < buf.length; i += 2) {
+    let tmp = buf[i];
+    buf[i] = buf[i + 1];
+    buf[i + 1] = tmp;
+  }
+}
+function swap32(buf) {
+  if (buf.length % 4 !== 0) throw new RangeError(`Buffer length must be a multiple of 4`);
+  for (let i = 0; i < buf.length; i += 4) {
+    let tmp = buf[i];
+    buf[i] = buf[i + 3];
+    buf[i + 3] = tmp;
+    tmp = buf[i + 1];
+    buf[i + 1] = buf[i + 2];
+    buf[i + 2] = tmp;
+  }
+}
+function swap64(buf) {
+  if (buf.length % 8 !== 0) throw new RangeError(`Buffer length must be a multiple of 8`);
+  for (let i = 0; i < buf.length; i += 8) {
+    let tmp = buf[i];
+    buf[i] = buf[i + 7];
+    buf[i + 7] = tmp;
+    tmp = buf[i + 1];
+    buf[i + 1] = buf[i + 6];
+    buf[i + 6] = tmp;
+    tmp = buf[i + 2];
+    buf[i + 2] = buf[i + 5];
+    buf[i + 5] = tmp;
+    tmp = buf[i + 3];
+    buf[i + 3] = buf[i + 4];
+    buf[i + 4] = tmp;
+  }
+}
+function swapNibbles(buf) {
+  for (let i = 0; i < buf.length; i++) {
+    buf[i] = (buf[i] & 240) >> 4 | (buf[i] & 15) << 4;
+  }
+}
+
+// src/arrays/u8/xor.ts
+function xor(data, key) {
+  if (key.length < data.length)
+    throw new RangeError(`Key must be at least as long as data (key=${key.length}, data=${data.length})`);
+  let ret = allocate(data.length);
+  for (let i = 0; i < data.length; i++) {
+    ret[i] = data[i] ^ key[i];
+  }
+  return ret;
+}
+function xorInPlace(data, key) {
+  if (key.length < data.length)
+    throw new RangeError(`Key must be at least as long as data (key=${key.length}, data=${data.length})`);
+  for (let i = 0; i < data.length; i++) {
+    data[i] ^= key[i];
+  }
+}
+
+// src/bigint/math.ts
+function bitLength(n) {
+  if (n === 0n) return 0;
+  if (n < 0n) n = -n;
+  let hex = n.toString(16);
+  let len = hex.length;
+  let leadingDigit = parseInt(hex[0], 16);
+  return (len - 1) * 4 + (32 - Math.clz32(leadingDigit));
+}
+function twoMultiplicity(n) {
+  if (n === 0n) return 0n;
+  let m = 0n;
+  let pow = 1n;
+  while (true) {
+    if ((n & pow) !== 0n) return m;
+    m += 1n;
+    pow <<= 1n;
+  }
+}
+function min2(a, b) {
+  return a < b ? a : b;
+}
+function min(...args) {
+  let m = args[0];
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] < m) m = args[i];
+  }
+  return m;
+}
+function max2(a, b) {
+  return a > b ? a : b;
+}
+function max(...args) {
+  let m = args[0];
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] > m) m = args[i];
+  }
+  return m;
+}
+function abs(a) {
+  return a < 0n ? -a : a;
+}
+function euclideanGcd(a, b) {
+  while (b !== 0n) {
+    let t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+}
+function modPowBinary(base, exp, mod) {
+  base %= mod;
+  let result = 1n;
+  while (exp > 0n) {
+    if (exp % 2n === 1n) result = result * base % mod;
+    exp >>= 1n;
+    base = base ** 2n % mod;
+  }
+  return result;
+}
+function modInv(a, n) {
+  let [g, x] = eGcd(toZn(a, n), n);
+  if (g !== 1n) throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`);
+  else return toZn(x, n);
+}
+function eGcd(a, b) {
+  let x = 0n;
+  let y = 1n;
+  let u = 1n;
+  let v = 0n;
+  while (a !== 0n) {
+    let q = b / a;
+    let r = b % a;
+    let m = x - u * q;
+    let n = y - v * q;
+    b = a;
+    a = r;
+    x = u;
+    y = v;
+    u = m;
+    v = n;
+  }
+  return [b, x, y];
+}
+function toZn(a, n) {
+  if (typeof a === "number") a = BigInt(a);
+  if (typeof n === "number") n = BigInt(n);
+  if (n <= 0n) throw new RangeError("n must be greater than 0.");
+  let aZn = a % n;
+  return aZn < 0n ? aZn + n : aZn;
+}
+
+// src/bigint/bytes.ts
+function toBytes(value, length = 0, le = false) {
+  let bits = bitLength(value);
+  let bytes = Math.ceil(bits / 8);
+  if (length !== 0 && bytes > length)
+    throw new RangeError(`Value out of bounds: ${bytes.toString()}, ${length.toString()}.`);
+  if (length === 0) length = bytes;
+  let buf = new ArrayBuffer(length);
+  let u8 = new Uint8Array(buf);
+  let unaligned = length % 8;
+  let dv = new DataView(buf, 0, length - unaligned);
+  for (let i = 0; i < dv.byteLength; i += 8) {
+    dv.setBigUint64(i, value & 0xffffffffffffffffn, true);
+    value >>= 64n;
+  }
+  if (unaligned > 0) {
+    for (let i = length - unaligned; i < length; i++) {
+      u8[i] = Number(value & 0xffn);
+      value >>= 8n;
+    }
+  }
+  if (!le) u8.reverse();
+  return u8;
+}
+function fromBytes(buffer, le = false) {
+  if (le) buffer = u8_exports.toReversed(buffer);
+  let unaligned = buffer.length % 8;
+  let dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength - unaligned);
+  let res = 0n;
+  for (let i = 0; i < dv.byteLength; i += 8) res = res << 64n | BigInt(dv.getBigUint64(i, false));
+  if (unaligned > 0) {
+    for (let i = buffer.length - unaligned; i < buffer.length; i++) res = res << 8n | BigInt(buffer[i]);
+  }
+  return res;
+}
+
+// src/encoding/base64.ts
+var base64_exports = {};
+__export(base64_exports, {
+  decode: () => decode,
+  decodedLength: () => decodedLength,
+  encode: () => encode,
+  encodeLookup: () => encodeLookup,
+  encodedLength: () => encodedLength2,
+  lookup: () => lookup
+});
+
+// src/encoding/utf8.ts
+var utf8_exports = {};
+__export(utf8_exports, {
+  decoder: () => decoder,
+  encodedLength: () => encodedLength,
+  encoder: () => encoder
+});
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function encodedLength(data) {
+  if (typeof Buffer !== "undefined") return Buffer.byteLength(data, "utf8");
+  let length = data.length;
+  for (let i = length - 1; i >= 0; i--) {
+    let code = data.charCodeAt(i);
+    if (code > 127 && code <= 2047) length++;
+    else if (code > 2047 && code <= 65535) length += 2;
+    if (code >= 56320 && code <= 57343) i--;
+  }
+  return length;
+}
+
+// src/encoding/base64.ts
+var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var lookup = /* @__PURE__ */ new Map();
+var encodeLookup = /* @__PURE__ */ new Map();
+for (let i = 0; i < alphabet.length; i++) {
+  const charCode = alphabet.charCodeAt(i);
+  lookup.set(charCode, i);
+  encodeLookup.set(i, charCode);
+}
+lookup.set("=".charCodeAt(0), 0);
+lookup.set("-".charCodeAt(0), 62);
+lookup.set("_".charCodeAt(0), 63);
+var HasToBase64 = typeof Uint8Array.prototype.toBase64 === "function";
+var HasFromBase64 = typeof Uint8Array.fromBase64 === "function";
+function decode(data, url = false) {
+  if (typeof Buffer !== "undefined") {
+    let buf = Buffer.from(data, url ? "base64url" : "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  if (HasFromBase64) return Uint8Array.fromBase64(data, { alphabet: url ? "base64url" : "base64" });
+  data = data.replace(/=+$/g, "");
+  let n = data.length;
+  let rem = n % 4;
+  let k = rem && rem - 1;
+  let m = (n >> 2) * 3 + k;
+  let encoded = u8_exports.allocate(n + 3);
+  encoder.encodeInto(`${data}===`, encoded);
+  for (let i = 0, j = 0; i < n; i += 4, j += 3) {
+    let x = (lookup.get(encoded[i]) << 18) + (lookup.get(encoded[i + 1]) << 12) + (lookup.get(encoded[i + 2]) << 6) + lookup.get(encoded[i + 3]);
+    encoded[j] = x >> 16;
+    encoded[j + 1] = x >> 8 & 255;
+    encoded[j + 2] = x & 255;
+  }
+  return new Uint8Array(encoded.buffer, encoded.byteOffset, m);
+}
+var ToBase64Options = { alphabet: "base64", omitPadding: false };
+var ToBase64UrlOptions = { alphabet: "base64url", omitPadding: true };
+function encode(bytes, url = false) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString(url ? "base64url" : "base64");
+  if (HasToBase64) return bytes.toBase64(url ? ToBase64UrlOptions : ToBase64Options);
+  let m = bytes.length;
+  let k = m % 3;
+  let n = Math.floor(m / 3) * 4 + (k && k + 1);
+  let N = Math.ceil(m / 3) * 4;
+  let encoded = u8_exports.allocate(N);
+  for (let i = 0, j = 0; j < m; i += 4, j += 3) {
+    let y = (bytes[j] << 16) + (bytes[j + 1] << 8) + (bytes[j + 2] | 0);
+    encoded[i] = encodeLookup.get(y >> 18);
+    encoded[i + 1] = encodeLookup.get(y >> 12 & 63);
+    encoded[i + 2] = encodeLookup.get(y >> 6 & 63);
+    encoded[i + 3] = encodeLookup.get(y & 63);
+  }
+  let base64 = decoder.decode(new Uint8Array(encoded.buffer, encoded.byteOffset, n));
+  if (url) base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
+  else {
+    if (k === 1) base64 += "==";
+    if (k === 2) base64 += "=";
+  }
+  return base64;
+}
+function encodedLength2(n) {
+  return Math.ceil(n / 3) * 4;
+}
+function decodedLength(n) {
+  let rem = n % 4;
+  return (n >> 2) * 3 + (rem && rem - 1);
+}
+
+// src/encoding/hex.ts
+var hex_exports = {};
+__export(hex_exports, {
+  decode: () => decode2,
+  decodedLength: () => decodedLength2,
+  encode: () => encode2,
+  encodedLength: () => encodedLength3
+});
+var hexSliceLookupTable = (function() {
+  const alphabet2 = "0123456789abcdef";
+  const table = Array.from({ length: 256 });
+  for (let i = 0; i < 16; ++i) {
+    const i16 = i * 16;
+    for (let j = 0; j < 16; ++j) {
+      table[i16 + j] = alphabet2[i] + alphabet2[j];
+    }
+  }
+  return table;
+})();
+var hexCharValueTable = {
+  0: 0,
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5,
+  6: 6,
+  7: 7,
+  8: 8,
+  9: 9,
+  a: 10,
+  b: 11,
+  c: 12,
+  d: 13,
+  e: 14,
+  f: 15,
+  A: 10,
+  B: 11,
+  C: 12,
+  D: 13,
+  E: 14,
+  F: 15
+};
+var HasToHex = typeof Uint8Array.prototype.toHex === "function";
+var HasFromHex = typeof Uint8Array.fromHex === "function";
+function encode2(buf) {
+  if (typeof Buffer !== "undefined") return Buffer.from(buf).toString("hex");
+  if (HasToHex) return buf.toHex();
+  let out = "";
+  for (let i = 0; i < buf.byteLength; ++i) out += hexSliceLookupTable[buf[i]];
+  return out;
+}
+function decode2(data) {
+  if (typeof Buffer !== "undefined") {
+    let buf2 = Buffer.from(data, "hex");
+    return new Uint8Array(buf2.buffer, buf2.byteOffset, buf2.byteLength);
+  }
+  if (HasFromHex) return Uint8Array.fromHex(data);
+  let buf = u8_exports.allocate(Math.ceil(data.length / 2));
+  let dataLength = data.length;
+  let length = Math.min(buf.length, dataLength / 2);
+  let i;
+  for (i = 0; i < length; ++i) {
+    let a = hexCharValueTable[data[i * 2]];
+    let b = hexCharValueTable[data[i * 2 + 1]];
+    if (a === void 0 || b === void 0) throw new TypeError("Invalid hex string.", { cause: { data } });
+    buf[i] = a << 4 | b;
+  }
+  return buf;
+}
+function encodedLength3(n) {
+  return n * 2;
+}
+function decodedLength2(n) {
+  return Math.ceil(n / 2);
+}
+
+// src/iterate/enumerate.ts
+function enumerate(iterable) {
+  const iterator = iterable[Symbol.iterator]();
+  let idx = 0;
+  return {
+    [Symbol.iterator]() {
+      return this;
+    },
+    next() {
+      let res = iterator.next();
+      if (res.done) return res;
+      return { done: false, value: [idx++, res.value] };
+    }
+  };
+}
+
+// src/misc/assert.ts
+function assert(condition, message) {
+  if (!condition) throw new Error(typeof message === "string" ? message : "Assertion failed.", { cause: message });
+}
+function assertHashKey(obj, key) {
+  if (!(key in obj)) throw new Error(`Key ${JSON.stringify(key)} not found in object.`, { cause: { obj, key } });
+}
+function unsafeCastType(value) {
+}
+function assertNotNull(value) {
+  if (value === null || void 0) throw new Error(`Value is ${value}.`);
+}
+function asNonNull(value) {
+  assertNotNull(value);
+  return value;
+}
+function assertMatches(str, regex) {
+  let match = str.match(regex);
+  if (!match) throw new Error(`${JSON.stringify(str)} does not match ${regex}.`, { cause: { str, regex } });
+  return match;
+}
+
+// src/misc/composer.ts
+function composeMiddlewares(middlewares, final) {
+  middlewares = middlewares.slice();
+  if (final == null)
+    return function(context, next) {
+      function dispatch2(i, ctx) {
+        let fn = middlewares[i] ?? next;
+        return fn(ctx, dispatch2.bind(null, i + 1));
+      }
+      return dispatch2(0, context);
+    };
+  middlewares.push(final);
+  function dispatch(i, ctx) {
+    let fn = middlewares[i];
+    return fn(ctx, boundDispatches[i + 1]);
+  }
+  let boundDispatches = [];
+  for (let i = 0; i < middlewares.length; i++) {
+    boundDispatches.push(dispatch.bind(null, i));
+  }
+  return function(context) {
+    return boundDispatches[0](context);
+  };
+}
+
+// src/misc/guards.ts
+var isNotUndefined = (val) => val !== void 0;
+var isNotNull = (val) => val !== null;
+var isBoolean = (val) => typeof val === "boolean";
+var isTruthy = (val) => Boolean(val);
+var isFalsy = (val) => !val;
+var isFunction = (val) => typeof val === "function";
+var isNumber = (val) => typeof val === "number";
+var isString = (val) => typeof val === "string";
+var isSymbol = (val) => typeof val === "symbol";
+var isBigInt = (val) => typeof val === "bigint";
+var isObject = (val) => typeof val === "object" && val !== null;
+
+// src/misc/noop.ts
+function noop() {
+}
+
+// src/misc/objects.ts
+function objectKeys(obj) {
+  return Object.keys(obj);
+}
+function objectEntries(obj) {
+  return Object.entries(obj);
+}
+function clearUndefinedInPlace(obj) {
+  for (const key in obj) {
+    if (!Object.hasOwn(obj, key)) continue;
+    if (obj[key] === void 0) {
+      delete obj[key];
+    }
+  }
+}
+function deepMerge(into, from, options = {}) {
+  if (!Array.isArray(from)) from = [from];
+  if (from.length === 0) return into;
+  const {
+    undefined: undefinedStrategy = "ignore",
+    properties: propertiesStrategy = "replace",
+    arrays: arraysStrategy = "replace",
+    objects: objectsStrategy = "merge"
+  } = options;
+  for (let i = 0; i < from.length; i++) {
+    const source = from[i];
+    for (const key in source) {
+      if (!Object.hasOwn(source, key)) continue;
+      const value = source[key];
+      const existing = into[key];
+      if (value === void 0) {
+        if (undefinedStrategy === "replace") {
+          ;
+          into[key] = void 0;
+        }
+        continue;
+      }
+      if (Array.isArray(value)) {
+        if (arraysStrategy === "merge" && Array.isArray(existing)) {
+          existing.push(...value);
+        } else if (arraysStrategy === "ignore" && existing !== void 0) {
+        } else {
+          ;
+          into[key] = [...value];
+        }
+        continue;
+      }
+      if (typeof value === "object" && value !== null) {
+        if (objectsStrategy === "merge" && typeof existing === "object" && existing !== null) {
+          ;
+          into[key] = deepMerge(existing, value, options);
+        } else if (objectsStrategy === "ignore" && existing !== void 0) {
+        } else {
+          ;
+          into[key] = { ...value };
+        }
+        continue;
+      }
+      if (propertiesStrategy === "ignore" && existing !== void 0) {
+      } else {
+        ;
+        into[key] = value;
+      }
+    }
+  }
+  return into;
+}
+
+// src/misc/string.ts
+function splitOnce(str, separator) {
+  let idx = str.indexOf(separator);
+  if (idx === -1) throw new RangeError(`Separator not found: ${separator}.`, { cause: { str, separator } });
+  return [str.slice(0, idx), str.slice(idx + separator.length)];
+}
+function assertStartsWith(str, prefix) {
+  if (!str.startsWith(prefix))
+    throw new TypeError(`String does not starts with ${prefix}.`, { cause: { str, prefix } });
+}
+function assertsEndsWith(str, suffix) {
+  if (!str.endsWith(suffix)) throw new TypeError(`String does not ends with ${suffix}.`, { cause: { str, suffix } });
+}
+
+// src/not-sync/timers.ts
+var timers_exports = {};
+__export(timers_exports, {
+  clearInterval: () => clearIntervalWrap,
+  clearTimeout: () => clearTimeoutWrap,
+  setInterval: () => setIntervalWrap,
+  setTimeout: () => setTimeoutWrap
+});
+var setTimeoutWrap = ((...args) => setTimeout(...args));
+var setIntervalWrap = ((...args) => setInterval(...args));
+var clearTimeoutWrap = ((...args) => clearTimeout(...args));
+var clearIntervalWrap = ((...args) => clearInterval(...args));
+
+// src/not-sync/async-interval.ts
+var AsyncInterval = class {
+  #handler;
+  #interval;
+  #timer;
+  #onError = noop;
+  #stopped = true;
+  #abortController = new AbortController();
+  constructor(handler, interval) {
+    this.#handler = handler;
+    this.#interval = interval;
+  }
+  start(after = this.#interval) {
+    this.stop();
+    this.#stopped = false;
+    this.#timer = setTimeoutWrap(this.#onTimeout, after);
+  }
+  startNow() {
+    this.stop();
+    this.#stopped = false;
+    this.#onTimeout();
+  }
+  stop() {
+    this.#abortController.abort();
+    this.#abortController = new AbortController();
+    if (this.#timer != null) {
+      clearTimeoutWrap(this.#timer);
+      this.#timer = void 0;
+    }
+    this.#stopped = true;
+  }
+  onError(handler) {
+    this.#onError = handler;
+  }
+  #onTimeout = () => {
+    this.#timer = void 0;
+    void (async () => {
+      try {
+        await this.#handler(this.#abortController.signal);
+      } catch (err) {
+        this.#onError(err);
+      }
+      if (this.#stopped) return;
+      this.#timer = setTimeoutWrap(this.#onTimeout, this.#interval);
+    })();
+  };
+};
+
+// src/structures/_iterator.ts
+var _hasIteratorFrom = null;
+function maybeWrapIterator(iter) {
+  if (_hasIteratorFrom === null) {
+    _hasIteratorFrom = typeof globalThis.Iterator !== "undefined" && "from" in globalThis.Iterator;
+  }
+  if (_hasIteratorFrom) {
+    return globalThis.Iterator.from(iter);
+  }
+  return iter;
+}
+
+// src/structures/custom-map.ts
+var CustomMap = class {
+  clear;
+  #map;
+  #mapperTo;
+  #mapperFrom;
+  constructor(externalToInternal, internalToExternal) {
+    this.#mapperTo = externalToInternal;
+    this.#mapperFrom = internalToExternal;
+    let map = this.#map = /* @__PURE__ */ new Map();
+    this.clear = map.clear.bind(this.#map);
+  }
+  get size() {
+    return this.#map.size;
+  }
+  get [Symbol.toStringTag]() {
+    return this.#map[Symbol.toStringTag];
+  }
+  getInternalMap() {
+    return this.#map;
+  }
+  delete(key) {
+    return this.#map.delete(this.#mapperTo(key));
+  }
+  forEach(cb, thisArg) {
+    return this.#map.forEach((value, key) => {
+      cb.call(thisArg, value, this.#mapperFrom(key), this);
+    });
+  }
+  get(key) {
+    return this.#map.get(this.#mapperTo(key));
+  }
+  has(key) {
+    return this.#map.has(this.#mapperTo(key));
+  }
+  set(key, value) {
+    this.#map.set(this.#mapperTo(key), value);
+    return this;
+  }
+  getOrInsert(key, value) {
+    if (!this.#map.getOrInsert) {
+      return value;
+    }
+    return this.#map.getOrInsert(this.#mapperTo(key), value);
+  }
+  getOrInsertComputed(key, callback) {
+    return this.#map.getOrInsertComputed(this.#mapperTo(key), (key2) => callback(this.#mapperFrom(key2)));
+  }
+  entries() {
+    let inner = this.#map.entries();
+    const iterator = {
+      [Symbol.iterator]: () => iterator,
+      next: () => {
+        let { done, value } = inner.next();
+        if (done) return { done, value };
+        return {
+          done,
+          value: [this.#mapperFrom(value[0]), value[1]]
+        };
+      }
+    };
+    return maybeWrapIterator(iterator);
+  }
+  keys() {
+    let inner = this.#map.keys();
+    const iterator = {
+      [Symbol.iterator]: () => iterator,
+      next: () => {
+        let { done, value } = inner.next();
+        if (done) return { done, value };
+        return { done, value: this.#mapperFrom(value) };
+      }
+    };
+    return maybeWrapIterator(iterator);
+  }
+  values() {
+    let inner = this.#map.values();
+    const iterator = {
+      [Symbol.iterator]: () => iterator,
+      next: () => {
+        let { done, value } = inner.next();
+        if (done) return { done, value };
+        return { done, value };
+      }
+    };
+    return maybeWrapIterator(iterator);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+
+// src/structures/custom-set.ts
+var CustomSet = class _CustomSet {
+  clear;
+  #set;
+  #mapperTo;
+  #mapperFrom;
+  constructor(externalToInternal, internalToExternal) {
+    this.#mapperTo = externalToInternal;
+    this.#mapperFrom = internalToExternal;
+    let set = this.#set = /* @__PURE__ */ new Set();
+    this.clear = set.clear.bind(set);
+  }
+  get size() {
+    return this.#set.size;
+  }
+  get [Symbol.toStringTag]() {
+    return this.#set[Symbol.toStringTag];
+  }
+  add(value) {
+    this.#set.add(this.#mapperTo(value));
+    return this;
+  }
+  delete(value) {
+    return this.#set.delete(this.#mapperTo(value));
+  }
+  forEach(cb, thisArg) {
+    this.#set.forEach((value) => {
+      let mapped = this.#mapperFrom(value);
+      cb.call(thisArg, mapped, mapped, this);
+    });
+  }
+  has(value) {
+    return this.#set.has(this.#mapperTo(value));
+  }
+  entries() {
+    let inner = this.#set.entries();
+    const iterator = {
+      [Symbol.iterator]: () => iterator,
+      next: () => {
+        let { done, value } = inner.next();
+        if (done) return { done, value };
+        let mapped = this.#mapperFrom(value[0]);
+        return {
+          done,
+          value: [mapped, mapped]
+        };
+      }
+    };
+    return maybeWrapIterator(iterator);
+  }
+  keys() {
+    let inner = this.#set.keys();
+    const iterator = {
+      [Symbol.iterator]: () => iterator,
+      next: () => {
+        let { done, value } = inner.next();
+        if (done) return { done, value };
+        return { done, value: this.#mapperFrom(value) };
+      }
+    };
+    return maybeWrapIterator(iterator);
+  }
+  values() {
+    return this.keys();
+  }
+  union(other) {
+    let newSet = new _CustomSet(
+      (k) => this.#mapperTo(k),
+      (k) => this.#mapperFrom(k)
+    );
+    this.#set.forEach((v) => newSet.add(this.#mapperFrom(v)));
+    other.forEach((v) => newSet.add(v));
+    return newSet;
+  }
+  intersection(other) {
+    let newSet = new _CustomSet(
+      (k) => this.#mapperTo(k),
+      (k) => this.#mapperFrom(k)
+    );
+    this.#set.forEach((v) => {
+      let ext = this.#mapperFrom(v);
+      if (other.has(ext)) newSet.add(ext);
+    });
+    return newSet;
+  }
+  difference(other) {
+    let newSet = new _CustomSet(this.#mapperTo, this.#mapperFrom);
+    this.#set.forEach((v) => {
+      let ext = this.#mapperFrom(v);
+      if (!other.has(ext)) newSet.add(ext);
+    });
+    return newSet;
+  }
+  symmetricDifference(other) {
+    let newSet = new _CustomSet(
+      (k) => this.#mapperTo(k),
+      (k) => this.#mapperFrom(k)
+    );
+    this.#set.forEach((v) => {
+      let ext = this.#mapperFrom(v);
+      if (!other.has(ext)) newSet.add(ext);
+    });
+    other.forEach((v) => {
+      if (!this.has(v)) newSet.add(v);
+    });
+    return newSet;
+  }
+  isSubsetOf(other) {
+    for (let v of this.#set) {
+      if (!other.has(this.#mapperFrom(v))) return false;
+    }
+    return true;
+  }
+  isSupersetOf(other) {
+    for (let v of other) {
+      if (!this.has(v)) return false;
+    }
+    return true;
+  }
+  isDisjointFrom(other) {
+    for (let v of other) {
+      if (this.has(v)) return false;
+    }
+    return true;
+  }
+  [Symbol.iterator]() {
+    return this.keys();
+  }
+  getInternalSet() {
+    return this.#set;
+  }
+};
+
+// src/structures/deque.ts
+var Log2 = Math.log(2);
+function _nextPowerOf2(n) {
+  if (n <= 4) return 4;
+  return 1 << Math.ceil(Math.log(n) / Log2);
+}
+var Deque = class {
+  _list;
+  _head = 0;
+  _tail = 0;
+  _capacityMask = 3;
+  _capacity;
+  constructor(array, options = {}) {
+    this._capacity = options.capacity;
+    if (array) {
+      this.#fromArray(array);
+    } else {
+      this._list = new Array(4);
+    }
+  }
+  get length() {
+    return this._tail - this._head & this._capacityMask;
+  }
+  isEmpty() {
+    return this._head === this._tail;
+  }
+  at(index) {
+    let i = index;
+    if (i !== (i | 0)) return void 0;
+    const len = this.length;
+    if (i >= len || i < -len) return void 0;
+    if (i < 0) i += len;
+    return this._list[this._head + i & this._capacityMask];
+  }
+  peekFront() {
+    return this.isEmpty() ? void 0 : this._list[this._head];
+  }
+  peekBack() {
+    return this.isEmpty() ? void 0 : this._list[this._tail - 1 + this._list.length & this._capacityMask];
+  }
+  pushFront(item) {
+    this._head = this._head - 1 + this._list.length & this._capacityMask;
+    this._list[this._head] = item;
+    if (this._head === this._tail) this.#growArray();
+    if (this._capacity !== void 0 && this.length > this._capacity) this.popBack();
+    return this.length;
+  }
+  pushBack(item) {
+    this._list[this._tail] = item;
+    this._tail = this._tail + 1 & this._capacityMask;
+    if (this._head === this._tail) this.#growArray();
+    if (this._capacity !== void 0 && this.length > this._capacity) this.popFront();
+    return this.length;
+  }
+  popFront() {
+    if (this.isEmpty()) return void 0;
+    const item = this._list[this._head];
+    this._list[this._head] = void 0;
+    this._head = this._head + 1 & this._capacityMask;
+    if (this._head < 2 && this._tail > 1e4 && this._tail <= this._list.length >>> 2) this.#shrinkArray();
+    return item;
+  }
+  popBack() {
+    if (this.isEmpty()) return void 0;
+    const idx = this._tail - 1 + this._list.length & this._capacityMask;
+    const item = this._list[idx];
+    this._list[idx] = void 0;
+    this._tail = idx;
+    if (this._head < 2 && this._tail > 1e4 && this._tail <= this._list.length >>> 2) this.#shrinkArray();
+    return item;
+  }
+  removeOne(idx) {
+    const len = this.length;
+    if (idx >= len || idx < -len) return void 0;
+    if (idx < 0) idx += len;
+    const realIdx = this._head + idx & this._capacityMask;
+    const item = this._list[realIdx];
+    this.#remove(realIdx);
+    return item;
+  }
+  removeBy(predicate) {
+    let i = this._head;
+    while (i !== this._tail) {
+      const item = this._list[i];
+      if (item !== void 0 && predicate(item)) {
+        this.#remove(i);
+        return;
+      }
+      i = i + 1 & this._capacityMask;
+    }
+  }
+  clear() {
+    this._list = new Array(this._list.length);
+    this._head = 0;
+    this._tail = 0;
+  }
+  indexOf(item) {
+    let i = this._head;
+    let pos = 0;
+    while (i !== this._tail) {
+      if (this._list[i] === item) return pos;
+      i = i + 1 & this._capacityMask;
+      pos++;
+    }
+    return -1;
+  }
+  findIndex(predicate) {
+    let i = this._head;
+    let pos = 0;
+    while (i !== this._tail) {
+      if (predicate(this._list[i])) return pos;
+      i = i + 1 & this._capacityMask;
+      pos++;
+    }
+    return -1;
+  }
+  find(predicate) {
+    let i = this._head;
+    while (i !== this._tail) {
+      const item = this._list[i];
+      if (item !== void 0 && predicate(item)) return item;
+      i = i + 1 & this._capacityMask;
+    }
+    return void 0;
+  }
+  includes(item) {
+    return this.indexOf(item) !== -1;
+  }
+  toArray() {
+    const arr = new Array(this.length);
+    let i = this._head;
+    let k = 0;
+    while (i !== this._tail) {
+      arr[k++] = this._list[i];
+      i = i + 1 & this._capacityMask;
+    }
+    return arr;
+  }
+  [Symbol.iterator]() {
+    let i = this._head;
+    return {
+      next: () => {
+        if (i === this._tail) return { done: true, value: void 0 };
+        const value = this._list[i];
+        i = i + 1 & this._capacityMask;
+        return { done: false, value };
+      }
+    };
+  }
+  #fromArray(array) {
+    const capacity = _nextPowerOf2(array.length);
+    this._list = new Array(capacity);
+    this._capacityMask = capacity - 1;
+    this._tail = array.length;
+    for (let i = 0; i < array.length; i++) this._list[i] = array[i];
+  }
+  #growArray() {
+    const newCapacity = this._list.length << 1;
+    const newList = new Array(newCapacity);
+    let k = 0;
+    let i = this._head;
+    while (i !== this._tail) {
+      newList[k++] = this._list[i];
+      i = i + 1 & this._capacityMask;
+    }
+    this._list = newList;
+    this._head = 0;
+    this._tail = k;
+    this._capacityMask = newCapacity - 1;
+  }
+  #shrinkArray() {
+    if (this._list.length <= 4) return;
+    const newCapacity = this._list.length >>> 1;
+    const newList = new Array(newCapacity);
+    let k = 0;
+    let i = this._head;
+    while (i !== this._tail) {
+      newList[k++] = this._list[i];
+      i = i + 1 & this._capacityMask;
+    }
+    this._list = newList;
+    this._head = 0;
+    this._tail = k;
+    this._capacityMask = newCapacity - 1;
+  }
+  #remove(idx) {
+    const mask = this._capacityMask;
+    const len = this._list.length;
+    if (idx - this._head < this.length - (idx - this._head)) {
+      let i = idx;
+      while (i > this._head) {
+        this._list[i] = this._list[i - 1 + len & mask];
+        i = i - 1 + len & mask;
+      }
+      this._list[this._head] = void 0;
+      this._head = this._head + 1 & mask;
+    } else {
+      let i = idx;
+      while (i !== this._tail) {
+        this._list[i] = this._list[i + 1 & mask];
+        i = i + 1 & mask;
+      }
+      this._list[this._tail - 1 + len & mask] = void 0;
+      this._tail = this._tail - 1 + len & mask;
+    }
+  }
+};
+
+// src/structures/lru-map.ts
+var LruMap = class {
+  #capacity;
+  #head;
+  #tail;
+  #map;
+  #size = 0;
+  constructor(capacity, MapImpl = Map) {
+    this.#capacity = capacity;
+    this.#map = new MapImpl();
+  }
+  get size() {
+    return this.#size;
+  }
+  get(key) {
+    let item = this.#map.get(key);
+    if (!item) return void 0;
+    this.#markUsed(item);
+    return item.value;
+  }
+  has(key) {
+    return this.#map.has(key);
+  }
+  set(key, value) {
+    let item = this.#map.get(key);
+    if (item) {
+      item.value = value;
+      this.#markUsed(item);
+      return;
+    }
+    item = {
+      key,
+      value,
+      next: void 0,
+      prev: void 0
+    };
+    this.#map.set(key, item);
+    if (this.#head) {
+      this.#head.prev = item;
+      item.next = this.#head;
+    } else {
+      this.#tail = item;
+    }
+    this.#head = item;
+    this.#size += 1;
+    if (this.#size > this.#capacity) {
+      let oldest = this.#tail;
+      if (oldest) this.#remove(oldest);
+    }
+  }
+  delete(key) {
+    let item = this.#map.get(key);
+    if (item) this.#remove(item);
+  }
+  clear() {
+    this.#map.clear();
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  #markUsed(item) {
+    if (item === this.#head) return;
+    if (item.prev) {
+      if (item === this.#tail) this.#tail = item.prev;
+      item.prev.next = item.next;
+    }
+    if (item.next) item.next.prev = item.prev;
+    item.prev = void 0;
+    item.next = this.#head;
+    if (this.#head) this.#head.prev = item;
+    this.#head = item;
+  }
+  #remove(item) {
+    if (item.prev) {
+      this.#tail = item.prev;
+      this.#tail.next = void 0;
+    } else {
+      this.#tail = void 0;
+      this.#head = void 0;
+    }
+    item.prev = item.next = void 0;
+    this.#map.delete(item.key);
+    this.#size -= 1;
+  }
+};
+
+// src/structures/lru-set.ts
+var LruSet = class {
+  #capacity;
+  #head;
+  #tail;
+  #set;
+  constructor(capacity, SetImpl = Set) {
+    this.#capacity = capacity;
+    this.#set = new SetImpl();
+  }
+  get size() {
+    return this.#set.size;
+  }
+  add(value) {
+    if (this.#set.has(value)) return;
+    if (!this.#head) this.#head = { value };
+    if (!this.#tail) this.#tail = this.#head;
+    else {
+      this.#tail.next = { value };
+      this.#tail = this.#tail.next;
+    }
+    this.#set.add(value);
+    if (this.#set.size > this.#capacity && this.#head !== void 0) {
+      this.#set.delete(this.#head.value);
+      this.#head = this.#head.next;
+    }
+  }
+  has(value) {
+    return this.#set.has(value);
+  }
+  clear() {
+    this.#head = this.#tail = void 0;
+    this.#set.clear();
+  }
+};
+
+// src/not-sync/async-lock.ts
+var AsyncLock = class {
+  _queue = new Deque();
+  async acquire() {
+    let info;
+    while (info = this._queue.peekFront()) {
+      await info[0];
+    }
+    let unlock;
+    const promise = new Promise((resolve) => {
+      unlock = resolve;
+    });
+    this._queue.pushBack([promise, unlock]);
+  }
+  release() {
+    const front = this._queue.popFront();
+    if (!front) {
+      throw new Error("Nothing to release.", { cause: this._queue });
+    }
+    front[1]();
+  }
+  with(func) {
+    return (async () => {
+      await this.acquire();
+      try {
+        return await func();
+      } finally {
+        this.release();
+      }
+    })();
+  }
+};
+
+// src/not-sync/deferred.ts
+var Deferred = class {
+  resolve;
+  reject;
+  promise;
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      ;
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+};
+var DeferredTracked = class {
+  promise;
+  status;
+  #resolve;
+  #reject;
+  constructor() {
+    this.status = { type: "pending" };
+    this.promise = new Promise((resolve, reject) => {
+      this.#resolve = resolve;
+      this.#reject = reject;
+    });
+  }
+  get result() {
+    if (this.status.type === "fulfilled") return this.status.value;
+    return void 0;
+  }
+  get error() {
+    if (this.status.type === "rejected") return this.status.reason;
+    return void 0;
+  }
+  resolve(value) {
+    if (this.status.type !== "pending") return;
+    this.status = { type: "fulfilled", value };
+    this.#resolve(value);
+  }
+  reject(reason) {
+    if (this.status.type !== "pending") return;
+    this.status = { type: "rejected", reason };
+    this.#reject(reason);
+  }
+};
+
+// src/not-sync/async-queue.ts
+var AsyncQueue = class {
+  queue;
+  maxSize;
+  #consumerWaiters = new Deque();
+  #producerWaiters = new Deque();
+  #ended = false;
+  constructor(from, maxSize) {
+    if (maxSize !== void 0 && maxSize < 1) {
+      throw new Error("maxSize must be at least 1");
+    }
+    this.maxSize = maxSize;
+    if (from) {
+      if (from instanceof Deque) {
+        this.queue = from;
+      } else {
+        this.queue = new Deque(from);
+      }
+    } else {
+      this.queue = new Deque();
+    }
+  }
+  get length() {
+    return this.queue.length;
+  }
+  get isFull() {
+    return this.maxSize !== void 0 && this.queue.length >= this.maxSize;
+  }
+  get remainingCapacity() {
+    return this.maxSize !== void 0 ? this.maxSize - this.queue.length : Infinity;
+  }
+  get ended() {
+    return this.#ended;
+  }
+  async enqueue(item) {
+    if (this.#ended) {
+      throw new Error("Cannot enqueue after .end() has been called");
+    }
+    if (this.#consumerWaiters.length > 0) {
+      let waiter = this.#consumerWaiters.popFront();
+      waiter.resolve(item);
+      return;
+    }
+    if (this.isFull) {
+      let waiter = new Deferred();
+      this.#producerWaiters.pushBack(waiter);
+      await waiter.promise;
+      if (this.#ended) {
+        throw new Error("Queue was ended while waiting to enqueue.");
+      }
+    }
+    this.queue.pushBack(item);
+  }
+  tryEnqueue(item) {
+    if (this.#ended || this.isFull || this.#consumerWaiters.length > 0) {
+      return false;
+    }
+    this.queue.pushBack(item);
+    return true;
+  }
+  end() {
+    if (this.#ended) throw new Error(".end() has already been called.");
+    this.#ended = true;
+    for (let waiter of this.#consumerWaiters) {
+      waiter.resolve(void 0);
+    }
+    this.#consumerWaiters.clear();
+    let err = new Error("Queue has been ended.");
+    for (let waiter of this.#producerWaiters) {
+      waiter.reject(err);
+    }
+    this.#producerWaiters.clear();
+  }
+  peek() {
+    return this.queue.peekFront();
+  }
+  next() {
+    let item = this.queue.popFront();
+    this.#wakeProducerIfNeeded();
+    return item;
+  }
+  async nextOrWait() {
+    if (this.queue.length > 0 || this.#ended) {
+      let item = this.queue.popFront();
+      this.#wakeProducerIfNeeded();
+      return item;
+    }
+    let waiter = new Deferred();
+    this.#consumerWaiters.pushBack(waiter);
+    return waiter.promise;
+  }
+  [Symbol.asyncIterator]() {
+    let iterator = {
+      [Symbol.asyncIterator]: () => iterator,
+      next: async () => {
+        let item = await this.nextOrWait();
+        if (item === void 0) return { done: true, value: void 0 };
+        return { value: item, done: false };
+      }
+    };
+    return iterator;
+  }
+  #wakeProducerIfNeeded() {
+    if (this.#producerWaiters.length > 0 && !this.isFull) {
+      let producer = this.#producerWaiters.popFront();
+      producer.resolve();
+    }
+  }
+};
+
+// src/not-sync/emitter.ts
+var Emitter = class {
+  #listeners = [];
+  #emit = noop;
+  get length() {
+    return this.#listeners.length;
+  }
+  add(listener) {
+    this.#listeners.push(listener);
+    this.#updateEmit();
+  }
+  forwardTo(emitter) {
+    this.add(emitter.emit.bind(emitter));
+  }
+  remove(listener) {
+    let idx = this.#listeners.indexOf(listener);
+    if (idx === -1) return;
+    this.#listeners.splice(idx, 1);
+    this.#updateEmit();
+  }
+  emit(value) {
+    this.#emit(value);
+  }
+  once(listener) {
+    const once = (value) => {
+      this.remove(once);
+      listener(value);
+    };
+    this.add(once);
+  }
+  listeners() {
+    return this.#listeners;
+  }
+  clear() {
+    this.#listeners.length = 0;
+    this.#emit = noop;
+  }
+  #emitFew = (value) => {
+    let len = this.#listeners.length;
+    this.#listeners[0](value);
+    len > 1 && this.#listeners[1](value);
+    len > 2 && this.#listeners[2](value);
+    len > 3 && this.#listeners[3](value);
+    len > 4 && this.#listeners[4](value);
+  };
+  #emitAll = (value) => {
+    let len = this.#listeners.length;
+    for (let i = 0; i < len; i++) {
+      this.#listeners[i](value);
+    }
+  };
+  #updateEmit = () => {
+    let len = this.#listeners.length;
+    if (len === 0) {
+      this.#emit = noop;
+    } else if (len === 1) {
+      this.#emit = this.#listeners[0];
+    } else if (len <= 5) {
+      this.#emit = this.#emitFew;
+    } else {
+      this.#emit = this.#emitAll;
+    }
+  };
+};
+
+// src/not-sync/async-resource.ts
+var AsyncResource = class {
+  constructor(options) {
+    this.options = options;
+    this.#ctx = {
+      current: null,
+      currentFetchedAt: 0,
+      currentExpiresAt: 0,
+      isBackground: false,
+      abort: null
+    };
+  }
+  options;
+  onUpdated = new Emitter();
+  #abort;
+  #ctx;
+  #updating;
+  #timeout;
+  #destroyed = false;
+  get isStale() {
+    return this.#ctx.current === null || this.#ctx.currentExpiresAt <= performance.now();
+  }
+  setData(data, expiresIn) {
+    if (this.#destroyed) return;
+    let now = performance.now();
+    this.#ctx.current = data;
+    this.#ctx.currentExpiresAt = now + expiresIn;
+    this.#ctx.currentFetchedAt = now;
+    this.onUpdated.emit(this.#ctx);
+    if (this.options.autoReload) {
+      this.#clearTimer();
+      let delay = expiresIn + (this.options.authReloadAfter ?? 0);
+      this.#timeout = setTimeoutWrap(() => {
+        if (this.#destroyed) return;
+        this.#ctx.isBackground = true;
+        this.update(true).catch(noop);
+      }, delay);
+    }
+  }
+  async update(force = false) {
+    if (this.#destroyed) return;
+    if (this.#updating) {
+      await this.#updating.promise;
+      return;
+    }
+    if (!force && !this.isStale) return;
+    this.#abort?.abort();
+    this.#abort = new AbortController();
+    this.#ctx.abort = this.#abort.signal;
+    this.#updating = new Deferred();
+    let result;
+    try {
+      result = await this.options.fetcher(this.#ctx);
+    } catch (err) {
+      if (err.name === "AbortError") {
+        this.#updating.resolve();
+        this.#updating = void 0;
+        this.#ctx.abort = null;
+        return;
+      }
+      if (this.options.onError) this.options.onError(err, this.#ctx);
+      else console.error(err);
+      this.#updating.resolve();
+      this.#updating = void 0;
+      this.#ctx.abort = null;
+      return;
+    }
+    this.#updating.resolve();
+    this.#updating = void 0;
+    this.#ctx.abort = null;
+    if (!this.#destroyed) {
+      this.setData(result.data, result.expiresIn);
+    }
+  }
+  async get() {
+    if (this.#destroyed) return null;
+    if (this.options.swr === true && this.#ctx.current !== null) {
+      let validator = this.options.swrValidator;
+      if (!validator || validator(this.#ctx)) {
+        this.#ctx.isBackground = true;
+        this.update(true).catch(noop);
+        return this.#ctx.current;
+      }
+    }
+    this.#ctx.isBackground = false;
+    await this.update();
+    return this.#ctx.current;
+  }
+  getCached() {
+    return this.#ctx.current;
+  }
+  destroy() {
+    if (this.#destroyed) return;
+    this.#destroyed = true;
+    this.#clearTimer();
+    this.#abort?.abort();
+    this.onUpdated.clear();
+    if (this.#updating) {
+      this.#updating.resolve();
+      this.#updating = void 0;
+    }
+  }
+  #clearTimer() {
+    if (this.#timeout) {
+      clearTimeoutWrap(this.#timeout);
+      this.#timeout = void 0;
+    }
+  }
+};
+
+// src/not-sync/condition-variable.ts
+var ConditionVariable = class {
+  #resolvers = [];
+  wait() {
+    return new Promise((resolve) => {
+      this.#resolvers.push(resolve);
+    });
+  }
+  notify() {
+    let resolvers = this.#resolvers;
+    this.#resolvers = [];
+    for (let resolve of resolvers) {
+      resolve();
+    }
+  }
+};
+
+// src/not-sync/pool.ts
+var ErrorInfo = class {
+  constructor(item, index, error) {
+    this.item = item;
+    this.index = index;
+    this.error = error;
+  }
+  item;
+  index;
+  error;
+};
+var AggregateError = class extends Error {
+  constructor(errors) {
+    super(`AggregateError: ${errors.length} errors`);
+    this.errors = errors;
+  }
+  errors;
+};
+async function asyncPool(iterable, executor, options = {}) {
+  let { limit = 16, signal, onErrorStrategy } = options;
+  if (limit <= 0) throw new RangeError(`Pool limit must be a positive integer.`);
+  if (signal?.aborted) throw signal.reason;
+  let iterator = iterable[Symbol.asyncIterator]?.() ?? iterable[Symbol.iterator]?.();
+  if (!iterator) throw new TypeError(`iterable must be iterable`);
+  let idx = 0;
+  let errors = [];
+  let abortController = new AbortController();
+  let abortSignal = signal ? AbortSignal.any([signal, abortController.signal]) : abortController.signal;
+  async function worker() {
+    while (true) {
+      if (abortSignal.aborted) return;
+      let result;
+      try {
+        result = await iterator.next();
+      } catch (e) {
+        abortController.abort(e);
+        return;
+      }
+      if (result.done) return;
+      if (abortSignal.aborted) return;
+      let item = result.value;
+      let thisIdx = idx++;
+      try {
+        await executor(item, thisIdx);
+      } catch (err) {
+        let action = onErrorStrategy?.(item, thisIdx, err) ?? "throw";
+        if (action instanceof Promise) {
+          action = await action;
+        }
+        if (action === "ignore") continue;
+        if (action === "collect") {
+          errors.push(new ErrorInfo(item, thisIdx, err));
+          continue;
+        }
+        abortController.abort(err);
+        return;
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: limit }, worker));
+  if (abortSignal.aborted) throw abortSignal.reason;
+  if (errors.length > 0) throw new AggregateError(errors);
+}
+async function parallelMap(iterable, executor, options = {}) {
+  let result = [];
+  if (Array.isArray(iterable)) {
+    result.length = iterable.length;
+  }
+  await asyncPool(
+    iterable,
+    async (item, index) => {
+      result[index] = await executor(item, index);
+    },
+    options
+  );
+  return result;
+}
+
+// src/not-sync/sleep.ts
+function sleep(ms, signal) {
+  if (ms < 0) throw new RangeError("sleep: ms must be a non-negative number");
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+      return;
+    }
+    let timeoutId = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timeoutId);
+        reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/types/error.ts
+function unknownToError(err) {
+  if (err instanceof Error) {
+    return err;
+  }
+  if (typeof err === "string") {
+    return new Error(err);
+  }
+  let error = "";
+  try {
+    error = JSON.stringify(err);
+  } catch (_) {
+  }
+  return new Error(error, { cause: err });
+}
+var NotImplementedError = class extends Error {
+  constructor(message, options = {}) {
+    super(`Not implemented${message != null ? `: ${message}` : ""}`, options);
+  }
+};
+function throwNotImplemented(message, options) {
+  throw new NotImplementedError(message, options);
+}
+function throwUnreachable() {
+  throw new Error("Unreachable");
+}
+export {
+  AggregateError,
+  AsyncInterval,
+  AsyncLock,
+  AsyncQueue,
+  AsyncResource,
+  ConditionVariable,
+  CustomMap,
+  CustomSet,
+  Deferred,
+  DeferredTracked,
+  Deque,
+  Emitter,
+  LruMap,
+  LruSet,
+  NotImplementedError,
+  abs,
+  asNonNull,
+  assert,
+  assertHashKey,
+  assertMatches,
+  assertNotNull,
+  assertStartsWith,
+  assertsEndsWith,
+  asyncPool,
+  base64_exports as base64,
+  bitLength,
+  clearUndefinedInPlace,
+  composeMiddlewares,
+  deepMerge,
+  enumerate,
+  euclideanGcd,
+  fromBytes,
+  hex_exports as hex,
+  isBigInt,
+  isBoolean,
+  isFalsy,
+  isFunction,
+  isNotNull,
+  isNotUndefined,
+  isNumber,
+  isObject,
+  isString,
+  isSymbol,
+  isTruthy,
+  max,
+  max2,
+  min,
+  min2,
+  modInv,
+  modPowBinary,
+  noop,
+  objectEntries,
+  objectKeys,
+  parallelMap,
+  sleep,
+  splitOnce,
+  throwNotImplemented,
+  throwUnreachable,
+  timers_exports as timers,
+  toBytes,
+  twoMultiplicity,
+  typed_exports as typed,
+  u8_exports as u8,
+  unknownToError,
+  unsafeCastType,
+  utf8_exports as utf8
+};