speexjs-core 0.7.0

package/dist/collection/index.js

@@ -0,0 +1,375 @@
+// src/collection/index.ts
+function groupBy(items, keyFn) {
+  const result = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    if (!result[key]) result[key] = [];
+    result[key].push(item);
+  }
+  return result;
+}
+function keyBy(items, keyFn) {
+  const result = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    result[key] = item;
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function pluck(items, key) {
+  return items.map((item) => item[key]);
+}
+function shuffle(items) {
+  const result = [...items];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = result[i];
+    result[i] = result[j];
+    result[j] = temp;
+  }
+  return result;
+}
+function sample(items) {
+  return items.length > 0 ? items[Math.floor(Math.random() * items.length)] : void 0;
+}
+function sampleSize(items, size) {
+  if (size <= 0 || items.length === 0) return [];
+  const pool = shuffle(items);
+  return pool.slice(0, Math.min(size, items.length));
+}
+function chunk(items, size) {
+  if (size <= 0 || items.length === 0) return [];
+  const result = [];
+  for (let i = 0; i < items.length; i += size) {
+    result.push(items.slice(i, i + size));
+  }
+  return result;
+}
+function compareValues(a, b) {
+  if (a === b) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : 1;
+  if (typeof a === "number" && typeof b === "number") return a < b ? -1 : 1;
+  return String(a) < String(b) ? -1 : 1;
+}
+function sortBy(items, ...criteria) {
+  return [...items].sort((a, b) => {
+    for (const criterion of criteria) {
+      const cmp = compareValues(criterion(a), criterion(b));
+      if (cmp !== 0) return cmp;
+    }
+    return 0;
+  });
+}
+function orderBy(items, key, direction = "asc") {
+  return [...items].sort((a, b) => {
+    const cmp = compareValues(key(a), key(b));
+    return direction === "asc" ? cmp : -cmp;
+  });
+}
+function uniqueBy(items, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function flatten(items) {
+  const result = [];
+  for (const sub of items) {
+    for (const item of sub) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function first(items) {
+  return items[0];
+}
+function last(items) {
+  return items[items.length - 1];
+}
+function isEmpty(value) {
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "string") return value.length === 0;
+  if (value instanceof Map || value instanceof Set) return value.size === 0;
+  if (value !== null && typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function topoSort(items) {
+  const adj = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  const itemMap = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    itemMap.set(item.id, item);
+    if (!adj.has(item.id)) adj.set(item.id, []);
+    if (!inDegree.has(item.id)) inDegree.set(item.id, 0);
+  }
+  for (const item of items) {
+    if (item.dependencies) {
+      for (const depId of item.dependencies) {
+        adj.get(depId)?.push(item.id);
+        inDegree.set(item.id, (inDegree.get(item.id) ?? 0) + 1);
+      }
+    }
+  }
+  const queue = [];
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) queue.push(id);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    sorted.push(id);
+    for (const neighbor of adj.get(id) ?? []) {
+      const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) queue.push(neighbor);
+    }
+  }
+  if (sorted.length !== items.length) {
+    throw new Error("Circular dependency detected");
+  }
+  return sorted.map((id) => itemMap.get(id));
+}
+function slidingWindows(items, size, step = 1) {
+  if (size <= 0 || items.length === 0 || step <= 0) return [];
+  const result = [];
+  for (let i = 0; i + size <= items.length; i += step) {
+    result.push(items.slice(i, i + size));
+  }
+  return result;
+}
+function tumblingWindows(items, size) {
+  if (size <= 0 || items.length === 0) return [];
+  const result = [];
+  for (let i = 0; i < items.length; i += size) {
+    result.push(items.slice(i, i + size));
+  }
+  return result;
+}
+function deepGet(obj, path, default_) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) return default_;
+    if (typeof current !== "object") return default_;
+    const curObj = current;
+    if (!(key in curObj)) return default_;
+    current = curObj[key];
+  }
+  return current ?? default_;
+}
+function deepSet(obj, path, value) {
+  const keys = path.split(".");
+  const PROTO_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  for (const key of keys) {
+    if (PROTO_KEYS.has(key)) {
+      return { ...obj };
+    }
+  }
+  const result = { ...obj };
+  let current = result;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    const next = current[key];
+    if (next === null || next === void 0 || typeof next !== "object") {
+      const isArray = /^\d+$/.test(keys[i + 1]);
+      current[key] = isArray ? [] : {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return result;
+}
+function partition(items, predicate) {
+  const pass = [];
+  const fail = [];
+  for (const item of items) {
+    if (predicate(item)) pass.push(item);
+    else fail.push(item);
+  }
+  return [pass, fail];
+}
+function compact(items) {
+  return items.filter(Boolean);
+}
+function difference(a, b) {
+  const setB = new Set(b);
+  return a.filter((item) => !setB.has(item));
+}
+function intersection(a, b) {
+  const setB = new Set(b);
+  return a.filter((item) => setB.has(item));
+}
+function union(...arrays) {
+  const set = /* @__PURE__ */ new Set();
+  for (const arr of arrays) {
+    for (const item of arr) {
+      set.add(item);
+    }
+  }
+  return [...set];
+}
+function zip(...arrays) {
+  if (arrays.length === 0) return [];
+  const minLen = Math.min(...arrays.map((a) => a.length));
+  const result = [];
+  for (let i = 0; i < minLen; i++) {
+    const tuple = [];
+    for (const arr of arrays) {
+      tuple.push(arr[i]);
+    }
+    result.push(tuple);
+  }
+  return result;
+}
+function unzip(paired) {
+  if (paired.length === 0) return [];
+  const tupleLen = paired.reduce((max, t) => Math.max(max, t.length), 0);
+  const result = Array.from({ length: tupleLen }, () => []);
+  for (const tuple of paired) {
+    for (let i = 0; i < tupleLen; i++) {
+      result[i].push(tuple[i]);
+    }
+  }
+  return result;
+}
+function countBy(items, keyFn) {
+  const result = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
+}
+function maxBy(items, keyFn) {
+  if (items.length === 0) return void 0;
+  let maxItem = items[0];
+  let maxVal = keyFn(maxItem);
+  for (let i = 1; i < items.length; i++) {
+    const val = keyFn(items[i]);
+    if (val > maxVal) {
+      maxVal = val;
+      maxItem = items[i];
+    }
+  }
+  return maxItem;
+}
+function minBy(items, keyFn) {
+  if (items.length === 0) return void 0;
+  let minItem = items[0];
+  let minVal = keyFn(minItem);
+  for (let i = 1; i < items.length; i++) {
+    const val = keyFn(items[i]);
+    if (val < minVal) {
+      minVal = val;
+      minItem = items[i];
+    }
+  }
+  return minItem;
+}
+function sumBy(items, keyFn) {
+  let total = 0;
+  for (const item of items) {
+    total += keyFn(item);
+  }
+  return total;
+}
+function findIndex(items, predicate, fromIndex = 0) {
+  for (let i = fromIndex; i < items.length; i++) {
+    if (predicate(items[i])) return i;
+  }
+  return -1;
+}
+function findLast(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (predicate(items[i])) return items[i];
+  }
+  return void 0;
+}
+function drop(items, n = 1) {
+  return items.slice(Math.max(0, n));
+}
+function dropRight(items, n = 1) {
+  return items.slice(0, Math.max(0, items.length - n));
+}
+function take(items, n = 1) {
+  return items.slice(0, Math.max(0, n));
+}
+function takeRight(items, n = 1) {
+  return items.slice(Math.max(0, items.length - n));
+}
+function without(items, ...values) {
+  const exclude = new Set(values);
+  return items.filter((item) => !exclude.has(item));
+}
+function nth(items, index) {
+  return index < 0 ? items[items.length + index] : items[index];
+}
+export {
+  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
+};
+//# sourceMappingURL=index.js.map

package/dist/collection/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/collection/index.ts"],"sourcesContent":["/**\r\n * Groups an array of items by a key extracted from each item.\r\n *\r\n * @example groupBy([{ type: 'a' }, { type: 'b' }, { type: 'a' }], x => x.type)\r\n *          // => { a: [{ type: 'a' }, { type: 'a' }], b: [{ type: 'b' }] }\r\n */\r\nexport function groupBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, T[]> {\r\n  const result = {} as Record<K, T[]>\r\n  for (const item of items) {\r\n    const key = keyFn(item)\r\n    if (!result[key]) result[key] = []\r\n    result[key]!.push(item)\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Creates an object keyed by the result of keyFn for each item.\r\n *\r\n * @example keyBy([{ id: 1, name: 'a' }, { id: 2, name: 'b' }], x => x.id)\r\n *          // => { 1: { id: 1, name: 'a' }, 2: { id: 2, name: 'b' } }\r\n */\r\nexport function keyBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, T> {\r\n  const result = {} as Record<K, T>\r\n  for (const item of items) {\r\n    const key = keyFn(item)\r\n    result[key] = item\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Returns a copy of the object with the specified keys omitted.\r\n */\r\nexport function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\r\n  const result = { ...obj } as T\r\n  for (const key of keys) {\r\n    delete result[key]\r\n  }\r\n  return result as Omit<T, K>\r\n}\r\n\r\n/**\r\n * Returns a copy of the object with only the specified keys.\r\n */\r\nexport function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\r\n  const result = {} as Pick<T, K>\r\n  for (const key of keys) {\r\n    if (key in obj) {\r\n      result[key] = obj[key]\r\n    }\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Extracts a property value from each item in an array.\r\n */\r\nexport function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {\r\n  return items.map(item => item[key])\r\n}\r\n\r\n/**\r\n * Randomizes array order in-place using the Fisher-Yates algorithm.\r\n */\r\nexport function shuffle<T>(items: T[]): T[] {\r\n  const result = [...items]\r\n  for (let i = result.length - 1; i > 0; i--) {\r\n    const j = Math.floor(Math.random() * (i + 1))\r\n    const temp = result[i]!\r\n    result[i] = result[j]!\r\n    result[j] = temp\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Returns a random element from the array, or undefined if empty.\r\n */\r\nexport function sample<T>(items: T[]): T | undefined {\r\n  return items.length > 0 ? items[Math.floor(Math.random() * items.length)] : undefined\r\n}\r\n\r\n/**\r\n * Returns an array of `size` random elements (without duplicates).\r\n */\r\nexport function sampleSize<T>(items: T[], size: number): T[] {\r\n  if (size <= 0 || items.length === 0) return []\r\n  const pool = shuffle(items)\r\n  return pool.slice(0, Math.min(size, items.length))\r\n}\r\n\r\n/**\r\n * Splits an array into chunks of the specified size.\r\n */\r\nexport function chunk<T>(items: T[], size: number): T[][] {\r\n  if (size <= 0 || items.length === 0) return []\r\n  const result: T[][] = []\r\n  for (let i = 0; i < items.length; i += size) {\r\n    result.push(items.slice(i, i + size))\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Returns a sorted copy of the array using the provided criteria functions.\r\n * Earlier criteria take precedence.\r\n */\r\nfunction compareValues(a: unknown, b: unknown): number {\r\n  if (a === b) return 0\r\n  if (a == null) return -1\r\n  if (b == null) return 1\r\n  if (typeof a === 'string' && typeof b === 'string') return a < b ? -1 : 1\r\n  if (typeof a === 'number' && typeof b === 'number') return a < b ? -1 : 1\r\n  return String(a) < String(b) ? -1 : 1\r\n}\r\n\r\nexport function sortBy<T>(items: T[], ...criteria: Array<(item: T) => unknown>): T[] {\r\n  return [...items].sort((a, b) => {\r\n    for (const criterion of criteria) {\r\n      const cmp = compareValues(criterion(a), criterion(b))\r\n      if (cmp !== 0) return cmp\r\n    }\r\n    return 0\r\n  })\r\n}\r\n\r\n/**\r\n * Returns a sorted copy of the array by a single key and direction.\r\n */\r\nexport function orderBy<T>(items: T[], key: (item: T) => unknown, direction: SortDirection = 'asc'): T[] {\r\n  return [...items].sort((a, b) => {\r\n    const cmp = compareValues(key(a), key(b))\r\n    return direction === 'asc' ? cmp : -cmp\r\n  })\r\n}\r\n\r\n/**\r\n * Returns unique elements based on the result of keyFn.\r\n */\r\nexport function uniqueBy<T>(items: T[], keyFn: (item: T) => unknown): T[] {\r\n  const seen = new Set<unknown>()\r\n  return items.filter(item => {\r\n    const key = keyFn(item)\r\n    if (seen.has(key)) return false\r\n    seen.add(key)\r\n    return true\r\n  })\r\n}\r\n\r\n/**\r\n * Flattens an array of arrays one level.\r\n */\r\nexport function flatten<T>(items: T[][]): T[] {\r\n  const result: T[] = []\r\n  for (const sub of items) {\r\n    for (const item of sub) {\r\n      result.push(item)\r\n    }\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Returns an array with unique primitive values.\r\n */\r\nexport function uniq<T>(items: T[]): T[] {\r\n  return [...new Set(items)]\r\n}\r\n\r\n/**\r\n * Returns the first element, or undefined if empty.\r\n */\r\nexport function first<T>(items: T[]): T | undefined {\r\n  return items[0]\r\n}\r\n\r\n/**\r\n * Returns the last element, or undefined if empty.\r\n */\r\nexport function last<T>(items: T[]): T | undefined {\r\n  return items[items.length - 1]\r\n}\r\n\r\n/**\r\n * Checks if a value is empty.\r\n * Works for arrays, objects, strings, Map, and Set.\r\n */\r\nexport function isEmpty(value: unknown): boolean {\r\n  if (Array.isArray(value)) return value.length === 0\r\n  if (typeof value === 'string') return value.length === 0\r\n  if (value instanceof Map || value instanceof Set) return value.size === 0\r\n  if (value !== null && typeof value === 'object') return Object.keys(value as Record<string, unknown>).length === 0\r\n  return false\r\n}\r\n\r\nexport type SortDirection = 'asc' | 'desc'\r\n\r\nexport function topoSort<T extends { id: string; dependencies?: string[] }>(items: T[]): T[] {\r\n  const adj = new Map<string, string[]>()\r\n  const inDegree = new Map<string, number>()\r\n  const itemMap = new Map<string, T>()\r\n\r\n  for (const item of items) {\r\n    itemMap.set(item.id, item)\r\n    if (!adj.has(item.id)) adj.set(item.id, [])\r\n    if (!inDegree.has(item.id)) inDegree.set(item.id, 0)\r\n  }\r\n\r\n  for (const item of items) {\r\n    if (item.dependencies) {\r\n      for (const depId of item.dependencies) {\r\n        adj.get(depId)?.push(item.id)\r\n        inDegree.set(item.id, (inDegree.get(item.id) ?? 0) + 1)\r\n      }\r\n    }\r\n  }\r\n\r\n  const queue: string[] = []\r\n  for (const [id, degree] of inDegree) {\r\n    if (degree === 0) queue.push(id)\r\n  }\r\n\r\n  const sorted: string[] = []\r\n  while (queue.length > 0) {\r\n    const id = queue.shift()!\r\n    sorted.push(id)\r\n    for (const neighbor of adj.get(id) ?? []) {\r\n      const newDegree = (inDegree.get(neighbor) ?? 1) - 1\r\n      inDegree.set(neighbor, newDegree)\r\n      if (newDegree === 0) queue.push(neighbor)\r\n    }\r\n  }\r\n\r\n  if (sorted.length !== items.length) {\r\n    throw new Error('Circular dependency detected')\r\n  }\r\n\r\n  return sorted.map(id => itemMap.get(id)!)\r\n}\r\n\r\nexport function slidingWindows<T>(items: T[], size: number, step: number = 1): T[][] {\r\n  if (size <= 0 || items.length === 0 || step <= 0) return []\r\n  const result: T[][] = []\r\n  for (let i = 0; i + size <= items.length; i += step) {\r\n    result.push(items.slice(i, i + size))\r\n  }\r\n  return result\r\n}\r\n\r\nexport function tumblingWindows<T>(items: T[], size: number): T[][] {\r\n  if (size <= 0 || items.length === 0) return []\r\n  const result: T[][] = []\r\n  for (let i = 0; i < items.length; i += size) {\r\n    result.push(items.slice(i, i + size))\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Gets a nested value from an object using a dot-separated path.\r\n *\r\n * @example deepGet({ a: { b: 2 } }, 'a.b') // 2\r\n * @example deepGet({ a: { b: 2 } }, 'a.c') // undefined\r\n */\r\nexport function deepGet<T = unknown>(obj: unknown, path: string, default_?: T): T | undefined {\r\n  const keys = path.split('.')\r\n  let current: unknown = obj\r\n  for (const key of keys) {\r\n    if (current === null || current === undefined) return default_\r\n    if (typeof current !== 'object') return default_\r\n    const curObj = current as Record<string, unknown>\r\n    if (!(key in curObj)) return default_\r\n    current = curObj[key]\r\n  }\r\n  return (current as T) ?? default_\r\n}\r\n\r\n/**\r\n * Sets a nested value in an object using a dot-separated path.\r\n * Creates intermediate objects/arrays as needed.\r\n *\r\n * @example deepSet({ a: { b: 2 } }, 'a.b', 3) // { a: { b: 3 } }\r\n * @example deepSet({}, 'a.b.c', 1) // { a: { b: { c: 1 } } }\r\n */\r\nexport function deepSet<T extends Record<string, unknown>>(obj: T, path: string, value: unknown): T {\r\n  const keys = path.split('.')\r\n  const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype'])\r\n  for (const key of keys) {\r\n    if (PROTO_KEYS.has(key)) {\r\n      return { ...obj } as T\r\n    }\r\n  }\r\n  const result = { ...obj } as Record<string, unknown>\r\n  let current = result\r\n  for (let i = 0; i < keys.length - 1; i++) {\r\n    const key = keys[i]!\r\n    const next = current[key]\r\n    if (next === null || next === undefined || typeof next !== 'object') {\r\n      const isArray = /^\\d+$/.test(keys[i + 1]!)\r\n      current[key] = isArray ? [] : {}\r\n    }\r\n    current = current[key] as Record<string, unknown>\r\n  }\r\n  current[keys[keys.length - 1]!] = value\r\n  return result as T\r\n}\r\n\r\n/**\r\n * Splits an array into two groups: those that pass the predicate and those that don't.\r\n *\r\n * @example partition([1, 2, 3, 4, 5], n => n % 2 === 0)\r\n *          // => [[2, 4], [1, 3, 5]]\r\n */\r\nexport function partition<T>(items: T[], predicate: (item: T) => boolean): [T[], T[]] {\r\n  const pass: T[] = []\r\n  const fail: T[] = []\r\n  for (const item of items) {\r\n    if (predicate(item)) pass.push(item)\r\n    else fail.push(item)\r\n  }\r\n  return [pass, fail]\r\n}\r\n\r\n/**\r\n * Removes all falsy values from an array (false, null, 0, '', undefined, NaN).\r\n *\r\n * @example compact([0, 1, false, 2, '', 3, null, undefined, NaN])\r\n *          // => [1, 2, 3]\r\n */\r\nexport function compact<T>(items: (T | false | null | 0 | '' | undefined)[]): T[] {\r\n  return items.filter(Boolean) as T[]\r\n}\r\n\r\n/**\r\n * Returns elements in array A that are not in array B (uses SameValueZero).\r\n *\r\n * @example difference([1, 2, 3, 4], [2, 4])\r\n *          // => [1, 3]\r\n */\r\nexport function difference<T>(a: T[], b: T[]): T[] {\r\n  const setB = new Set(b)\r\n  return a.filter(item => !setB.has(item))\r\n}\r\n\r\n/**\r\n * Returns elements present in all given arrays (uses SameValueZero).\r\n *\r\n * @example intersection([1, 2, 3], [2, 3, 4])\r\n *          // => [2, 3]\r\n */\r\nexport function intersection<T>(a: T[], b: T[]): T[] {\r\n  const setB = new Set(b)\r\n  return a.filter(item => setB.has(item))\r\n}\r\n\r\n/**\r\n * Returns unique elements from all given arrays.\r\n *\r\n * @example union([1, 2], [2, 3], [3, 4])\r\n *          // => [1, 2, 3, 4]\r\n */\r\nexport function union<T>(...arrays: T[][]): T[] {\r\n  const set = new Set<T>()\r\n  for (const arr of arrays) {\r\n    for (const item of arr) {\r\n      set.add(item)\r\n    }\r\n  }\r\n  return [...set]\r\n}\r\n\r\n/**\r\n * Merges arrays element-wise into tuples, stopping at the shortest array.\r\n *\r\n * @example zip(['a', 'b', 'c'], [1, 2])\r\n *          // => [['a', 1], ['b', 2]]\r\n */\r\nexport function zip<T, U>(a: T[], b: U[]): [T, U][]\r\nexport function zip<T, U, V>(a: T[], b: U[], c: V[]): [T, U, V][]\r\nexport function zip<T>(...arrays: T[][]): T[][] {\r\n  if (arrays.length === 0) return []\r\n  const minLen = Math.min(...arrays.map(a => a.length))\r\n  const result: T[][] = []\r\n  for (let i = 0; i < minLen; i++) {\r\n    const tuple: T[] = []\r\n    for (const arr of arrays) {\r\n      tuple.push(arr[i]!)\r\n    }\r\n    result.push(tuple)\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Inverse of zip: splits an array of tuples back into individual arrays.\r\n *\r\n * @example unzip([['a', 1], ['b', 2]])\r\n *          // => [['a', 'b'], [1, 2]]\r\n */\r\nexport function unzip<T>(paired: T[][]): T[][] {\r\n  if (paired.length === 0) return []\r\n  const tupleLen = paired.reduce((max, t) => Math.max(max, t.length), 0)\r\n  const result: T[][] = Array.from({ length: tupleLen }, () => [])\r\n  for (const tuple of paired) {\r\n    for (let i = 0; i < tupleLen; i++) {\r\n      result[i]!.push(tuple[i] as T)\r\n    }\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Counts occurrences of each key produced by the key function.\r\n *\r\n * @example countBy([1, 2, 3, 4, 5], n => n % 2 === 0 ? 'even' : 'odd')\r\n *          // => { odd: 3, even: 2 }\r\n */\r\nexport function countBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, number> {\r\n  const result = {} as Record<K, number>\r\n  for (const item of items) {\r\n    const key = keyFn(item)\r\n    result[key] = (result[key] ?? 0) + 1\r\n  }\r\n  return result\r\n}\r\n\r\n/**\r\n * Returns the element with the maximum value by the key function.\r\n *\r\n * @example maxBy([{ name: 'a', score: 10 }, { name: 'b', score: 20 }], x => x.score)\r\n *          // => { name: 'b', score: 20 }\r\n */\r\nexport function maxBy<T>(items: T[], keyFn: (item: T) => number): T | undefined {\r\n  if (items.length === 0) return undefined\r\n  let maxItem = items[0]!\r\n  let maxVal = keyFn(maxItem)\r\n  for (let i = 1; i < items.length; i++) {\r\n    const val = keyFn(items[i]!)\r\n    if (val > maxVal) {\r\n      maxVal = val\r\n      maxItem = items[i]!\r\n    }\r\n  }\r\n  return maxItem\r\n}\r\n\r\n/**\r\n * Returns the element with the minimum value by the key function.\r\n *\r\n * @example minBy([{ name: 'a', score: 10 }, { name: 'b', score: 20 }], x => x.score)\r\n *          // => { name: 'a', score: 10 }\r\n */\r\nexport function minBy<T>(items: T[], keyFn: (item: T) => number): T | undefined {\r\n  if (items.length === 0) return undefined\r\n  let minItem = items[0]!\r\n  let minVal = keyFn(minItem)\r\n  for (let i = 1; i < items.length; i++) {\r\n    const val = keyFn(items[i]!)\r\n    if (val < minVal) {\r\n      minVal = val\r\n      minItem = items[i]!\r\n    }\r\n  }\r\n  return minItem\r\n}\r\n\r\n/**\r\n * Returns the sum of values produced by the key function.\r\n *\r\n * @example sumBy([{ n: 1 }, { n: 2 }, { n: 3 }], x => x.n)\r\n *          // => 6\r\n */\r\nexport function sumBy<T>(items: T[], keyFn: (item: T) => number): number {\r\n  let total = 0\r\n  for (const item of items) {\r\n    total += keyFn(item)\r\n  }\r\n  return total\r\n}\r\n\r\n/**\r\n * Returns the index of the first element satisfying the predicate, or -1.\r\n *\r\n * @example findIndex([1, 3, 5, 8, 10], n => n % 2 === 0)\r\n *          // => 3\r\n */\r\nexport function findIndex<T>(items: T[], predicate: (item: T) => boolean, fromIndex: number = 0): number {\r\n  for (let i = fromIndex; i < items.length; i++) {\r\n    if (predicate(items[i]!)) return i\r\n  }\r\n  return -1\r\n}\r\n\r\n/**\r\n * Finds the last element satisfying the predicate.\r\n *\r\n * @example findLast([1, 2, 3, 4, 5], n => n % 2 === 0)\r\n *          // => 4\r\n */\r\nexport function findLast<T>(items: T[], predicate: (item: T) => boolean): T | undefined {\r\n  for (let i = items.length - 1; i >= 0; i--) {\r\n    if (predicate(items[i]!)) return items[i]\r\n  }\r\n  return undefined\r\n}\r\n\r\n/**\r\n * Drops the first n elements from the array.\r\n *\r\n * @example drop([1, 2, 3, 4, 5], 2)\r\n *          // => [3, 4, 5]\r\n */\r\nexport function drop<T>(items: T[], n: number = 1): T[] {\r\n  return items.slice(Math.max(0, n))\r\n}\r\n\r\n/**\r\n * Drops the last n elements from the array.\r\n *\r\n * @example dropRight([1, 2, 3, 4, 5], 2)\r\n *          // => [1, 2, 3]\r\n */\r\nexport function dropRight<T>(items: T[], n: number = 1): T[] {\r\n  return items.slice(0, Math.max(0, items.length - n))\r\n}\r\n\r\n/**\r\n * Takes the first n elements from the array.\r\n *\r\n * @example take([1, 2, 3, 4, 5], 2)\r\n *          // => [1, 2]\r\n */\r\nexport function take<T>(items: T[], n: number = 1): T[] {\r\n  return items.slice(0, Math.max(0, n))\r\n}\r\n\r\n/**\r\n * Takes the last n elements from the array.\r\n *\r\n * @example takeRight([1, 2, 3, 4, 5], 2)\r\n *          // => [4, 5]\r\n */\r\nexport function takeRight<T>(items: T[], n: number = 1): T[] {\r\n  return items.slice(Math.max(0, items.length - n))\r\n}\r\n\r\n/**\r\n * Removes specified values from the array (uses SameValueZero).\r\n *\r\n * @example without([1, 2, 1, 3, 1, 4], 1, 3)\r\n *          // => [2, 4]\r\n */\r\nexport function without<T>(items: T[], ...values: T[]): T[] {\r\n  const exclude = new Set(values)\r\n  return items.filter(item => !exclude.has(item))\r\n}\r\n\r\n/**\r\n * Gets the element at the given index. Supports negative indexing.\r\n *\r\n * @example nth([1, 2, 3], 1)   // => 2\r\n * @example nth([1, 2, 3], -1)  // => 3\r\n */\r\nexport function nth<T>(items: T[], index: number): T | undefined {\r\n  return index < 0 ? items[items.length + index] : items[index]\r\n}\r\n"],"mappings":"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","names":[]}

package/dist/color/index.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Converts a hex color string to RGB values.
+ *
+ * @example hexToRgb('#ff0000') // { r: 255, g: 0, b: 0 }
+ * @example hexToRgb('#f00')   // { r: 255, g: 0, b: 0 }
+ * @example hexToRgb('#FF8800') // { r: 255, g: 136, b: 0 }
+ */
+declare function hexToRgb(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+} | null;
+/**
+ * Converts RGB values to a hex color string.
+ *
+ * @example rgbToHex(255, 0, 0) // "#ff0000"
+ * @example rgbToHex(255, 136, 0) // "#ff8800"
+ */
+declare function rgbToHex(r: number, g: number, b: number): string;
+/**
+ * Lightens a hex color by a given percentage (0-100).
+ *
+ * @example lighten('#ff0000', 20) // "#ff3333"
+ * @example lighten('#0000ff', 50) // "#7f7fff"
+ */
+declare function lighten(hex: string, percent: number): string;
+/**
+ * Darkens a hex color by a given percentage (0-100).
+ *
+ * @example darken('#ff0000', 20) // "#cc0000"
+ * @example darken('#00ff00', 50) // "#008000"
+ */
+declare function darken(hex: string, percent: number): string;
+/**
+ * Checks the WCAG contrast ratio between two hex colors.
+ * Returns the ratio as a number (1-21). WCAG AA requires 4.5:1 for normal text.
+ *
+ * @example contrastRatio('#000000', '#ffffff') // 21
+ * @example contrastRatio('#ff0000', '#ffffff') // 3.99
+ */
+declare function contrastRatio(hex1: string, hex2: string): number;
+/**
+ * Checks if a hex color meets WCAG AA contrast ratio (4.5:1) against another color.
+ *
+ * @example meetsWCAG('#000000', '#ffffff') // true (black on white)
+ * @example meetsWCAG('#999999', '#ffffff') // false (gray on white)
+ */
+declare function meetsWCAG(hex1: string, hex2: string, level?: 'AA' | 'AAA'): boolean;
+/**
+ * Checks if a string is a valid hex color.
+ * Supports 3-digit (#rgb), 6-digit (#rrggbb), with or without leading `#`.
+ *
+ * @example isValidHex('#ff0000') // true
+ * @example isValidHex('#f00')    // true
+ * @example isValidHex('ff0000')  // true
+ * @example isValidHex('#xyz')    // false
+ */
+declare function isValidHex(value: string): boolean;
+/**
+ * Converts a hex color to an HSL object.
+ * Returns `null` for invalid input.
+ *
+ * @example hexToHsl('#ff0000') // { h: 0, s: 100, l: 50 }
+ * @example hexToHsl('#00ff00') // { h: 120, s: 100, l: 50 }
+ * @example hexToHsl('#0000ff') // { h: 240, s: 100, l: 50 }
+ */
+declare function hexToHsl(hex: string): {
+    h: number;
+    s: number;
+    l: number;
+} | null;
+/**
+ * Converts HSL values to a hex color string.
+ *
+ * @example hslToHex(0, 100, 50)   // '#ff0000'
+ * @example hslToHex(120, 100, 50) // '#00ff00'
+ * @example hslToHex(240, 100, 50) // '#0000ff'
+ */
+declare function hslToHex(h: number, s: number, l: number): string;
+/**
+ * Blends two hex colors together with a weight factor.
+ * Weight 0 = fully color1, weight 1 = fully color2. Default 0.5.
+ *
+ * @example mix('#ff0000', '#0000ff')    // '#7f007f'
+ * @example mix('#ff0000', '#0000ff', 0) // '#ff0000'
+ * @example mix('#ff0000', '#0000ff', 1) // '#0000ff'
+ */
+declare function mix(color1: string, color2: string, weight?: number): string;
+/**
+ * Generates a random hex color.
+ *
+ * @example randomColor() // '#a3f07b'
+ */
+declare function randomColor(): string;
+/**
+ * Checks if a hex color is perceived as light (useful for text contrast decisions).
+ *
+ * @example isLight('#ffffff') // true
+ * @example isLight('#000000') // false
+ * @example isLight('#ff0000') // false
+ */
+declare function isLight(hex: string): boolean;
+/**
+ * Checks if a hex color is perceived as dark.
+ *
+ * @example isDark('#000000') // true
+ * @example isDark('#ffffff') // false
+ */
+declare function isDark(hex: string): boolean;
+/**
+ * Returns the complementary color (180° hue rotation).
+ *
+ * @example complementary('#ff0000') // '#00ffff'
+ * @example complementary('#00ff00') // '#ff00ff'
+ * @example complementary('#0000ff') // '#ffff00'
+ */
+declare function complementary(hex: string): string;
+/**
+ * Sets opacity on a hex color, returning an 8-digit hex (#rrggbbaa).
+ * Opacity is clamped to 0-1.
+ *
+ * @example alpha('#ff0000', 0.5) // '#ff000080'
+ * @example alpha('#00ff00', 1)   // '#00ff00ff'
+ * @example alpha('#0000ff', 0)   // '#0000ff00'
+ */
+declare function alpha(hex: string, opacity: number): string;
+
+export { alpha, complementary, contrastRatio, darken, hexToHsl, hexToRgb, hslToHex, isDark, isLight, isValidHex, lighten, meetsWCAG, mix, randomColor, rgbToHex };