speexjs-core 0.7.0

package/dist/color/index.js

@@ -0,0 +1,167 @@
+// src/color/index.ts
+function hexToRgb(hex) {
+  let h = hex.replace("#", "");
+  if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+  if (h.length !== 6) return null;
+  const num = Number.parseInt(h, 16);
+  if (isNaN(num)) return null;
+  return {
+    r: num >> 16 & 255,
+    g: num >> 8 & 255,
+    b: num & 255
+  };
+}
+function rgbToHex(r, g, b) {
+  const toHex = (n) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0");
+  return "#" + toHex(r) + toHex(g) + toHex(b);
+}
+function lighten(hex, percent) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  const factor = percent / 100;
+  return rgbToHex(
+    rgb.r + (255 - rgb.r) * factor,
+    rgb.g + (255 - rgb.g) * factor,
+    rgb.b + (255 - rgb.b) * factor
+  );
+}
+function darken(hex, percent) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  const factor = percent / 100;
+  return rgbToHex(
+    rgb.r * (1 - factor),
+    rgb.g * (1 - factor),
+    rgb.b * (1 - factor)
+  );
+}
+function contrastRatio(hex1, hex2) {
+  const lum1 = relativeLuminance(hex1);
+  const lum2 = relativeLuminance(hex2);
+  const lighter = Math.max(lum1, lum2);
+  const darker = Math.min(lum1, lum2);
+  return Number(((lighter + 0.05) / (darker + 0.05)).toFixed(2));
+}
+function relativeLuminance(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return 0;
+  const vals = [rgb.r / 255, rgb.g / 255, rgb.b / 255].map((c) => {
+    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * vals[0] + 0.7152 * vals[1] + 0.0722 * vals[2];
+}
+function meetsWCAG(hex1, hex2, level) {
+  const ratio = contrastRatio(hex1, hex2);
+  const threshold = level === "AAA" ? 7 : 4.5;
+  return ratio >= threshold;
+}
+function isValidHex(value) {
+  return /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value);
+}
+function hexToHsl(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return null;
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) return { h: 0, s: 0, l: Math.round(l * 100) };
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h = 0;
+  switch (max) {
+    case r:
+      h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+      break;
+    case g:
+      h = ((b - r) / d + 2) / 6;
+      break;
+    case b:
+      h = ((r - g) / d + 4) / 6;
+      break;
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToHex(h, s, l) {
+  const hue = h / 360;
+  const sat = s / 100;
+  const lig = l / 100;
+  if (sat === 0) {
+    const val = Math.round(lig * 255);
+    return rgbToHex(val, val, val);
+  }
+  const hue2rgb = (p2, q2, t) => {
+    let tt = t;
+    if (tt < 0) tt += 1;
+    if (tt > 1) tt -= 1;
+    if (tt < 1 / 6) return p2 + (q2 - p2) * 6 * tt;
+    if (tt < 1 / 2) return q2;
+    if (tt < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - tt) * 6;
+    return p2;
+  };
+  const q = lig < 0.5 ? lig * (1 + sat) : lig + sat - lig * sat;
+  const p = 2 * lig - q;
+  return rgbToHex(
+    Math.round(hue2rgb(p, q, hue + 1 / 3) * 255),
+    Math.round(hue2rgb(p, q, hue) * 255),
+    Math.round(hue2rgb(p, q, hue - 1 / 3) * 255)
+  );
+}
+function mix(color1, color2, weight = 0.5) {
+  const rgb1 = hexToRgb(color1);
+  const rgb2 = hexToRgb(color2);
+  if (!rgb1 || !rgb2) return color1;
+  const w = Math.max(0, Math.min(1, weight));
+  const lerp = (a, b) => Math.floor(a + (b - a) * w);
+  return rgbToHex(lerp(rgb1.r, rgb2.r), lerp(rgb1.g, rgb2.g), lerp(rgb1.b, rgb2.b));
+}
+function randomColor() {
+  const r = Math.floor(Math.random() * 256);
+  const g = Math.floor(Math.random() * 256);
+  const b = Math.floor(Math.random() * 256);
+  return rgbToHex(r, g, b);
+}
+function isLight(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return false;
+  return (0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b) / 255 > 0.5;
+}
+function isDark(hex) {
+  return !isLight(hex);
+}
+function complementary(hex) {
+  const hsl = hexToHsl(hex);
+  if (!hsl) return hex;
+  return hslToHex((hsl.h + 180) % 360, hsl.s, hsl.l);
+}
+function alpha(hex, opacity) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  const a = Math.max(0, Math.min(1, opacity));
+  const alphaHex = Math.round(a * 255).toString(16).padStart(2, "0");
+  return rgbToHex(rgb.r, rgb.g, rgb.b) + alphaHex;
+}
+export {
+  alpha,
+  complementary,
+  contrastRatio,
+  darken,
+  hexToHsl,
+  hexToRgb,
+  hslToHex,
+  isDark,
+  isLight,
+  isValidHex,
+  lighten,
+  meetsWCAG,
+  mix,
+  randomColor,
+  rgbToHex
+};
+//# sourceMappingURL=index.js.map

package/dist/color/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/color/index.ts"],"sourcesContent":["/**\n * Converts a hex color string to RGB values.\n *\n * @example hexToRgb('#ff0000') // { r: 255, g: 0, b: 0 }\n * @example hexToRgb('#f00')   // { r: 255, g: 0, b: 0 }\n * @example hexToRgb('#FF8800') // { r: 255, g: 136, b: 0 }\n */\nexport function hexToRgb(hex: string): { r: number; g: number; b: number } | null {\n  let h = hex.replace('#', '')\n  if (h.length === 3) h = h[0]! + h[0] + h[1]! + h[1] + h[2]! + h[2]\n  if (h.length !== 6) return null\n  const num = Number.parseInt(h, 16)\n  if (isNaN(num)) return null\n  return {\n    r: (num >> 16) & 255,\n    g: (num >> 8) & 255,\n    b: num & 255,\n  }\n}\n\n/**\n * Converts RGB values to a hex color string.\n *\n * @example rgbToHex(255, 0, 0) // \"#ff0000\"\n * @example rgbToHex(255, 136, 0) // \"#ff8800\"\n */\nexport function rgbToHex(r: number, g: number, b: number): string {\n  const toHex = (n: number) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, '0')\n  return '#' + toHex(r) + toHex(g) + toHex(b)\n}\n\n/**\n * Lightens a hex color by a given percentage (0-100).\n *\n * @example lighten('#ff0000', 20) // \"#ff3333\"\n * @example lighten('#0000ff', 50) // \"#7f7fff\"\n */\nexport function lighten(hex: string, percent: number): string {\n  const rgb = hexToRgb(hex)\n  if (!rgb) return hex\n  const factor = percent / 100\n  return rgbToHex(\n    rgb.r + (255 - rgb.r) * factor,\n    rgb.g + (255 - rgb.g) * factor,\n    rgb.b + (255 - rgb.b) * factor,\n  )\n}\n\n/**\n * Darkens a hex color by a given percentage (0-100).\n *\n * @example darken('#ff0000', 20) // \"#cc0000\"\n * @example darken('#00ff00', 50) // \"#008000\"\n */\nexport function darken(hex: string, percent: number): string {\n  const rgb = hexToRgb(hex)\n  if (!rgb) return hex\n  const factor = percent / 100\n  return rgbToHex(\n    rgb.r * (1 - factor),\n    rgb.g * (1 - factor),\n    rgb.b * (1 - factor),\n  )\n}\n\n/**\n * Checks the WCAG contrast ratio between two hex colors.\n * Returns the ratio as a number (1-21). WCAG AA requires 4.5:1 for normal text.\n *\n * @example contrastRatio('#000000', '#ffffff') // 21\n * @example contrastRatio('#ff0000', '#ffffff') // 3.99\n */\nexport function contrastRatio(hex1: string, hex2: string): number {\n  const lum1 = relativeLuminance(hex1)\n  const lum2 = relativeLuminance(hex2)\n  const lighter = Math.max(lum1, lum2)\n  const darker = Math.min(lum1, lum2)\n  return Number(((lighter + 0.05) / (darker + 0.05)).toFixed(2))\n}\n\nfunction relativeLuminance(hex: string): number {\n  const rgb = hexToRgb(hex)\n  if (!rgb) return 0\n  const vals = [rgb.r / 255, rgb.g / 255, rgb.b / 255].map((c) => {\n    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4)\n  })\n  return 0.2126 * vals[0]! + 0.7152 * vals[1]! + 0.0722 * vals[2]!\n}\n\n/**\n * Checks if a hex color meets WCAG AA contrast ratio (4.5:1) against another color.\n *\n * @example meetsWCAG('#000000', '#ffffff') // true (black on white)\n * @example meetsWCAG('#999999', '#ffffff') // false (gray on white)\n */\nexport function meetsWCAG(hex1: string, hex2: string, level?: 'AA' | 'AAA'): boolean {\n  const ratio = contrastRatio(hex1, hex2)\n  const threshold = level === 'AAA' ? 7 : 4.5\n  return ratio >= threshold\n}\n\n/**\n * Checks if a string is a valid hex color.\n * Supports 3-digit (#rgb), 6-digit (#rrggbb), with or without leading `#`.\n *\n * @example isValidHex('#ff0000') // true\n * @example isValidHex('#f00')    // true\n * @example isValidHex('ff0000')  // true\n * @example isValidHex('#xyz')    // false\n */\nexport function isValidHex(value: string): boolean {\n  return /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value)\n}\n\n/**\n * Converts a hex color to an HSL object.\n * Returns `null` for invalid input.\n *\n * @example hexToHsl('#ff0000') // { h: 0, s: 100, l: 50 }\n * @example hexToHsl('#00ff00') // { h: 120, s: 100, l: 50 }\n * @example hexToHsl('#0000ff') // { h: 240, s: 100, l: 50 }\n */\nexport function hexToHsl(hex: string): { h: number; s: number; l: number } | null {\n  const rgb = hexToRgb(hex)\n  if (!rgb) return null\n  const r = rgb.r / 255\n  const g = rgb.g / 255\n  const b = rgb.b / 255\n  const max = Math.max(r, g, b)\n  const min = Math.min(r, g, b)\n  const l = (max + min) / 2\n  if (max === min) return { h: 0, s: 0, l: Math.round(l * 100) }\n  const d = max - min\n  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min)\n  let h = 0\n  switch (max) {\n    case r: h = ((g - b) / d + (g < b ? 6 : 0)) / 6; break\n    case g: h = ((b - r) / d + 2) / 6; break\n    case b: h = ((r - g) / d + 4) / 6; break\n  }\n  return {\n    h: Math.round(h * 360),\n    s: Math.round(s * 100),\n    l: Math.round(l * 100),\n  }\n}\n\n/**\n * Converts HSL values to a hex color string.\n *\n * @example hslToHex(0, 100, 50)   // '#ff0000'\n * @example hslToHex(120, 100, 50) // '#00ff00'\n * @example hslToHex(240, 100, 50) // '#0000ff'\n */\nexport function hslToHex(h: number, s: number, l: number): string {\n  const hue = h / 360\n  const sat = s / 100\n  const lig = l / 100\n  if (sat === 0) {\n    const val = Math.round(lig * 255)\n    return rgbToHex(val, val, val)\n  }\n  const hue2rgb = (p: number, q: number, t: number): number => {\n    let tt = t\n    if (tt < 0) tt += 1\n    if (tt > 1) tt -= 1\n    if (tt < 1 / 6) return p + (q - p) * 6 * tt\n    if (tt < 1 / 2) return q\n    if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6\n    return p\n  }\n  const q = lig < 0.5 ? lig * (1 + sat) : lig + sat - lig * sat\n  const p = 2 * lig - q\n  return rgbToHex(\n    Math.round(hue2rgb(p, q, hue + 1 / 3) * 255),\n    Math.round(hue2rgb(p, q, hue) * 255),\n    Math.round(hue2rgb(p, q, hue - 1 / 3) * 255),\n  )\n}\n\n/**\n * Blends two hex colors together with a weight factor.\n * Weight 0 = fully color1, weight 1 = fully color2. Default 0.5.\n *\n * @example mix('#ff0000', '#0000ff')    // '#7f007f'\n * @example mix('#ff0000', '#0000ff', 0) // '#ff0000'\n * @example mix('#ff0000', '#0000ff', 1) // '#0000ff'\n */\nexport function mix(color1: string, color2: string, weight: number = 0.5): string {\n  const rgb1 = hexToRgb(color1)\n  const rgb2 = hexToRgb(color2)\n  if (!rgb1 || !rgb2) return color1\n  const w = Math.max(0, Math.min(1, weight))\n  const lerp = (a: number, b: number) => Math.floor(a + (b - a) * w)\n  return rgbToHex(lerp(rgb1.r, rgb2.r), lerp(rgb1.g, rgb2.g), lerp(rgb1.b, rgb2.b))\n}\n\n/**\n * Generates a random hex color.\n *\n * @example randomColor() // '#a3f07b'\n */\nexport function randomColor(): string {\n  const r = Math.floor(Math.random() * 256)\n  const g = Math.floor(Math.random() * 256)\n  const b = Math.floor(Math.random() * 256)\n  return rgbToHex(r, g, b)\n}\n\n/**\n * Checks if a hex color is perceived as light (useful for text contrast decisions).\n *\n * @example isLight('#ffffff') // true\n * @example isLight('#000000') // false\n * @example isLight('#ff0000') // false\n */\nexport function isLight(hex: string): boolean {\n  const rgb = hexToRgb(hex)\n  if (!rgb) return false\n  return (0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b) / 255 > 0.5\n}\n\n/**\n * Checks if a hex color is perceived as dark.\n *\n * @example isDark('#000000') // true\n * @example isDark('#ffffff') // false\n */\nexport function isDark(hex: string): boolean {\n  return !isLight(hex)\n}\n\n/**\n * Returns the complementary color (180° hue rotation).\n *\n * @example complementary('#ff0000') // '#00ffff'\n * @example complementary('#00ff00') // '#ff00ff'\n * @example complementary('#0000ff') // '#ffff00'\n */\nexport function complementary(hex: string): string {\n  const hsl = hexToHsl(hex)\n  if (!hsl) return hex\n  return hslToHex((hsl.h + 180) % 360, hsl.s, hsl.l)\n}\n\n/**\n * Sets opacity on a hex color, returning an 8-digit hex (#rrggbbaa).\n * Opacity is clamped to 0-1.\n *\n * @example alpha('#ff0000', 0.5) // '#ff000080'\n * @example alpha('#00ff00', 1)   // '#00ff00ff'\n * @example alpha('#0000ff', 0)   // '#0000ff00'\n */\nexport function alpha(hex: string, opacity: number): string {\n  const rgb = hexToRgb(hex)\n  if (!rgb) return hex\n  const a = Math.max(0, Math.min(1, opacity))\n  const alphaHex = Math.round(a * 255).toString(16).padStart(2, '0')\n  return rgbToHex(rgb.r, rgb.g, rgb.b) + alphaHex\n}\n"],"mappings":"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","names":["p","q"]}

package/dist/core/index.d.ts

@@ -0,0 +1,119 @@
+interface DebounceOptions {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}
+interface DebouncedFunction<T extends (...args: unknown[]) => unknown> {
+    (...args: Parameters<T>): void;
+    cancel(): void;
+    flush(): void;
+}
+interface MemoizedFunction<T extends (...args: unknown[]) => unknown> {
+    (...args: Parameters<T>): ReturnType<T>;
+    cache: Map<string, ReturnType<T>>;
+}
+interface RetryOptions {
+    attempts?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    shouldRetry?: (error: unknown) => boolean;
+}
+/**
+ * Deep clone a value, supporting objects, arrays, Date, RegExp, Map, Set,
+ * and cyclic references.
+ *
+ * @param value - The value to clone.
+ * @returns A deep copy of the input value.
+ */
+declare function deepClone<T>(value: T): T;
+/**
+ * Deep merge multiple objects. Arrays are overwritten, not concatenated.
+ * `null` and `undefined` source objects are skipped.
+ *
+ * @param objects - The objects to merge.
+ * @returns A new object with merged properties.
+ */
+declare function deepMerge<T extends Record<string, unknown>>(...objects: Partial<T>[]): T;
+/**
+ * Creates a debounced function that delays invoking `fn` until after `wait`
+ * milliseconds have elapsed since the last invocation. Supports leading,
+ * trailing, and maxWait options. The returned function also has `.cancel()`
+ * and `.flush()` methods.
+ *
+ * @param fn - The function to debounce.
+ * @param wait - The number of milliseconds to delay.
+ * @param options - Optional configuration.
+ * @returns A debounced function with `.cancel()` and `.flush()`.
+ */
+declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, wait: number, options?: DebounceOptions): DebouncedFunction<T>;
+/**
+ * Creates a throttled function that only invokes `fn` at most once per
+ * `wait` milliseconds.
+ *
+ * @param fn - The function to throttle.
+ * @param wait - The number of milliseconds to throttle invocations to.
+ * @returns A throttled function.
+ */
+declare function throttle<T extends (...args: unknown[]) => unknown>(fn: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Creates a memoized version of `fn`. Uses a `Map` cache keyed by the
+ * first argument by default, or by a custom `resolver` function.
+ *
+ * @param fn - The function to memoize.
+ * @param resolver - Optional function to determine the cache key.
+ * @returns The memoized function with a `.cache` property.
+ */
+declare function memoize<T extends (...args: unknown[]) => unknown>(fn: T, resolver?: (...args: Parameters<T>) => string): MemoizedFunction<T>;
+/**
+ * Retries an async function with exponential backoff and jitter.
+ *
+ * @param fn - The async function to retry.
+ * @param options - Retry configuration.
+ * @returns A promise that resolves with the function result.
+ */
+declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * A no-operation function that returns `undefined`.
+ */
+declare function noop(): void;
+/**
+ * Returns the given value unchanged.
+ *
+ * @param value - The value to return.
+ * @returns The same value.
+ */
+declare function identity<T>(value: T): T;
+/**
+ * Creates a function that invokes `fn` only once. Subsequent calls return
+ * the result of the first invocation.
+ *
+ * @param fn - The function to wrap.
+ * @returns A function that runs only once.
+ */
+declare function once<T extends (...args: unknown[]) => unknown>(fn: T): (...args: Parameters<T>) => ReturnType<T>;
+/**
+ * Deep equality check between two values. Supports primitives, objects,
+ * arrays, Date, RegExp, Map, Set, and nested structures. Circular
+ * references are handled.
+ *
+ * @example deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }) // true
+ * @example deepEqual({ a: 1 }, { a: 2 }) // false
+ */
+declare function deepEqual(a: unknown, b: unknown): boolean;
+/**
+ * Performs left-to-right function composition.
+ *
+ * @example const fn = pipe((x: number) => x + 1, (x: number) => x * 2)
+ * fn(3) // 8
+ */
+declare function pipe<T>(initial: T, ...fns: Array<(arg: T) => T>): T;
+declare function pipe<T, R>(initial: T, ...fns: Array<(arg: unknown) => unknown>): R;
+/**
+ * Performs right-to-left function composition.
+ *
+ * @example const fn = compose((x: number) => x * 2, (x: number) => x + 1)
+ * fn(3) // 8 — same as (3+1)*2
+ */
+declare function compose<T>(...fns: Array<(arg: T) => T>): (initial: T) => T;
+
+export { type DebounceOptions, type DebouncedFunction, type MemoizedFunction, type RetryOptions, compose, debounce, deepClone, deepEqual, deepMerge, identity, memoize, noop, once, pipe, retry, throttle };

package/dist/core/index.js

@@ -0,0 +1,324 @@
+// src/core/index.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function getType(value) {
+  return Object.prototype.toString.call(value);
+}
+function clone(value, seen) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  const tag = getType(value);
+  if (tag === "[object Date]") {
+    const cloned = new Date(value.getTime());
+    seen.set(value, cloned);
+    return cloned;
+  }
+  if (tag === "[object RegExp]") {
+    const regExp = value;
+    const cloned = new RegExp(regExp.source, regExp.flags);
+    cloned.lastIndex = regExp.lastIndex;
+    seen.set(value, cloned);
+    return cloned;
+  }
+  if (tag === "[object Map]") {
+    const cloned = /* @__PURE__ */ new Map();
+    seen.set(value, cloned);
+    value.forEach((v, k) => {
+      cloned.set(clone(k, seen), clone(v, seen));
+    });
+    return cloned;
+  }
+  if (tag === "[object Set]") {
+    const cloned = /* @__PURE__ */ new Set();
+    seen.set(value, cloned);
+    value.forEach((v) => {
+      cloned.add(clone(v, seen));
+    });
+    return cloned;
+  }
+  if (Array.isArray(value)) {
+    const cloned = [];
+    seen.set(value, cloned);
+    for (let i = 0; i < value.length; i++) {
+      cloned[i] = clone(value[i], seen);
+    }
+    return cloned;
+  }
+  if (tag === "[object Object]") {
+    const cloned = {};
+    seen.set(value, cloned);
+    const keys = Object.keys(value);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      cloned[key] = clone(value[key], seen);
+    }
+    return cloned;
+  }
+  return value;
+}
+function deepClone(value) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  return clone(value, seen);
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (let i = 0; i < objects.length; i++) {
+    const obj = objects[i];
+    if (obj === null || obj === void 0) continue;
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; j++) {
+      const key = keys[j];
+      if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+      const val = obj[key];
+      const existing = result[key];
+      if (val !== void 0 && isPlainObject(val) && isPlainObject(existing)) {
+        result[key] = deepMerge(
+          existing,
+          val
+        );
+      } else if (val !== void 0) {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+}
+function debounce(fn, wait, options) {
+  const { leading = false, trailing = true, maxWait } = options ?? {};
+  let timer = null;
+  let maxTimer = null;
+  let lastArgs = null;
+  let lastCallTime = null;
+  let lastInvokeTime = 0;
+  function invoke(time) {
+    lastInvokeTime = time;
+    if (lastArgs) {
+      fn(...lastArgs);
+      lastArgs = null;
+    }
+  }
+  function startTimer(waitTime) {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      const now = Date.now();
+      if (lastArgs && trailing) {
+        invoke(now);
+      }
+      timer = null;
+      lastCallTime = null;
+    }, waitTime);
+  }
+  function startMaxTimer() {
+    if (maxWait === void 0 || maxTimer) return;
+    maxTimer = setTimeout(() => {
+      if (lastArgs) {
+        invoke(Date.now());
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        lastCallTime = null;
+      }
+    }, maxWait);
+  }
+  function clearAllTimers() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (maxTimer) {
+      clearTimeout(maxTimer);
+      maxTimer = null;
+    }
+  }
+  function shouldInvoke(time) {
+    if (lastCallTime === null) return true;
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return timeSinceLastCall >= wait || maxWait !== void 0 && timeSinceLastInvoke >= maxWait;
+  }
+  const debounced = function(...args) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = args;
+    lastCallTime = time;
+    if (isInvoking && !timer && leading) {
+      invoke(time);
+    }
+    if (!timer) {
+      startTimer(wait);
+      if (maxWait !== void 0) {
+        startMaxTimer();
+      }
+    }
+  };
+  debounced.cancel = () => {
+    clearAllTimers();
+    lastArgs = null;
+    lastCallTime = null;
+    lastInvokeTime = 0;
+  };
+  debounced.flush = () => {
+    if (timer && lastArgs) {
+      invoke(Date.now());
+      clearAllTimers();
+      lastCallTime = null;
+    }
+  };
+  return debounced;
+}
+function throttle(fn, wait) {
+  let lastTime = 0;
+  let timer = null;
+  let lastArgs = null;
+  const throttled = function(...args) {
+    const now = Date.now();
+    const remaining = wait - (now - lastTime);
+    if (remaining <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      lastTime = now;
+      lastArgs = null;
+      fn.apply(this, args);
+    } else {
+      lastArgs = args;
+      if (!timer) {
+        timer = setTimeout(() => {
+          lastTime = Date.now();
+          timer = null;
+          if (lastArgs) {
+            fn.apply(this, lastArgs);
+            lastArgs = null;
+          }
+        }, remaining);
+      }
+    }
+  };
+  return throttled;
+}
+function memoize(fn, resolver) {
+  const cache = /* @__PURE__ */ new Map();
+  const memoized = function(...args) {
+    const key = resolver ? resolver(...args) : String(args[0]);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn.apply(this, args);
+    cache.set(key, result);
+    return result;
+  };
+  memoized.cache = cache;
+  return memoized;
+}
+function retry(fn, options) {
+  const {
+    attempts = 3,
+    baseDelay = 1e3,
+    maxDelay = 3e4,
+    shouldRetry = () => true
+  } = options ?? {};
+  let attempt = 0;
+  const execute = () => {
+    attempt++;
+    return fn().catch((error) => {
+      if (attempt >= attempts || !shouldRetry(error)) {
+        throw error;
+      }
+      const delay = Math.min(
+        baseDelay * Math.pow(2, attempt - 1) + Math.random() * baseDelay,
+        maxDelay
+      );
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(execute());
+        }, delay);
+      });
+    });
+  };
+  return execute();
+}
+function noop() {
+  return void 0;
+}
+function identity(value) {
+  return value;
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return function(...args) {
+    if (!called) {
+      called = true;
+      result = fn.apply(this, args);
+    }
+    return result;
+  };
+}
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null || typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  const aObj = a;
+  const bObj = b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [k, v] of a) {
+      if (!b.has(k) || !deepEqual(v, b.get(k))) return false;
+    }
+    return true;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const v of a) {
+      if (!b.has(v)) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(aObj);
+  const keysB = Object.keys(bObj);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;
+    if (!deepEqual(aObj[key], bObj[key])) return false;
+  }
+  return true;
+}
+function pipe(initial, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), initial);
+}
+function compose(...fns) {
+  return (initial) => fns.reduceRight((acc, fn) => fn(acc), initial);
+}
+export {
+  compose,
+  debounce,
+  deepClone,
+  deepEqual,
+  deepMerge,
+  identity,
+  memoize,
+  noop,
+  once,
+  pipe,
+  retry,
+  throttle
+};
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["export interface DebounceOptions {\r\n  leading?: boolean\r\n  trailing?: boolean\r\n  maxWait?: number\r\n}\r\n\r\nexport interface DebouncedFunction<T extends (...args: unknown[]) => unknown> {\r\n  (...args: Parameters<T>): void\r\n  cancel(): void\r\n  flush(): void\r\n}\r\n\r\nexport interface MemoizedFunction<T extends (...args: unknown[]) => unknown> {\r\n  (...args: Parameters<T>): ReturnType<T>\r\n  cache: Map<string, ReturnType<T>>\r\n}\r\n\r\nexport interface RetryOptions {\r\n  attempts?: number\r\n  baseDelay?: number\r\n  maxDelay?: number\r\n  shouldRetry?: (error: unknown) => boolean\r\n}\r\n\r\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\r\n  if (value === null || typeof value !== 'object') return false\r\n  const proto = Object.getPrototypeOf(value)\r\n  return proto === Object.prototype || proto === null\r\n}\r\n\r\nfunction getType(value: unknown): string {\r\n  return Object.prototype.toString.call(value)\r\n}\r\n\r\nfunction clone<T>(value: T, seen: WeakMap<object, unknown>): T {\r\n  if (value === null || typeof value !== 'object') return value\r\n\r\n  if (seen.has(value as object)) return seen.get(value as object) as T\r\n\r\n  const tag = getType(value)\r\n\r\n  if (tag === '[object Date]') {\r\n    const cloned = new Date((value as unknown as Date).getTime())\r\n    seen.set(value as object, cloned)\r\n    return cloned as unknown as T\r\n  }\r\n\r\n  if (tag === '[object RegExp]') {\r\n    const regExp = value as unknown as RegExp\r\n    const cloned = new RegExp(regExp.source, regExp.flags)\r\n    cloned.lastIndex = regExp.lastIndex\r\n    seen.set(value as object, cloned)\r\n    return cloned as unknown as T\r\n  }\r\n\r\n  if (tag === '[object Map]') {\r\n    const cloned = new Map<unknown, unknown>()\r\n    seen.set(value as object, cloned)\r\n    ;(value as unknown as Map<unknown, unknown>).forEach((v, k) => {\r\n      cloned.set(clone(k, seen), clone(v, seen))\r\n    })\r\n    return cloned as unknown as T\r\n  }\r\n\r\n  if (tag === '[object Set]') {\r\n    const cloned = new Set<unknown>()\r\n    seen.set(value as object, cloned)\r\n    ;(value as unknown as Set<unknown>).forEach(v => {\r\n      cloned.add(clone(v, seen))\r\n    })\r\n    return cloned as unknown as T\r\n  }\r\n\r\n  if (Array.isArray(value)) {\r\n    const cloned: unknown[] = []\r\n    seen.set(value as object, cloned)\r\n    for (let i = 0; i < value.length; i++) {\r\n      cloned[i] = clone(value[i], seen)\r\n    }\r\n    return cloned as unknown as T\r\n  }\r\n\r\n  if (tag === '[object Object]') {\r\n    const cloned: Record<string, unknown> = {}\r\n    seen.set(value as object, cloned)\r\n    const keys = Object.keys(value as Record<string, unknown>)\r\n    for (let i = 0; i < keys.length; i++) {\r\n      const key = keys[i]!\r\n      cloned[key] = clone((value as Record<string, unknown>)[key], seen)\r\n    }\r\n    return cloned as unknown as T\r\n  }\r\n\r\n  return value\r\n}\r\n\r\n/**\r\n * Deep clone a value, supporting objects, arrays, Date, RegExp, Map, Set,\r\n * and cyclic references.\r\n *\r\n * @param value - The value to clone.\r\n * @returns A deep copy of the input value.\r\n */\r\nexport function deepClone<T>(value: T): T {\r\n  const seen = new WeakMap<object, unknown>()\r\n  return clone(value, seen)\r\n}\r\n\r\n/**\r\n * Deep merge multiple objects. Arrays are overwritten, not concatenated.\r\n * `null` and `undefined` source objects are skipped.\r\n *\r\n * @param objects - The objects to merge.\r\n * @returns A new object with merged properties.\r\n */\r\nexport function deepMerge<T extends Record<string, unknown>>(...objects: Partial<T>[]): T {\r\n  const result = {} as T\r\n\r\n  for (let i = 0; i < objects.length; i++) {\r\n    const obj = objects[i]\r\n    if (obj === null || obj === undefined) continue\r\n\r\n    const keys = Object.keys(obj) as (keyof T)[]\r\n    for (let j = 0; j < keys.length; j++) {\r\n      const key = keys[j]!\r\n      if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue\r\n      const val = obj[key]\r\n      const existing = result[key]\r\n\r\n      if (val !== undefined && isPlainObject(val) && isPlainObject(existing)) {\r\n        result[key] = deepMerge(\r\n          existing as Record<string, unknown>,\r\n          val as Record<string, unknown>\r\n        ) as T[keyof T]\r\n      } else if (val !== undefined) {\r\n        result[key] = val as T[keyof T]\r\n      }\r\n    }\r\n  }\r\n\r\n  return result\r\n}\r\n\r\n/**\r\n * Creates a debounced function that delays invoking `fn` until after `wait`\r\n * milliseconds have elapsed since the last invocation. Supports leading,\r\n * trailing, and maxWait options. The returned function also has `.cancel()`\r\n * and `.flush()` methods.\r\n *\r\n * @param fn - The function to debounce.\r\n * @param wait - The number of milliseconds to delay.\r\n * @param options - Optional configuration.\r\n * @returns A debounced function with `.cancel()` and `.flush()`.\r\n */\r\nexport function debounce<T extends (...args: unknown[]) => unknown>(\r\n  fn: T,\r\n  wait: number,\r\n  options?: DebounceOptions\r\n): DebouncedFunction<T> {\r\n  const { leading = false, trailing = true, maxWait } = options ?? {}\r\n\r\n  let timer: ReturnType<typeof setTimeout> | null = null\r\n  let maxTimer: ReturnType<typeof setTimeout> | null = null\r\n  let lastArgs: Parameters<T> | null = null\r\n  let lastCallTime: number | null = null\r\n  let lastInvokeTime = 0\r\n\r\n  function invoke(time: number): void {\r\n    lastInvokeTime = time\r\n    if (lastArgs) {\r\n      fn(...lastArgs)\r\n      lastArgs = null\r\n    }\r\n  }\r\n\r\n  function startTimer(waitTime: number): void {\r\n    if (timer) clearTimeout(timer)\r\n    timer = setTimeout(() => {\r\n      const now = Date.now()\r\n      if (lastArgs && trailing) {\r\n        invoke(now)\r\n      }\r\n      timer = null\r\n      lastCallTime = null\r\n    }, waitTime)\r\n  }\r\n\r\n  function startMaxTimer(): void {\r\n    if (maxWait === undefined || maxTimer) return\r\n    maxTimer = setTimeout(() => {\r\n      if (lastArgs) {\r\n        invoke(Date.now())\r\n        if (timer) {\r\n          clearTimeout(timer)\r\n          timer = null\r\n        }\r\n        lastCallTime = null\r\n      }\r\n    }, maxWait)\r\n  }\r\n\r\n  function clearAllTimers(): void {\r\n    if (timer) {\r\n      clearTimeout(timer)\r\n      timer = null\r\n    }\r\n    if (maxTimer) {\r\n      clearTimeout(maxTimer)\r\n      maxTimer = null\r\n    }\r\n  }\r\n\r\n  function shouldInvoke(time: number): boolean {\r\n    if (lastCallTime === null) return true\r\n    const timeSinceLastCall = time - lastCallTime\r\n    const timeSinceLastInvoke = time - lastInvokeTime\r\n    return (\r\n      timeSinceLastCall >= wait ||\r\n      (maxWait !== undefined && timeSinceLastInvoke >= maxWait)\r\n    )\r\n  }\r\n\r\n  const debounced = function (this: unknown, ...args: Parameters<T>): void {\r\n    const time = Date.now()\r\n    const isInvoking = shouldInvoke(time)\r\n\r\n    lastArgs = args\r\n    lastCallTime = time\r\n\r\n    if (isInvoking && !timer && leading) {\r\n      invoke(time)\r\n    }\r\n\r\n    if (!timer) {\r\n      startTimer(wait)\r\n      if (maxWait !== undefined) {\r\n        startMaxTimer()\r\n      }\r\n    }\r\n  } as DebouncedFunction<T>\r\n\r\n  debounced.cancel = (): void => {\r\n    clearAllTimers()\r\n    lastArgs = null\r\n    lastCallTime = null\r\n    lastInvokeTime = 0\r\n  }\r\n\r\n  debounced.flush = (): void => {\r\n    if (timer && lastArgs) {\r\n      invoke(Date.now())\r\n      clearAllTimers()\r\n      lastCallTime = null\r\n    }\r\n  }\r\n\r\n  return debounced\r\n}\r\n\r\n/**\r\n * Creates a throttled function that only invokes `fn` at most once per\r\n * `wait` milliseconds.\r\n *\r\n * @param fn - The function to throttle.\r\n * @param wait - The number of milliseconds to throttle invocations to.\r\n * @returns A throttled function.\r\n */\r\nexport function throttle<T extends (...args: unknown[]) => unknown>(\r\n  fn: T,\r\n  wait: number\r\n): (...args: Parameters<T>) => void {\r\n  let lastTime = 0\r\n  let timer: ReturnType<typeof setTimeout> | null = null\r\n  let lastArgs: Parameters<T> | null = null\r\n\r\n  const throttled = function (this: unknown, ...args: Parameters<T>): void {\r\n    const now = Date.now()\r\n    const remaining = wait - (now - lastTime)\r\n\r\n    if (remaining <= 0) {\r\n      if (timer) {\r\n        clearTimeout(timer)\r\n        timer = null\r\n      }\r\n      lastTime = now\r\n      lastArgs = null\r\n      fn.apply(this, args)\r\n    } else {\r\n      lastArgs = args\r\n      if (!timer) {\r\n        timer = setTimeout(() => {\r\n          lastTime = Date.now()\r\n          timer = null\r\n          if (lastArgs) {\r\n            fn.apply(this, lastArgs)\r\n            lastArgs = null\r\n          }\r\n        }, remaining)\r\n      }\r\n    }\r\n  }\r\n\r\n  return throttled\r\n}\r\n\r\n/**\r\n * Creates a memoized version of `fn`. Uses a `Map` cache keyed by the\r\n * first argument by default, or by a custom `resolver` function.\r\n *\r\n * @param fn - The function to memoize.\r\n * @param resolver - Optional function to determine the cache key.\r\n * @returns The memoized function with a `.cache` property.\r\n */\r\nexport function memoize<T extends (...args: unknown[]) => unknown>(\r\n  fn: T,\r\n  resolver?: (...args: Parameters<T>) => string\r\n): MemoizedFunction<T> {\r\n  const cache = new Map<string, ReturnType<T>>()\r\n\r\n  const memoized = function (this: unknown, ...args: Parameters<T>): ReturnType<T> {\r\n    const key = resolver ? resolver(...args) : String(args[0])\r\n    if (cache.has(key)) {\r\n      return cache.get(key) as ReturnType<T>\r\n    }\r\n    const result = fn.apply(this, args) as ReturnType<T>\r\n    cache.set(key, result)\r\n    return result\r\n  }\r\n\r\n  memoized.cache = cache\r\n\r\n  return memoized as MemoizedFunction<T>\r\n}\r\n\r\n/**\r\n * Retries an async function with exponential backoff and jitter.\r\n *\r\n * @param fn - The async function to retry.\r\n * @param options - Retry configuration.\r\n * @returns A promise that resolves with the function result.\r\n */\r\nexport function retry<T>(\r\n  fn: () => Promise<T>,\r\n  options?: RetryOptions\r\n): Promise<T> {\r\n  const {\r\n    attempts = 3,\r\n    baseDelay = 1000,\r\n    maxDelay = 30000,\r\n    shouldRetry = () => true,\r\n  } = options ?? {}\r\n\r\n  let attempt = 0\r\n\r\n  const execute = (): Promise<T> => {\r\n    attempt++\r\n    return fn().catch((error: unknown) => {\r\n      if (attempt >= attempts || !shouldRetry(error)) {\r\n        throw error\r\n      }\r\n\r\n      const delay = Math.min(\r\n        baseDelay * Math.pow(2, attempt - 1) + Math.random() * baseDelay,\r\n        maxDelay\r\n      )\r\n\r\n      return new Promise<T>(resolve => {\r\n        setTimeout(() => {\r\n          resolve(execute())\r\n        }, delay)\r\n      })\r\n    })\r\n  }\r\n\r\n  return execute()\r\n}\r\n\r\n/**\r\n * A no-operation function that returns `undefined`.\r\n */\r\nexport function noop(): void {\r\n  return undefined\r\n}\r\n\r\n/**\r\n * Returns the given value unchanged.\r\n *\r\n * @param value - The value to return.\r\n * @returns The same value.\r\n */\r\nexport function identity<T>(value: T): T {\r\n  return value\r\n}\r\n\r\n/**\r\n * Creates a function that invokes `fn` only once. Subsequent calls return\r\n * the result of the first invocation.\r\n *\r\n * @param fn - The function to wrap.\r\n * @returns A function that runs only once.\r\n */\r\nexport function once<T extends (...args: unknown[]) => unknown>(\r\n  fn: T\r\n): (...args: Parameters<T>) => ReturnType<T> {\r\n  let called = false\r\n  let result: ReturnType<T>\r\n\r\n  return function (this: unknown, ...args: Parameters<T>): ReturnType<T> {\r\n    if (!called) {\r\n      called = true\r\n      result = fn.apply(this, args) as ReturnType<T>\r\n    }\r\n    return result\r\n  }\r\n}\r\n\r\n/**\r\n * Deep equality check between two values. Supports primitives, objects,\r\n * arrays, Date, RegExp, Map, Set, and nested structures. Circular\r\n * references are handled.\r\n *\r\n * @example deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }) // true\r\n * @example deepEqual({ a: 1 }, { a: 2 }) // false\r\n */\r\nexport function deepEqual(a: unknown, b: unknown): boolean {\r\n  if (Object.is(a, b)) return true\r\n  if (a === null || b === null || typeof a !== typeof b) return false\r\n  if (typeof a !== 'object') return false\r\n\r\n  const aObj = a as Record<string, unknown>\r\n  const bObj = b as Record<string, unknown>\r\n\r\n  if (Array.isArray(a) && Array.isArray(b)) {\r\n    if (a.length !== b.length) return false\r\n    for (let i = 0; i < a.length; i++) {\r\n      if (!deepEqual(a[i], b[i])) return false\r\n    }\r\n    return true\r\n  }\r\n\r\n  if (a instanceof Date && b instanceof Date) {\r\n    return a.getTime() === b.getTime()\r\n  }\r\n\r\n  if (a instanceof RegExp && b instanceof RegExp) {\r\n    return a.source === b.source && a.flags === b.flags\r\n  }\r\n\r\n  if (a instanceof Map && b instanceof Map) {\r\n    if (a.size !== b.size) return false\r\n    for (const [k, v] of a) {\r\n      if (!b.has(k) || !deepEqual(v, b.get(k))) return false\r\n    }\r\n    return true\r\n  }\r\n\r\n  if (a instanceof Set && b instanceof Set) {\r\n    if (a.size !== b.size) return false\r\n    for (const v of a) {\r\n      if (!b.has(v)) return false\r\n    }\r\n    return true\r\n  }\r\n\r\n  const keysA = Object.keys(aObj)\r\n  const keysB = Object.keys(bObj)\r\n  if (keysA.length !== keysB.length) return false\r\n\r\n  for (const key of keysA) {\r\n    if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false\r\n    if (!deepEqual(aObj[key], bObj[key])) return false\r\n  }\r\n  return true\r\n}\r\n\r\n/**\r\n * Performs left-to-right function composition.\r\n *\r\n * @example const fn = pipe((x: number) => x + 1, (x: number) => x * 2)\r\n * fn(3) // 8\r\n */\r\nexport function pipe<T>(initial: T, ...fns: Array<(arg: T) => T>): T\r\nexport function pipe<T, R>(initial: T, ...fns: Array<(arg: unknown) => unknown>): R\r\nexport function pipe(initial: unknown, ...fns: Array<(arg: unknown) => unknown>): unknown {\r\n  return fns.reduce((acc, fn) => fn(acc), initial)\r\n}\r\n\r\n/**\r\n * Performs right-to-left function composition.\r\n *\r\n * @example const fn = compose((x: number) => x * 2, (x: number) => x + 1)\r\n * fn(3) // 8 — same as (3+1)*2\r\n */\r\nexport function compose<T>(...fns: Array<(arg: T) => T>): (initial: T) => T\r\nexport function compose(...fns: Array<(arg: unknown) => unknown>): (initial: unknown) => unknown {\r\n  return (initial: unknown) => fns.reduceRight((acc, fn) => fn(acc), initial)\r\n}\r\n"],"mappings":"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","names":[]}