speexjs-core 0.7.0

package/dist/async/index.js

@@ -0,0 +1,366 @@
+// src/async/queue.ts
+var Queue = class {
+  _tasks = [];
+  _running = 0;
+  _paused = false;
+  _idleResolve = null;
+  _maxConcurrency;
+  constructor(options) {
+    this._maxConcurrency = options?.concurrency ?? 1;
+    if (this._maxConcurrency < 1) this._maxConcurrency = 1;
+  }
+  get pending() {
+    return this._tasks.length;
+  }
+  get running() {
+    return this._running;
+  }
+  add(task, options) {
+    return new Promise((resolve, reject) => {
+      this._tasks.push({
+        priority: options?.priority ?? 0,
+        task,
+        resolve,
+        reject
+      });
+      this._tasks.sort((a, b) => b.priority - a.priority);
+      this._process();
+    });
+  }
+  pause() {
+    this._paused = true;
+  }
+  resume() {
+    this._paused = false;
+    this._process();
+  }
+  clear() {
+    const err = new Error("Queue cleared");
+    for (const t of this._tasks) t.reject(err);
+    this._tasks = [];
+  }
+  onIdle() {
+    if (this._running === 0 && this._tasks.length === 0) return Promise.resolve();
+    return new Promise((resolve) => {
+      this._idleResolve = resolve;
+    });
+  }
+  _process() {
+    if (this._paused) return;
+    while (this._running < this._maxConcurrency && this._tasks.length > 0) {
+      const item = this._tasks.shift();
+      this._running++;
+      item.task().then((result) => item.resolve(result)).catch((err) => item.reject(err)).finally(() => {
+        this._running--;
+        this._process();
+        if (this._running === 0 && this._tasks.length === 0 && this._idleResolve) {
+          this._idleResolve();
+          this._idleResolve = null;
+        }
+      });
+    }
+  }
+};
+
+// src/async/semaphore.ts
+var Semaphore = class {
+  _available;
+  _waiting = [];
+  constructor(concurrency) {
+    if (concurrency < 1) throw new RangeError("Semaphore concurrency must be >= 1");
+    this._available = concurrency;
+  }
+  get available() {
+    return this._available;
+  }
+  acquire() {
+    if (this._available > 0) {
+      this._available--;
+      return Promise.resolve(this._release.bind(this));
+    }
+    return new Promise((resolve) => {
+      this._waiting.push(() => {
+        this._available--;
+        resolve(this._release.bind(this));
+      });
+    });
+  }
+  async use(fn) {
+    const release = await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  _release() {
+    this._available++;
+    if (this._waiting.length > 0) {
+      const next = this._waiting.shift();
+      if (next) next();
+    }
+  }
+};
+
+// src/async/memoize.ts
+function memoizeAsync(fn, options) {
+  const {
+    ttl = 6e4,
+    staleWhileRevalidate = false,
+    maxSize = 100,
+    resolver = (...args) => JSON.stringify(args)
+  } = options ?? {};
+  const cache = /* @__PURE__ */ new Map();
+  const memoized = (async (...args) => {
+    const key = resolver(...args);
+    const now = Date.now();
+    const entry = cache.get(key);
+    if (entry && now - entry.timestamp < ttl) {
+      return entry.value;
+    }
+    if (entry && staleWhileRevalidate && now - entry.timestamp >= ttl) {
+      if (entry.promise) {
+        return entry.value;
+      }
+      entry.promise = fn(...args).then((result2) => {
+        entry.value = result2;
+        entry.timestamp = now;
+        entry.promise = void 0;
+        return result2;
+      }).catch((err) => {
+        entry.promise = void 0;
+        throw err;
+      });
+      return entry.value;
+    }
+    const result = await fn(...args);
+    cache.set(key, { value: result, timestamp: now });
+    if (cache.size > maxSize) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey !== void 0) cache.delete(firstKey);
+    }
+    return result;
+  });
+  memoized.cache = cache;
+  memoized.clear = () => cache.clear();
+  return memoized;
+}
+
+// src/async/ratelimit.ts
+var RateLimiter = class {
+  _maxRequests;
+  _perWindow;
+  _timestamps = [];
+  constructor(options) {
+    if (options.maxRequests < 1) throw new RangeError("maxRequests must be >= 1");
+    if (options.perWindow < 1) throw new RangeError("perWindow must be >= 1");
+    this._maxRequests = options.maxRequests;
+    this._perWindow = options.perWindow;
+  }
+  _prune() {
+    const now = Date.now();
+    const cutoff = now - this._perWindow;
+    while (this._timestamps.length > 0) {
+      const ts = this._timestamps[0];
+      if (ts === void 0 || ts > cutoff) break;
+      this._timestamps.shift();
+    }
+  }
+  /**
+   * Check if a request is allowed without waiting.
+   */
+  tryAcquire() {
+    this._prune();
+    if (this._timestamps.length < this._maxRequests) {
+      this._timestamps.push(Date.now());
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Wait until a request is allowed.
+   */
+  async acquire() {
+    while (true) {
+      this._prune();
+      if (this._timestamps.length < this._maxRequests) {
+        this._timestamps.push(Date.now());
+        return;
+      }
+      const oldest = this._timestamps[0] ?? Date.now();
+      const waitMs = oldest + this._perWindow - Date.now();
+      if (waitMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, waitMs));
+      }
+    }
+  }
+  /**
+   * Current number of pending requests in the window.
+   */
+  get pending() {
+    this._prune();
+    return this._timestamps.length;
+  }
+};
+
+// src/async/mutex.ts
+var Mutex = class {
+  _locked = false;
+  _waiting = [];
+  /**
+   * Acquire the lock. Returns a release function to be called when done.
+   */
+  acquire() {
+    if (!this._locked) {
+      this._locked = true;
+      return Promise.resolve(this._release.bind(this));
+    }
+    return new Promise((resolve) => {
+      this._waiting.push(() => {
+        resolve(this._release.bind(this));
+      });
+    });
+  }
+  /**
+   * Run a function with the lock held and automatically release it.
+   */
+  async use(fn) {
+    const release = await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Whether the mutex is currently locked.
+   */
+  get locked() {
+    return this._locked;
+  }
+  _release() {
+    if (this._waiting.length > 0) {
+      const next = this._waiting.shift();
+      if (next) next();
+    } else {
+      this._locked = false;
+    }
+  }
+};
+
+// src/async/batch.ts
+async function batch(items, batchSize, fn) {
+  if (batchSize < 1) throw new RangeError("batchSize must be >= 1");
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const chunk = items.slice(i, i + batchSize);
+    const batchResults = await fn(chunk);
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// src/async/waterfall.ts
+async function waterfall(tasks, initial) {
+  let result = initial;
+  for (const task of tasks) {
+    result = await task(result);
+  }
+  return result;
+}
+
+// src/async/index.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function timeout(promise, ms, errorMessage) {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(errorMessage ?? `Promise timed out after ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function raceWithTimeout(promise, ms) {
+  let timer;
+  const timeoutPromise = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function allSettledMap(items, fn) {
+  return await Promise.allSettled(items.map(fn));
+}
+async function parallelMap(items, fn, concurrency = Number.POSITIVE_INFINITY) {
+  if (concurrency === Number.POSITIVE_INFINITY) {
+    return await Promise.all(items.map(fn));
+  }
+  const results = [];
+  const queue = [...items];
+  const worker = async () => {
+    while (queue.length > 0) {
+      const item = queue.shift();
+      results.push(await fn(item));
+    }
+  };
+  const workerCount = Math.min(concurrency, items.length);
+  const workers = Array.from({ length: workerCount }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+async function retryAsync(fn, options) {
+  const { attempts = 3, baseDelay = 1e3, maxDelay = 3e4, shouldRetry = () => true } = options ?? {};
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!shouldRetry(error) || attempt >= attempts - 1) break;
+      const delay = Math.min(baseDelay * 2 ** attempt + Math.random() * baseDelay, maxDelay);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+async function pipeline(initial, ...fns) {
+  let result = initial;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+export {
+  Mutex,
+  Queue,
+  RateLimiter,
+  Semaphore,
+  allSettledMap,
+  batch,
+  deferred,
+  memoizeAsync,
+  parallelMap,
+  pipeline,
+  raceWithTimeout,
+  retryAsync,
+  sleep,
+  timeout,
+  waterfall
+};
+//# sourceMappingURL=index.js.map

package/dist/async/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/async/queue.ts","../../src/async/semaphore.ts","../../src/async/memoize.ts","../../src/async/ratelimit.ts","../../src/async/mutex.ts","../../src/async/batch.ts","../../src/async/waterfall.ts","../../src/async/index.ts"],"sourcesContent":["export interface QueueOptions {\n  concurrency?: number\n}\n\n/**\n * Priority-based async task queue with concurrency control.\n *\n * @example\n * const queue = new Queue({ concurrency: 2 })\n * const result = await queue.add(() => fetch('/api/data'))\n */\nexport class Queue<T = unknown> {\n  private _tasks: Array<{\n    priority: number\n    task: () => Promise<T>\n    resolve: (value: T) => void\n    reject: (reason: unknown) => void\n  }> = []\n  private _running = 0\n  private _paused = false\n  private _idleResolve: (() => void) | null = null\n  private _maxConcurrency: number\n\n  constructor(options?: QueueOptions) {\n    this._maxConcurrency = options?.concurrency ?? 1\n    if (this._maxConcurrency < 1) this._maxConcurrency = 1\n  }\n\n  get pending(): number {\n    return this._tasks.length\n  }\n\n  get running(): number {\n    return this._running\n  }\n\n  add<R>(task: () => Promise<R>, options?: { priority?: number }): Promise<R> {\n    return new Promise<R>((resolve, reject) => {\n      this._tasks.push({\n        priority: options?.priority ?? 0,\n        task: task as unknown as () => Promise<T>,\n        resolve: resolve as (value: T) => void,\n        reject,\n      })\n      this._tasks.sort((a, b) => b.priority - a.priority)\n      this._process()\n    })\n  }\n\n  pause(): void {\n    this._paused = true\n  }\n\n  resume(): void {\n    this._paused = false\n    this._process()\n  }\n\n  clear(): void {\n    const err = new Error('Queue cleared')\n    for (const t of this._tasks) t.reject(err)\n    this._tasks = []\n  }\n\n  onIdle(): Promise<void> {\n    if (this._running === 0 && this._tasks.length === 0) return Promise.resolve()\n    return new Promise<void>((resolve) => {\n      this._idleResolve = resolve\n    })\n  }\n\n  private _process(): void {\n    if (this._paused) return\n    while (this._running < this._maxConcurrency && this._tasks.length > 0) {\n      const item = this._tasks.shift()!\n      this._running++\n      item\n        .task()\n        .then((result) => item.resolve(result))\n        .catch((err) => item.reject(err))\n        .finally(() => {\n          this._running--\n          this._process()\n          if (this._running === 0 && this._tasks.length === 0 && this._idleResolve) {\n            this._idleResolve()\n            this._idleResolve = null\n          }\n        })\n    }\n  }\n}\n\nexport default Queue\n","/**\n * Semaphore for controlling concurrent access to a resource.\n *\n * @example\n * const sem = new Semaphore(2)\n * await sem.use(async () => {\n *   // Only 2 callers at a time\n *   await doSomething()\n * })\n */\nexport class Semaphore {\n  private _available: number\n  private _waiting: Array<() => void> = []\n\n  constructor(concurrency: number) {\n    if (concurrency < 1) throw new RangeError('Semaphore concurrency must be >= 1')\n    this._available = concurrency\n  }\n\n  get available(): number {\n    return this._available\n  }\n\n  acquire(): Promise<() => void> {\n    if (this._available > 0) {\n      this._available--\n      return Promise.resolve(this._release.bind(this))\n    }\n    return new Promise<() => void>((resolve) => {\n      this._waiting.push(() => {\n        this._available--\n        resolve(this._release.bind(this))\n      })\n    })\n  }\n\n  async use<T>(fn: () => Promise<T>): Promise<T> {\n    const release = await this.acquire()\n    try {\n      return await fn()\n    } finally {\n      release()\n    }\n  }\n\n  private _release(): void {\n    this._available++\n    if (this._waiting.length > 0) {\n      const next = this._waiting.shift()\n      if (next) next()\n    }\n  }\n}\n\nexport default Semaphore\n","/**\n * Options for memoizeAsync.\n */\nexport interface MemoizeAsyncOptions {\n  /** Time-to-live in milliseconds (default: 60000) */\n  ttl?: number\n  /** Return stale value while fetching fresh data (default: false) */\n  staleWhileRevalidate?: boolean\n  /** Maximum number of cached entries (default: 100) */\n  maxSize?: number\n  /** Custom cache key resolver. Defaults to JSON.stringify of args. */\n  resolver?: (...args: unknown[]) => string\n}\n\ninterface CacheEntry {\n  value: unknown\n  timestamp: number\n  promise?: Promise<unknown>\n}\n\n/**\n * Memoizes an async function with TTL, stale-while-revalidate, and bounded cache.\n *\n * @example\n * const fetchData = memoizeAsync(async (id: string) => {\n *   return await api.fetch(id)\n * }, { ttl: 5000, staleWhileRevalidate: true })\n *\n * const data = await fetchData('123') // cached for 5s\n * const data2 = await fetchData('123') // returns cached, refreshes in bg\n */\nexport function memoizeAsync<T extends (...args: unknown[]) => Promise<unknown>>(\n  fn: T,\n  options?: MemoizeAsyncOptions,\n): T & {\n  cache: Map<string, CacheEntry>\n  clear: () => void\n} {\n  const {\n    ttl = 60000,\n    staleWhileRevalidate = false,\n    maxSize = 100,\n    resolver = (...args: unknown[]) => JSON.stringify(args),\n  } = options ?? {}\n\n  const cache = new Map<string, CacheEntry>()\n\n  const memoized = (async (...args: unknown[]): Promise<unknown> => {\n    const key = resolver(...args)\n    const now = Date.now()\n    const entry = cache.get(key)\n\n    if (entry && now - entry.timestamp < ttl) {\n      return entry.value\n    }\n\n    if (entry && staleWhileRevalidate && now - entry.timestamp >= ttl) {\n      if (entry.promise) {\n        return entry.value\n      }\n      entry.promise = fn(...args)\n        .then((result) => {\n          entry.value = result\n          entry.timestamp = now\n          entry.promise = undefined\n          return result\n        })\n        .catch((err) => {\n          entry.promise = undefined\n          throw err\n        })\n      return entry.value\n    }\n\n    const result = await fn(...args)\n    cache.set(key, { value: result, timestamp: now })\n\n    if (cache.size > maxSize) {\n      const firstKey = cache.keys().next().value\n      if (firstKey !== undefined) cache.delete(firstKey)\n    }\n\n    return result\n  }) as T & {\n    cache: Map<string, CacheEntry>\n    clear: () => void\n  }\n\n  memoized.cache = cache\n  memoized.clear = () => cache.clear()\n\n  return memoized\n}\n\nexport default memoizeAsync\n","/**\n * Rate limiter that restricts the number of requests within a sliding time window.\n *\n * @example\n * const limiter = new RateLimiter({ maxRequests: 5, perWindow: 1000 })\n * if (limiter.tryAcquire()) {\n *   // Allowed\n * }\n *\n * @example\n * const limiter = new RateLimiter({ maxRequests: 2, perWindow: 1000 })\n * await limiter.acquire()\n * await limiter.acquire()\n * // Third call waits until the window rolls\n */\nexport class RateLimiter {\n  private _maxRequests: number\n  private _perWindow: number\n  private _timestamps: number[] = []\n\n  constructor(options: { maxRequests: number; perWindow: number }) {\n    if (options.maxRequests < 1) throw new RangeError('maxRequests must be >= 1')\n    if (options.perWindow < 1) throw new RangeError('perWindow must be >= 1')\n    this._maxRequests = options.maxRequests\n    this._perWindow = options.perWindow\n  }\n\n  private _prune(): void {\n    const now = Date.now()\n    const cutoff = now - this._perWindow\n    while (this._timestamps.length > 0) {\n      const ts = this._timestamps[0]\n      if (ts === undefined || ts > cutoff) break\n      this._timestamps.shift()\n    }\n  }\n\n  /**\n   * Check if a request is allowed without waiting.\n   */\n  tryAcquire(): boolean {\n    this._prune()\n    if (this._timestamps.length < this._maxRequests) {\n      this._timestamps.push(Date.now())\n      return true\n    }\n    return false\n  }\n\n  /**\n   * Wait until a request is allowed.\n   */\n  async acquire(): Promise<void> {\n    while (true) {\n      this._prune()\n      if (this._timestamps.length < this._maxRequests) {\n        this._timestamps.push(Date.now())\n        return\n      }\n      const oldest = this._timestamps[0] ?? Date.now()\n      const waitMs = oldest + this._perWindow - Date.now()\n      if (waitMs > 0) {\n        await new Promise<void>(resolve => setTimeout(resolve, waitMs))\n      }\n    }\n  }\n\n  /**\n   * Current number of pending requests in the window.\n   */\n  get pending(): number {\n    this._prune()\n    return this._timestamps.length\n  }\n}\n\nexport default RateLimiter\n","/**\n * Mutex for exclusive access to a critical section.\n *\n * @example\n * const mutex = new Mutex()\n * const release = await mutex.acquire()\n * try {\n *   // Exclusive access\n * } finally {\n *   release()\n * }\n *\n * @example\n * const mutex = new Mutex()\n * const result = await mutex.use(async () => {\n *   return await fetch('/api/data')\n * })\n */\nexport class Mutex {\n  private _locked = false\n  private _waiting: Array<() => void> = []\n\n  /**\n   * Acquire the lock. Returns a release function to be called when done.\n   */\n  acquire(): Promise<() => void> {\n    if (!this._locked) {\n      this._locked = true\n      return Promise.resolve(this._release.bind(this))\n    }\n    return new Promise<() => void>(resolve => {\n      this._waiting.push(() => {\n        resolve(this._release.bind(this))\n      })\n    })\n  }\n\n  /**\n   * Run a function with the lock held and automatically release it.\n   */\n  async use<T>(fn: () => Promise<T>): Promise<T> {\n    const release = await this.acquire()\n    try {\n      return await fn()\n    } finally {\n      release()\n    }\n  }\n\n  /**\n   * Whether the mutex is currently locked.\n   */\n  get locked(): boolean {\n    return this._locked\n  }\n\n  private _release(): void {\n    if (this._waiting.length > 0) {\n      const next = this._waiting.shift()\n      if (next) next()\n    } else {\n      this._locked = false\n    }\n  }\n}\n\nexport default Mutex\n","/**\n * Process an array of items in sequential batches.\n *\n * @example\n * const items = [1, 2, 3, 4, 5]\n * const results = await batch(items, 2, async (batch) => {\n *   return batch.map(n => n * 2)\n * })\n * // results = [2, 4, 6, 8, 10]\n */\nexport async function batch<T, R>(\n  items: T[],\n  batchSize: number,\n  fn: (batch: T[]) => Promise<R[]>,\n): Promise<R[]> {\n  if (batchSize < 1) throw new RangeError('batchSize must be >= 1')\n\n  const results: R[] = []\n  for (let i = 0; i < items.length; i += batchSize) {\n    const chunk = items.slice(i, i + batchSize)\n    const batchResults = await fn(chunk)\n    results.push(...batchResults)\n  }\n  return results\n}\n\nexport default batch\n","/**\n * Execute async tasks in sequence, passing each result to the next task.\n *\n * @example\n * const result = await waterfall([\n *   async (n: number) => n + 1,\n *   async (n: number) => n * 2,\n *   async (n: number) => `Result: ${n}`,\n * ], 1)\n * // result = \"Result: 4\"\n *\n * @example\n * const result = await waterfall([\n *   async () => fetch('/api/data').then(r => r.json()),\n *   async (data) => process(data),\n * ])\n */\nexport async function waterfall(\n  tasks: Array<(arg: any) => Promise<any>>,\n  initial?: any,\n): Promise<any> {\n  let result = initial\n  for (const task of tasks) {\n    result = await task(result)\n  }\n  return result\n}\n\nexport default waterfall\n","import type { RetryOptions } from '../core/index.js'\r\n\r\n/**\r\n * Delays execution for the given number of milliseconds.\r\n */\r\nexport function sleep(ms: number): Promise<void> {\r\n  return new Promise(resolve => setTimeout(resolve, ms))\r\n}\r\n\r\n/**\r\n * Rejects a promise if it does not resolve within the specified timeout.\r\n */\r\nexport async function timeout<T>(promise: Promise<T>, ms: number, errorMessage?: string): Promise<T> {\r\n  let timer: ReturnType<typeof setTimeout> | undefined\r\n  const timeoutPromise = new Promise<never>((_, reject) => {\r\n    timer = setTimeout(() => reject(new Error(errorMessage ?? `Promise timed out after ${ms}ms`)), ms)\r\n  })\r\n  try {\r\n    return await Promise.race([promise, timeoutPromise])\r\n  } finally {\r\n    if (timer !== undefined) clearTimeout(timer)\r\n  }\r\n}\r\n\r\n/**\r\n * Races a promise against a timeout, returning 'timeout' if the timer wins.\r\n */\r\nexport async function raceWithTimeout<T>(promise: Promise<T>, ms: number): Promise<T | 'timeout'> {\r\n  let timer: ReturnType<typeof setTimeout> | undefined\r\n  const timeoutPromise = new Promise<'timeout'>(resolve => {\r\n    timer = setTimeout(() => resolve('timeout'), ms)\r\n  })\r\n  try {\r\n    return await Promise.race([promise, timeoutPromise])\r\n  } finally {\r\n    if (timer !== undefined) clearTimeout(timer)\r\n  }\r\n}\r\n\r\n/**\r\n * Maps over an array with an async function, using Promise.allSettled.\r\n * Returns an array of PromiseSettledResult.\r\n */\r\nexport async function allSettledMap<T, R>(\r\n  items: T[],\r\n  fn: (item: T) => Promise<R>,\r\n): Promise<PromiseSettledResult<R>[]> {\r\n  return await Promise.allSettled(items.map(fn))\r\n}\r\n\r\n/**\r\n * Maps over an array with an async function, limiting concurrency.\r\n *\r\n * @param concurrency - Maximum number of concurrent operations (default Infinity)\r\n */\r\nexport async function parallelMap<T, R>(\r\n  items: T[],\r\n  fn: (item: T) => Promise<R>,\r\n  concurrency = Number.POSITIVE_INFINITY,\r\n): Promise<R[]> {\r\n  if (concurrency === Number.POSITIVE_INFINITY) {\r\n    return await Promise.all(items.map(fn))\r\n  }\r\n\r\n  const results: R[] = []\r\n  const queue = [...items]\r\n\r\n  const worker = async (): Promise<void> => {\r\n    while (queue.length > 0) {\r\n      const item = queue.shift()!\r\n      results.push(await fn(item))\r\n    }\r\n  }\r\n\r\n  const workerCount = Math.min(concurrency, items.length)\r\n  const workers = Array.from({ length: workerCount }, () => worker())\r\n  await Promise.all(workers)\r\n  return results\r\n}\r\n\r\n/**\r\n * Retries an async function with exponential backoff.\r\n */\r\nexport async function retryAsync<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T> {\r\n  const { attempts = 3, baseDelay = 1000, maxDelay = 30000, shouldRetry = () => true } = options ?? {}\r\n  let lastError: unknown\r\n  for (let attempt = 0; attempt < attempts; attempt++) {\r\n    try {\r\n      return await fn()\r\n    } catch (error) {\r\n      lastError = error\r\n      if (!shouldRetry(error) || attempt >= attempts - 1) break\r\n      const delay = Math.min(baseDelay * 2 ** attempt + Math.random() * baseDelay, maxDelay)\r\n      await sleep(delay)\r\n    }\r\n  }\r\n  throw lastError\r\n}\r\n\r\n/**\r\n * Composes async functions, passing the result of each to the next.\r\n */\r\nexport async function pipeline<T>(initial: T, ...fns: Array<(arg: T) => Promise<T>>): Promise<T> {\r\n  let result = initial\r\n  for (const fn of fns) {\r\n    result = await fn(result)\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Creates a deferred promise with external resolve and reject methods.\r\n */\r\nexport function deferred<T>(): Deferred<T> {\r\n  let resolve!: (value: T) => void\r\n  let reject!: (reason: unknown) => void\r\n  const promise = new Promise<T>((res, rej) => {\r\n    resolve = res\r\n    reject = rej\r\n  })\r\n  return { promise, resolve, reject }\r\n}\r\n\r\nexport interface Deferred<T> {\r\n  promise: Promise<T>\r\n  resolve: (value: T) => void\r\n  reject: (reason: unknown) => void\r\n}\r\n\r\n// ─── Queue, Semaphore, memoizeAsync ─────────────────────\r\nexport { Queue } from './queue.js'\r\nexport type { QueueOptions } from './queue.js'\r\nexport { Semaphore } from './semaphore.js'\r\nexport { memoizeAsync } from './memoize.js'\r\nexport type { MemoizeAsyncOptions } from './memoize.js'\r\n\r\n// ─── RateLimiter, Mutex, batch, waterfall ───────────────\r\nexport { RateLimiter } from './ratelimit.js'\r\nexport { Mutex } from './mutex.js'\r\nexport { batch } from './batch.js'\r\nexport { waterfall } from './waterfall.js'\r\n"],"mappings":";AAWO,IAAM,QAAN,MAAyB;AAAA,EACtB,SAKH,CAAC;AAAA,EACE,WAAW;AAAA,EACX,UAAU;AAAA,EACV,eAAoC;AAAA,EACpC;AAAA,EAER,YAAY,SAAwB;AAClC,SAAK,kBAAkB,SAAS,eAAe;AAC/C,QAAI,KAAK,kBAAkB,EAAG,MAAK,kBAAkB;AAAA,EACvD;AAAA,EAEA,IAAI,UAAkB;AACpB,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA,EAEA,IAAI,UAAkB;AACpB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAO,MAAwB,SAA6C;AAC1E,WAAO,IAAI,QAAW,CAAC,SAAS,WAAW;AACzC,WAAK,OAAO,KAAK;AAAA,QACf,UAAU,SAAS,YAAY;AAAA,QAC/B;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AACD,WAAK,OAAO,KAAK,CAAC,GAAG,MAAM,EAAE,WAAW,EAAE,QAAQ;AAClD,WAAK,SAAS;AAAA,IAChB,CAAC;AAAA,EACH;AAAA,EAEA,QAAc;AACZ,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,SAAe;AACb,SAAK,UAAU;AACf,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,QAAc;AACZ,UAAM,MAAM,IAAI,MAAM,eAAe;AACrC,eAAW,KAAK,KAAK,OAAQ,GAAE,OAAO,GAAG;AACzC,SAAK,SAAS,CAAC;AAAA,EACjB;AAAA,EAEA,SAAwB;AACtB,QAAI,KAAK,aAAa,KAAK,KAAK,OAAO,WAAW,EAAG,QAAO,QAAQ,QAAQ;AAC5E,WAAO,IAAI,QAAc,CAAC,YAAY;AACpC,WAAK,eAAe;AAAA,IACtB,CAAC;AAAA,EACH;AAAA,EAEQ,WAAiB;AACvB,QAAI,KAAK,QAAS;AAClB,WAAO,KAAK,WAAW,KAAK,mBAAmB,KAAK,OAAO,SAAS,GAAG;AACrE,YAAM,OAAO,KAAK,OAAO,MAAM;AAC/B,WAAK;AACL,WACG,KAAK,EACL,KAAK,CAAC,WAAW,KAAK,QAAQ,MAAM,CAAC,EACrC,MAAM,CAAC,QAAQ,KAAK,OAAO,GAAG,CAAC,EAC/B,QAAQ,MAAM;AACb,aAAK;AACL,aAAK,SAAS;AACd,YAAI,KAAK,aAAa,KAAK,KAAK,OAAO,WAAW,KAAK,KAAK,cAAc;AACxE,eAAK,aAAa;AAClB,eAAK,eAAe;AAAA,QACtB;AAAA,MACF,CAAC;AAAA,IACL;AAAA,EACF;AACF;;;AChFO,IAAM,YAAN,MAAgB;AAAA,EACb;AAAA,EACA,WAA8B,CAAC;AAAA,EAEvC,YAAY,aAAqB;AAC/B,QAAI,cAAc,EAAG,OAAM,IAAI,WAAW,oCAAoC;AAC9E,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,IAAI,YAAoB;AACtB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,UAA+B;AAC7B,QAAI,KAAK,aAAa,GAAG;AACvB,WAAK;AACL,aAAO,QAAQ,QAAQ,KAAK,SAAS,KAAK,IAAI,CAAC;AAAA,IACjD;AACA,WAAO,IAAI,QAAoB,CAAC,YAAY;AAC1C,WAAK,SAAS,KAAK,MAAM;AACvB,aAAK;AACL,gBAAQ,KAAK,SAAS,KAAK,IAAI,CAAC;AAAA,MAClC,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,IAAO,IAAkC;AAC7C,UAAM,UAAU,MAAM,KAAK,QAAQ;AACnC,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,UAAE;AACA,cAAQ;AAAA,IACV;AAAA,EACF;AAAA,EAEQ,WAAiB;AACvB,SAAK;AACL,QAAI,KAAK,SAAS,SAAS,GAAG;AAC5B,YAAM,OAAO,KAAK,SAAS,MAAM;AACjC,UAAI,KAAM,MAAK;AAAA,IACjB;AAAA,EACF;AACF;;;ACrBO,SAAS,aACd,IACA,SAIA;AACA,QAAM;AAAA,IACJ,MAAM;AAAA,IACN,uBAAuB;AAAA,IACvB,UAAU;AAAA,IACV,WAAW,IAAI,SAAoB,KAAK,UAAU,IAAI;AAAA,EACxD,IAAI,WAAW,CAAC;AAEhB,QAAM,QAAQ,oBAAI,IAAwB;AAE1C,QAAM,YAAY,UAAU,SAAsC;AAChE,UAAM,MAAM,SAAS,GAAG,IAAI;AAC5B,UAAM,MAAM,KAAK,IAAI;AACrB,UAAM,QAAQ,MAAM,IAAI,GAAG;AAE3B,QAAI,SAAS,MAAM,MAAM,YAAY,KAAK;AACxC,aAAO,MAAM;AAAA,IACf;AAEA,QAAI,SAAS,wBAAwB,MAAM,MAAM,aAAa,KAAK;AACjE,UAAI,MAAM,SAAS;AACjB,eAAO,MAAM;AAAA,MACf;AACA,YAAM,UAAU,GAAG,GAAG,IAAI,EACvB,KAAK,CAACA,YAAW;AAChB,cAAM,QAAQA;AACd,cAAM,YAAY;AAClB,cAAM,UAAU;AAChB,eAAOA;AAAA,MACT,CAAC,EACA,MAAM,CAAC,QAAQ;AACd,cAAM,UAAU;AAChB,cAAM;AAAA,MACR,CAAC;AACH,aAAO,MAAM;AAAA,IACf;AAEA,UAAM,SAAS,MAAM,GAAG,GAAG,IAAI;AAC/B,UAAM,IAAI,KAAK,EAAE,OAAO,QAAQ,WAAW,IAAI,CAAC;AAEhD,QAAI,MAAM,OAAO,SAAS;AACxB,YAAM,WAAW,MAAM,KAAK,EAAE,KAAK,EAAE;AACrC,UAAI,aAAa,OAAW,OAAM,OAAO,QAAQ;AAAA,IACnD;AAEA,WAAO;AAAA,EACT;AAKA,WAAS,QAAQ;AACjB,WAAS,QAAQ,MAAM,MAAM,MAAM;AAEnC,SAAO;AACT;;;AC7EO,IAAM,cAAN,MAAkB;AAAA,EACf;AAAA,EACA;AAAA,EACA,cAAwB,CAAC;AAAA,EAEjC,YAAY,SAAqD;AAC/D,QAAI,QAAQ,cAAc,EAAG,OAAM,IAAI,WAAW,0BAA0B;AAC5E,QAAI,QAAQ,YAAY,EAAG,OAAM,IAAI,WAAW,wBAAwB;AACxE,SAAK,eAAe,QAAQ;AAC5B,SAAK,aAAa,QAAQ;AAAA,EAC5B;AAAA,EAEQ,SAAe;AACrB,UAAM,MAAM,KAAK,IAAI;AACrB,UAAM,SAAS,MAAM,KAAK;AAC1B,WAAO,KAAK,YAAY,SAAS,GAAG;AAClC,YAAM,KAAK,KAAK,YAAY,CAAC;AAC7B,UAAI,OAAO,UAAa,KAAK,OAAQ;AACrC,WAAK,YAAY,MAAM;AAAA,IACzB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,aAAsB;AACpB,SAAK,OAAO;AACZ,QAAI,KAAK,YAAY,SAAS,KAAK,cAAc;AAC/C,WAAK,YAAY,KAAK,KAAK,IAAI,CAAC;AAChC,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,UAAyB;AAC7B,WAAO,MAAM;AACX,WAAK,OAAO;AACZ,UAAI,KAAK,YAAY,SAAS,KAAK,cAAc;AAC/C,aAAK,YAAY,KAAK,KAAK,IAAI,CAAC;AAChC;AAAA,MACF;AACA,YAAM,SAAS,KAAK,YAAY,CAAC,KAAK,KAAK,IAAI;AAC/C,YAAM,SAAS,SAAS,KAAK,aAAa,KAAK,IAAI;AACnD,UAAI,SAAS,GAAG;AACd,cAAM,IAAI,QAAc,aAAW,WAAW,SAAS,MAAM,CAAC;AAAA,MAChE;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,UAAkB;AACpB,SAAK,OAAO;AACZ,WAAO,KAAK,YAAY;AAAA,EAC1B;AACF;;;ACxDO,IAAM,QAAN,MAAY;AAAA,EACT,UAAU;AAAA,EACV,WAA8B,CAAC;AAAA;AAAA;AAAA;AAAA,EAKvC,UAA+B;AAC7B,QAAI,CAAC,KAAK,SAAS;AACjB,WAAK,UAAU;AACf,aAAO,QAAQ,QAAQ,KAAK,SAAS,KAAK,IAAI,CAAC;AAAA,IACjD;AACA,WAAO,IAAI,QAAoB,aAAW;AACxC,WAAK,SAAS,KAAK,MAAM;AACvB,gBAAQ,KAAK,SAAS,KAAK,IAAI,CAAC;AAAA,MAClC,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,IAAO,IAAkC;AAC7C,UAAM,UAAU,MAAM,KAAK,QAAQ;AACnC,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,UAAE;AACA,cAAQ;AAAA,IACV;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,SAAkB;AACpB,WAAO,KAAK;AAAA,EACd;AAAA,EAEQ,WAAiB;AACvB,QAAI,KAAK,SAAS,SAAS,GAAG;AAC5B,YAAM,OAAO,KAAK,SAAS,MAAM;AACjC,UAAI,KAAM,MAAK;AAAA,IACjB,OAAO;AACL,WAAK,UAAU;AAAA,IACjB;AAAA,EACF;AACF;;;ACtDA,eAAsB,MACpB,OACA,WACA,IACc;AACd,MAAI,YAAY,EAAG,OAAM,IAAI,WAAW,wBAAwB;AAEhE,QAAM,UAAe,CAAC;AACtB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;AAChD,UAAM,QAAQ,MAAM,MAAM,GAAG,IAAI,SAAS;AAC1C,UAAM,eAAe,MAAM,GAAG,KAAK;AACnC,YAAQ,KAAK,GAAG,YAAY;AAAA,EAC9B;AACA,SAAO;AACT;;;ACPA,eAAsB,UACpB,OACA,SACc;AACd,MAAI,SAAS;AACb,aAAW,QAAQ,OAAO;AACxB,aAAS,MAAM,KAAK,MAAM;AAAA,EAC5B;AACA,SAAO;AACT;;;ACrBO,SAAS,MAAM,IAA2B;AAC/C,SAAO,IAAI,QAAQ,aAAW,WAAW,SAAS,EAAE,CAAC;AACvD;AAKA,eAAsB,QAAW,SAAqB,IAAY,cAAmC;AACnG,MAAI;AACJ,QAAM,iBAAiB,IAAI,QAAe,CAAC,GAAG,WAAW;AACvD,YAAQ,WAAW,MAAM,OAAO,IAAI,MAAM,gBAAgB,2BAA2B,EAAE,IAAI,CAAC,GAAG,EAAE;AAAA,EACnG,CAAC;AACD,MAAI;AACF,WAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,cAAc,CAAC;AAAA,EACrD,UAAE;AACA,QAAI,UAAU,OAAW,cAAa,KAAK;AAAA,EAC7C;AACF;AAKA,eAAsB,gBAAmB,SAAqB,IAAoC;AAChG,MAAI;AACJ,QAAM,iBAAiB,IAAI,QAAmB,aAAW;AACvD,YAAQ,WAAW,MAAM,QAAQ,SAAS,GAAG,EAAE;AAAA,EACjD,CAAC;AACD,MAAI;AACF,WAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,cAAc,CAAC;AAAA,EACrD,UAAE;AACA,QAAI,UAAU,OAAW,cAAa,KAAK;AAAA,EAC7C;AACF;AAMA,eAAsB,cACpB,OACA,IACoC;AACpC,SAAO,MAAM,QAAQ,WAAW,MAAM,IAAI,EAAE,CAAC;AAC/C;AAOA,eAAsB,YACpB,OACA,IACA,cAAc,OAAO,mBACP;AACd,MAAI,gBAAgB,OAAO,mBAAmB;AAC5C,WAAO,MAAM,QAAQ,IAAI,MAAM,IAAI,EAAE,CAAC;AAAA,EACxC;AAEA,QAAM,UAAe,CAAC;AACtB,QAAM,QAAQ,CAAC,GAAG,KAAK;AAEvB,QAAM,SAAS,YAA2B;AACxC,WAAO,MAAM,SAAS,GAAG;AACvB,YAAM,OAAO,MAAM,MAAM;AACzB,cAAQ,KAAK,MAAM,GAAG,IAAI,CAAC;AAAA,IAC7B;AAAA,EACF;AAEA,QAAM,cAAc,KAAK,IAAI,aAAa,MAAM,MAAM;AACtD,QAAM,UAAU,MAAM,KAAK,EAAE,QAAQ,YAAY,GAAG,MAAM,OAAO,CAAC;AAClE,QAAM,QAAQ,IAAI,OAAO;AACzB,SAAO;AACT;AAKA,eAAsB,WAAc,IAAsB,SAAoC;AAC5F,QAAM,EAAE,WAAW,GAAG,YAAY,KAAM,WAAW,KAAO,cAAc,MAAM,KAAK,IAAI,WAAW,CAAC;AACnG,MAAI;AACJ,WAAS,UAAU,GAAG,UAAU,UAAU,WAAW;AACnD,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,SAAS,OAAO;AACd,kBAAY;AACZ,UAAI,CAAC,YAAY,KAAK,KAAK,WAAW,WAAW,EAAG;AACpD,YAAM,QAAQ,KAAK,IAAI,YAAY,KAAK,UAAU,KAAK,OAAO,IAAI,WAAW,QAAQ;AACrF,YAAM,MAAM,KAAK;AAAA,IACnB;AAAA,EACF;AACA,QAAM;AACR;AAKA,eAAsB,SAAY,YAAe,KAAgD;AAC/F,MAAI,SAAS;AACb,aAAW,MAAM,KAAK;AACpB,aAAS,MAAM,GAAG,MAAM;AAAA,EAC1B;AACA,SAAO;AACT;AAKO,SAAS,WAA2B;AACzC,MAAI;AACJ,MAAI;AACJ,QAAM,UAAU,IAAI,QAAW,CAAC,KAAK,QAAQ;AAC3C,cAAU;AACV,aAAS;AAAA,EACX,CAAC;AACD,SAAO,EAAE,SAAS,SAAS,OAAO;AACpC;","names":["result"]}

package/dist/collection/index.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Groups an array of items by a key extracted from each item.
+ *
+ * @example groupBy([{ type: 'a' }, { type: 'b' }, { type: 'a' }], x => x.type)
+ *          // => { a: [{ type: 'a' }, { type: 'a' }], b: [{ type: 'b' }] }
+ */
+declare function groupBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, T[]>;
+/**
+ * Creates an object keyed by the result of keyFn for each item.
+ *
+ * @example keyBy([{ id: 1, name: 'a' }, { id: 2, name: 'b' }], x => x.id)
+ *          // => { 1: { id: 1, name: 'a' }, 2: { id: 2, name: 'b' } }
+ */
+declare function keyBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, T>;
+/**
+ * Returns a copy of the object with the specified keys omitted.
+ */
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * Returns a copy of the object with only the specified keys.
+ */
+declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * Extracts a property value from each item in an array.
+ */
+declare function pluck<T, K extends keyof T>(items: T[], key: K): T[K][];
+/**
+ * Randomizes array order in-place using the Fisher-Yates algorithm.
+ */
+declare function shuffle<T>(items: T[]): T[];
+/**
+ * Returns a random element from the array, or undefined if empty.
+ */
+declare function sample<T>(items: T[]): T | undefined;
+/**
+ * Returns an array of `size` random elements (without duplicates).
+ */
+declare function sampleSize<T>(items: T[], size: number): T[];
+/**
+ * Splits an array into chunks of the specified size.
+ */
+declare function chunk<T>(items: T[], size: number): T[][];
+declare function sortBy<T>(items: T[], ...criteria: Array<(item: T) => unknown>): T[];
+/**
+ * Returns a sorted copy of the array by a single key and direction.
+ */
+declare function orderBy<T>(items: T[], key: (item: T) => unknown, direction?: SortDirection): T[];
+/**
+ * Returns unique elements based on the result of keyFn.
+ */
+declare function uniqueBy<T>(items: T[], keyFn: (item: T) => unknown): T[];
+/**
+ * Flattens an array of arrays one level.
+ */
+declare function flatten<T>(items: T[][]): T[];
+/**
+ * Returns an array with unique primitive values.
+ */
+declare function uniq<T>(items: T[]): T[];
+/**
+ * Returns the first element, or undefined if empty.
+ */
+declare function first<T>(items: T[]): T | undefined;
+/**
+ * Returns the last element, or undefined if empty.
+ */
+declare function last<T>(items: T[]): T | undefined;
+/**
+ * Checks if a value is empty.
+ * Works for arrays, objects, strings, Map, and Set.
+ */
+declare function isEmpty(value: unknown): boolean;
+type SortDirection = 'asc' | 'desc';
+declare function topoSort<T extends {
+    id: string;
+    dependencies?: string[];
+}>(items: T[]): T[];
+declare function slidingWindows<T>(items: T[], size: number, step?: number): T[][];
+declare function tumblingWindows<T>(items: T[], size: number): T[][];
+/**
+ * Gets a nested value from an object using a dot-separated path.
+ *
+ * @example deepGet({ a: { b: 2 } }, 'a.b') // 2
+ * @example deepGet({ a: { b: 2 } }, 'a.c') // undefined
+ */
+declare function deepGet<T = unknown>(obj: unknown, path: string, default_?: T): T | undefined;
+/**
+ * Sets a nested value in an object using a dot-separated path.
+ * Creates intermediate objects/arrays as needed.
+ *
+ * @example deepSet({ a: { b: 2 } }, 'a.b', 3) // { a: { b: 3 } }
+ * @example deepSet({}, 'a.b.c', 1) // { a: { b: { c: 1 } } }
+ */
+declare function deepSet<T extends Record<string, unknown>>(obj: T, path: string, value: unknown): T;
+/**
+ * Splits an array into two groups: those that pass the predicate and those that don't.
+ *
+ * @example partition([1, 2, 3, 4, 5], n => n % 2 === 0)
+ *          // => [[2, 4], [1, 3, 5]]
+ */
+declare function partition<T>(items: T[], predicate: (item: T) => boolean): [T[], T[]];
+/**
+ * Removes all falsy values from an array (false, null, 0, '', undefined, NaN).
+ *
+ * @example compact([0, 1, false, 2, '', 3, null, undefined, NaN])
+ *          // => [1, 2, 3]
+ */
+declare function compact<T>(items: (T | false | null | 0 | '' | undefined)[]): T[];
+/**
+ * Returns elements in array A that are not in array B (uses SameValueZero).
+ *
+ * @example difference([1, 2, 3, 4], [2, 4])
+ *          // => [1, 3]
+ */
+declare function difference<T>(a: T[], b: T[]): T[];
+/**
+ * Returns elements present in all given arrays (uses SameValueZero).
+ *
+ * @example intersection([1, 2, 3], [2, 3, 4])
+ *          // => [2, 3]
+ */
+declare function intersection<T>(a: T[], b: T[]): T[];
+/**
+ * Returns unique elements from all given arrays.
+ *
+ * @example union([1, 2], [2, 3], [3, 4])
+ *          // => [1, 2, 3, 4]
+ */
+declare function union<T>(...arrays: T[][]): T[];
+/**
+ * Merges arrays element-wise into tuples, stopping at the shortest array.
+ *
+ * @example zip(['a', 'b', 'c'], [1, 2])
+ *          // => [['a', 1], ['b', 2]]
+ */
+declare function zip<T, U>(a: T[], b: U[]): [T, U][];
+declare function zip<T, U, V>(a: T[], b: U[], c: V[]): [T, U, V][];
+/**
+ * Inverse of zip: splits an array of tuples back into individual arrays.
+ *
+ * @example unzip([['a', 1], ['b', 2]])
+ *          // => [['a', 'b'], [1, 2]]
+ */
+declare function unzip<T>(paired: T[][]): T[][];
+/**
+ * Counts occurrences of each key produced by the key function.
+ *
+ * @example countBy([1, 2, 3, 4, 5], n => n % 2 === 0 ? 'even' : 'odd')
+ *          // => { odd: 3, even: 2 }
+ */
+declare function countBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, number>;
+/**
+ * Returns the element with the maximum value by the key function.
+ *
+ * @example maxBy([{ name: 'a', score: 10 }, { name: 'b', score: 20 }], x => x.score)
+ *          // => { name: 'b', score: 20 }
+ */
+declare function maxBy<T>(items: T[], keyFn: (item: T) => number): T | undefined;
+/**
+ * Returns the element with the minimum value by the key function.
+ *
+ * @example minBy([{ name: 'a', score: 10 }, { name: 'b', score: 20 }], x => x.score)
+ *          // => { name: 'a', score: 10 }
+ */
+declare function minBy<T>(items: T[], keyFn: (item: T) => number): T | undefined;
+/**
+ * Returns the sum of values produced by the key function.
+ *
+ * @example sumBy([{ n: 1 }, { n: 2 }, { n: 3 }], x => x.n)
+ *          // => 6
+ */
+declare function sumBy<T>(items: T[], keyFn: (item: T) => number): number;
+/**
+ * Returns the index of the first element satisfying the predicate, or -1.
+ *
+ * @example findIndex([1, 3, 5, 8, 10], n => n % 2 === 0)
+ *          // => 3
+ */
+declare function findIndex<T>(items: T[], predicate: (item: T) => boolean, fromIndex?: number): number;
+/**
+ * Finds the last element satisfying the predicate.
+ *
+ * @example findLast([1, 2, 3, 4, 5], n => n % 2 === 0)
+ *          // => 4
+ */
+declare function findLast<T>(items: T[], predicate: (item: T) => boolean): T | undefined;
+/**
+ * Drops the first n elements from the array.
+ *
+ * @example drop([1, 2, 3, 4, 5], 2)
+ *          // => [3, 4, 5]
+ */
+declare function drop<T>(items: T[], n?: number): T[];
+/**
+ * Drops the last n elements from the array.
+ *
+ * @example dropRight([1, 2, 3, 4, 5], 2)
+ *          // => [1, 2, 3]
+ */
+declare function dropRight<T>(items: T[], n?: number): T[];
+/**
+ * Takes the first n elements from the array.
+ *
+ * @example take([1, 2, 3, 4, 5], 2)
+ *          // => [1, 2]
+ */
+declare function take<T>(items: T[], n?: number): T[];
+/**
+ * Takes the last n elements from the array.
+ *
+ * @example takeRight([1, 2, 3, 4, 5], 2)
+ *          // => [4, 5]
+ */
+declare function takeRight<T>(items: T[], n?: number): T[];
+/**
+ * Removes specified values from the array (uses SameValueZero).
+ *
+ * @example without([1, 2, 1, 3, 1, 4], 1, 3)
+ *          // => [2, 4]
+ */
+declare function without<T>(items: T[], ...values: T[]): T[];
+/**
+ * Gets the element at the given index. Supports negative indexing.
+ *
+ * @example nth([1, 2, 3], 1)   // => 2
+ * @example nth([1, 2, 3], -1)  // => 3
+ */
+declare function nth<T>(items: T[], index: number): T | undefined;
+
+export { type SortDirection, chunk, compact, countBy, deepGet, deepSet, difference, drop, dropRight, findIndex, findLast, first, flatten, groupBy, intersection, isEmpty, keyBy, last, maxBy, minBy, nth, omit, orderBy, partition, pick, pluck, sample, sampleSize, shuffle, slidingWindows, sortBy, sumBy, take, takeRight, topoSort, tumblingWindows, union, uniq, uniqueBy, unzip, without, zip };