speexjs-core 0.7.0

package/dist/error/index.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Predefined error codes mapped to their default HTTP status codes.
+ */
+interface ErrorCodeMap {
+    'BAD_REQUEST': 400;
+    'UNAUTHORIZED': 401;
+    'FORBIDDEN': 403;
+    'NOT_FOUND': 404;
+    'CONFLICT': 409;
+    'VALIDATION_ERROR': 422;
+    'TOO_MANY': 429;
+    'INTERNAL': 500;
+    'BAD_GATEWAY': 502;
+    'UNAVAILABLE': 503;
+}
+/** Union of all known error codes. */
+type ErrorCode = keyof ErrorCodeMap;
+/**
+ * A typed error with a machine-readable code, HTTP status, optional details, and cause.
+ *
+ * - `code`  – Short machine-readable identifier (e.g. `'NOT_FOUND'`).
+ * - `status` – Defaults to the mapped HTTP status for the code; can be overridden.
+ * - `details` – Arbitrary metadata attached to the error.
+ *
+ * @example
+ * ```ts
+ * throw new TypedError('NOT_FOUND', 'User not found', { details: { userId } })
+ * ```
+ */
+declare class TypedError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly details?: unknown;
+    constructor(code: string, message: string, options?: {
+        status?: number;
+        details?: unknown;
+        cause?: unknown;
+    });
+    /**
+     * Serialize the error to a plain JSON-safe object.
+     */
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        status: number;
+        details: unknown;
+        cause: unknown;
+        stack?: string;
+    };
+    toString(): string;
+}
+/**
+ * Create a typed error from a known error code.
+ *
+ * The HTTP status is automatically derived from the code but can be overridden
+ * via an explicit `status` in options.
+ *
+ * @example
+ * ```ts
+ * throw createError('NOT_FOUND', 'User not found', { details: { userId: 1 } })
+ * ```
+ */
+declare function createError(code: ErrorCode, message: string, options?: {
+    details?: unknown;
+    cause?: unknown;
+}): TypedError;
+/**
+ * Checks whether an unknown value is a {@link TypedError}.
+ *
+ * @example
+ * ```ts
+ * if (isTypedError(err)) {
+ *   console.log(err.code, err.status)
+ * }
+ * ```
+ */
+declare function isTypedError(error: unknown): error is TypedError;
+
+/**
+ * Collects multiple errors into a single aggregate error.
+ *
+ * Useful for batch operations where independent steps may each fail and you
+ * want to report all failures together rather than throwing on the first one.
+ *
+ * @example
+ * ```ts
+ * const err = new MultiError([
+ *   new Error('First failure'),
+ *   new Error('Second failure'),
+ * ])
+ * throw err
+ * ```
+ */
+declare class MultiError extends Error {
+    readonly errors: Error[];
+    constructor(errors: Error[], message?: string);
+    /** Number of collected errors. */
+    get length(): number;
+    /**
+     * Check if any collected error satisfies `predicate`.
+     *
+     * @example
+     * ```ts
+     * if (err.some(e => e.message.includes('timeout'))) { … }
+     * ```
+     */
+    some(predicate: (error: Error) => boolean): boolean;
+    /** Array of all error messages. */
+    get messages(): string[];
+    /**
+     * Serialize to a plain JSON-safe object.
+     */
+    toJSON(): {
+        name: string;
+        message: string;
+        errors: Array<{
+            name: string;
+            message: string;
+            stack?: string;
+        }>;
+        stack?: string;
+    };
+    toString(): string;
+}
+/**
+ * Run `fn` and capture any thrown error.
+ *
+ * If `fn` returns successfully, `result` holds the return value and `errors`
+ * is an empty array. If `fn` throws, `errors` contains the thrown value
+ * (wrapped in an `Error` if it is not already one).
+ *
+ * @example
+ * ```ts
+ * const { result, errors } = collectErrors(() => {
+ *   return riskyOperation()
+ * })
+ * if (errors.length > 0) {
+ *   console.error('Operation failed', errors)
+ * }
+ * ```
+ */
+declare function collectErrors<T>(fn: () => T): {
+    result?: T;
+    errors: Error[];
+};
+
+export { type ErrorCode, type ErrorCodeMap, MultiError, TypedError, collectErrors, createError, isTypedError };

package/dist/error/index.js

@@ -0,0 +1,115 @@
+// src/error/createError.ts
+var defaultStatus = {
+  "BAD_REQUEST": 400,
+  "UNAUTHORIZED": 401,
+  "FORBIDDEN": 403,
+  "NOT_FOUND": 404,
+  "CONFLICT": 409,
+  "VALIDATION_ERROR": 422,
+  "TOO_MANY": 429,
+  "INTERNAL": 500,
+  "BAD_GATEWAY": 502,
+  "UNAVAILABLE": 503
+};
+var TypedError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "TypedError";
+    this.code = code;
+    this.status = options?.status ?? defaultStatus[code] ?? 500;
+    this.details = options?.details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Serialize the error to a plain JSON-safe object.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      details: this.details,
+      cause: this.cause,
+      ...this.stack ? { stack: this.stack } : {}
+    };
+  }
+  toString() {
+    return `${this.name} [${this.code}]: ${this.message}`;
+  }
+};
+function createError(code, message, options) {
+  return new TypedError(code, message, options);
+}
+function isTypedError(error) {
+  return error instanceof TypedError;
+}
+
+// src/error/MultiError.ts
+var MultiError = class extends Error {
+  errors;
+  constructor(errors, message) {
+    const joined = errors.map((e) => e.message).join("; ");
+    super(message ?? joined);
+    this.name = "MultiError";
+    this.errors = [...errors];
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /** Number of collected errors. */
+  get length() {
+    return this.errors.length;
+  }
+  /**
+   * Check if any collected error satisfies `predicate`.
+   *
+   * @example
+   * ```ts
+   * if (err.some(e => e.message.includes('timeout'))) { … }
+   * ```
+   */
+  some(predicate) {
+    return this.errors.some(predicate);
+  }
+  /** Array of all error messages. */
+  get messages() {
+    return this.errors.map((e) => e.message);
+  }
+  /**
+   * Serialize to a plain JSON-safe object.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      errors: this.errors.map((e) => ({
+        name: e.name,
+        message: e.message,
+        ...e.stack ? { stack: e.stack } : {}
+      })),
+      ...this.stack ? { stack: this.stack } : {}
+    };
+  }
+  toString() {
+    return `${this.name}: ${this.message}`;
+  }
+};
+function collectErrors(fn) {
+  try {
+    return { result: fn(), errors: [] };
+  } catch (err) {
+    return {
+      errors: [err instanceof Error ? err : new Error(String(err))]
+    };
+  }
+}
+export {
+  MultiError,
+  TypedError,
+  collectErrors,
+  createError,
+  isTypedError
+};
+//# sourceMappingURL=index.js.map

package/dist/error/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/error/createError.ts","../../src/error/MultiError.ts"],"sourcesContent":["/**\n * Predefined error codes mapped to their default HTTP status codes.\n */\nexport interface ErrorCodeMap {\n  'BAD_REQUEST': 400\n  'UNAUTHORIZED': 401\n  'FORBIDDEN': 403\n  'NOT_FOUND': 404\n  'CONFLICT': 409\n  'VALIDATION_ERROR': 422\n  'TOO_MANY': 429\n  'INTERNAL': 500\n  'BAD_GATEWAY': 502\n  'UNAVAILABLE': 503\n}\n\n/** Union of all known error codes. */\nexport type ErrorCode = keyof ErrorCodeMap\n\n/** Default HTTP status for each error code. */\nconst defaultStatus: ErrorCodeMap = {\n  'BAD_REQUEST': 400,\n  'UNAUTHORIZED': 401,\n  'FORBIDDEN': 403,\n  'NOT_FOUND': 404,\n  'CONFLICT': 409,\n  'VALIDATION_ERROR': 422,\n  'TOO_MANY': 429,\n  'INTERNAL': 500,\n  'BAD_GATEWAY': 502,\n  'UNAVAILABLE': 503,\n}\n\n/**\n * A typed error with a machine-readable code, HTTP status, optional details, and cause.\n *\n * - `code`  – Short machine-readable identifier (e.g. `'NOT_FOUND'`).\n * - `status` – Defaults to the mapped HTTP status for the code; can be overridden.\n * - `details` – Arbitrary metadata attached to the error.\n *\n * @example\n * ```ts\n * throw new TypedError('NOT_FOUND', 'User not found', { details: { userId } })\n * ```\n */\nexport class TypedError extends Error {\n  readonly code: string\n  readonly status: number\n  readonly details?: unknown\n\n  constructor(\n    code: string,\n    message: string,\n    options?: { status?: number; details?: unknown; cause?: unknown },\n  ) {\n    super(message, { cause: options?.cause })\n    this.name = 'TypedError'\n    this.code = code\n    this.status = options?.status ?? defaultStatus[code as ErrorCode] ?? 500\n    this.details = options?.details\n\n    Object.setPrototypeOf(this, new.target.prototype)\n  }\n\n  /**\n   * Serialize the error to a plain JSON-safe object.\n   */\n  toJSON(): {\n    name: string\n    message: string\n    code: string\n    status: number\n    details: unknown\n    cause: unknown\n    stack?: string\n  } {\n    return {\n      name: this.name,\n      message: this.message,\n      code: this.code,\n      status: this.status,\n      details: this.details,\n      cause: this.cause,\n      ...(this.stack ? { stack: this.stack } : {}),\n    }\n  }\n\n  override toString(): string {\n    return `${this.name} [${this.code}]: ${this.message}`\n  }\n}\n\n/**\n * Create a typed error from a known error code.\n *\n * The HTTP status is automatically derived from the code but can be overridden\n * via an explicit `status` in options.\n *\n * @example\n * ```ts\n * throw createError('NOT_FOUND', 'User not found', { details: { userId: 1 } })\n * ```\n */\nexport function createError(\n  code: ErrorCode,\n  message: string,\n  options?: { details?: unknown; cause?: unknown },\n): TypedError {\n  return new TypedError(code, message, options)\n}\n\n/**\n * Checks whether an unknown value is a {@link TypedError}.\n *\n * @example\n * ```ts\n * if (isTypedError(err)) {\n *   console.log(err.code, err.status)\n * }\n * ```\n */\nexport function isTypedError(error: unknown): error is TypedError {\n  return error instanceof TypedError\n}\n","/**\n * Collects multiple errors into a single aggregate error.\n *\n * Useful for batch operations where independent steps may each fail and you\n * want to report all failures together rather than throwing on the first one.\n *\n * @example\n * ```ts\n * const err = new MultiError([\n *   new Error('First failure'),\n *   new Error('Second failure'),\n * ])\n * throw err\n * ```\n */\nexport class MultiError extends Error {\n  readonly errors: Error[]\n\n  constructor(errors: Error[], message?: string) {\n    const joined = errors.map((e) => e.message).join('; ')\n    super(message ?? joined)\n    this.name = 'MultiError'\n    this.errors = [...errors]\n\n    Object.setPrototypeOf(this, new.target.prototype)\n  }\n\n  /** Number of collected errors. */\n  get length(): number {\n    return this.errors.length\n  }\n\n  /**\n   * Check if any collected error satisfies `predicate`.\n   *\n   * @example\n   * ```ts\n   * if (err.some(e => e.message.includes('timeout'))) { … }\n   * ```\n   */\n  some(predicate: (error: Error) => boolean): boolean {\n    return this.errors.some(predicate)\n  }\n\n  /** Array of all error messages. */\n  get messages(): string[] {\n    return this.errors.map((e) => e.message)\n  }\n\n  /**\n   * Serialize to a plain JSON-safe object.\n   */\n  toJSON(): {\n    name: string\n    message: string\n    errors: Array<{ name: string; message: string; stack?: string }>\n    stack?: string\n  } {\n    return {\n      name: this.name,\n      message: this.message,\n      errors: this.errors.map((e) => ({\n        name: e.name,\n        message: e.message,\n        ...(e.stack ? { stack: e.stack } : {}),\n      })),\n      ...(this.stack ? { stack: this.stack } : {}),\n    }\n  }\n\n  override toString(): string {\n    return `${this.name}: ${this.message}`\n  }\n}\n\n/**\n * Run `fn` and capture any thrown error.\n *\n * If `fn` returns successfully, `result` holds the return value and `errors`\n * is an empty array. If `fn` throws, `errors` contains the thrown value\n * (wrapped in an `Error` if it is not already one).\n *\n * @example\n * ```ts\n * const { result, errors } = collectErrors(() => {\n *   return riskyOperation()\n * })\n * if (errors.length > 0) {\n *   console.error('Operation failed', errors)\n * }\n * ```\n */\nexport function collectErrors<T>(\n  fn: () => T,\n): { result?: T; errors: Error[] } {\n  try {\n    return { result: fn(), errors: [] }\n  } catch (err) {\n    return {\n      errors: [err instanceof Error ? err : new Error(String(err))],\n    }\n  }\n}\n"],"mappings":";AAoBA,IAAM,gBAA8B;AAAA,EAClC,eAAe;AAAA,EACf,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,oBAAoB;AAAA,EACpB,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,eAAe;AACjB;AAcO,IAAM,aAAN,cAAyB,MAAM;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EAET,YACE,MACA,SACA,SACA;AACA,UAAM,SAAS,EAAE,OAAO,SAAS,MAAM,CAAC;AACxC,SAAK,OAAO;AACZ,SAAK,OAAO;AACZ,SAAK,SAAS,SAAS,UAAU,cAAc,IAAiB,KAAK;AACrE,SAAK,UAAU,SAAS;AAExB,WAAO,eAAe,MAAM,WAAW,SAAS;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA,EAKA,SAQE;AACA,WAAO;AAAA,MACL,MAAM,KAAK;AAAA,MACX,SAAS,KAAK;AAAA,MACd,MAAM,KAAK;AAAA,MACX,QAAQ,KAAK;AAAA,MACb,SAAS,KAAK;AAAA,MACd,OAAO,KAAK;AAAA,MACZ,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;AAAA,IAC5C;AAAA,EACF;AAAA,EAES,WAAmB;AAC1B,WAAO,GAAG,KAAK,IAAI,KAAK,KAAK,IAAI,MAAM,KAAK,OAAO;AAAA,EACrD;AACF;AAaO,SAAS,YACd,MACA,SACA,SACY;AACZ,SAAO,IAAI,WAAW,MAAM,SAAS,OAAO;AAC9C;AAYO,SAAS,aAAa,OAAqC;AAChE,SAAO,iBAAiB;AAC1B;;;AC5GO,IAAM,aAAN,cAAyB,MAAM;AAAA,EAC3B;AAAA,EAET,YAAY,QAAiB,SAAkB;AAC7C,UAAM,SAAS,OAAO,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,IAAI;AACrD,UAAM,WAAW,MAAM;AACvB,SAAK,OAAO;AACZ,SAAK,SAAS,CAAC,GAAG,MAAM;AAExB,WAAO,eAAe,MAAM,WAAW,SAAS;AAAA,EAClD;AAAA;AAAA,EAGA,IAAI,SAAiB;AACnB,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,KAAK,WAA+C;AAClD,WAAO,KAAK,OAAO,KAAK,SAAS;AAAA,EACnC;AAAA;AAAA,EAGA,IAAI,WAAqB;AACvB,WAAO,KAAK,OAAO,IAAI,CAAC,MAAM,EAAE,OAAO;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA,EAKA,SAKE;AACA,WAAO;AAAA,MACL,MAAM,KAAK;AAAA,MACX,SAAS,KAAK;AAAA,MACd,QAAQ,KAAK,OAAO,IAAI,CAAC,OAAO;AAAA,QAC9B,MAAM,EAAE;AAAA,QACR,SAAS,EAAE;AAAA,QACX,GAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAAA,MACtC,EAAE;AAAA,MACF,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;AAAA,IAC5C;AAAA,EACF;AAAA,EAES,WAAmB;AAC1B,WAAO,GAAG,KAAK,IAAI,KAAK,KAAK,OAAO;AAAA,EACtC;AACF;AAmBO,SAAS,cACd,IACiC;AACjC,MAAI;AACF,WAAO,EAAE,QAAQ,GAAG,GAAG,QAAQ,CAAC,EAAE;AAAA,EACpC,SAAS,KAAK;AACZ,WAAO;AAAA,MACL,QAAQ,CAAC,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;AAAA,IAC9D;AAAA,EACF;AACF;","names":[]}

package/dist/index-BgG21uJC.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Represents the severity level of a log entry.
+ * Ordered from least to most severe: debug < info < warn < error.
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Log function signature bound to a specific severity level.
+ */
+type LogFn = (message: string, meta?: Record<string, unknown>) => void;
+/**
+ * Configuration options for creating a Logger instance.
+ */
+interface LoggerOptions {
+    /** Minimum log level to output (default: 'info'). */
+    level?: LogLevel;
+    /** Optional name tag prepended to every message as `[name]`. */
+    name?: string;
+    /** Custom transport; defaults to {@link consoleTransport}. */
+    transport?: Transport$1;
+}
+/**
+ * A transport handles the formatted output of log entries.
+ * Implementations write to stdout, files, buffers, or remote services.
+ */
+interface Transport$1 {
+    log(level: LogLevel, message: string, meta?: Record<string, unknown>): void;
+}
+/**
+ * Structured logger with level filtering, child loggers, and pluggable transport.
+ *
+ * @example
+ * ```ts
+ * const log = new Logger({ level: 'debug', name: 'app' })
+ * log.info('server started', { port: 3000 })
+ *
+ * const child = log.child({ requestId: 'abc-123' })
+ * child.warn('slow query', { durationMs: 450 })
+ * ```
+ */
+declare class Logger {
+    private _level;
+    private _name?;
+    private _transport;
+    private _extraMeta;
+    constructor(options?: LoggerOptions);
+    private _shouldLog;
+    private _log;
+    /** Log at `debug` level. Only emitted when the current level is `'debug'`. */
+    debug: LogFn;
+    /** Log at `info` level. Emitted when level is `'debug'` or `'info'`. */
+    info: LogFn;
+    /** Log at `warn` level. Emitted when level is `'debug'`, `'info'`, or `'warn'`. */
+    warn: LogFn;
+    /** Log at `error` level. Always emitted regardless of current level. */
+    error: LogFn;
+    /**
+     * Creates a child logger that inherits the parent's level, name, and transport,
+     * but merges `extraMeta` into every log call. Child metadata is shallow-merged
+     * on top of the parent's inherited metadata.
+     *
+     * @param extraMeta - Additional context to include in every log entry.
+     */
+    child(extraMeta: Record<string, unknown>): Logger;
+    /** Updates the minimum log level for this instance. */
+    setLevel(level: LogLevel): void;
+    /** Returns the current minimum log level. */
+    getLevel(): LogLevel;
+    /**
+     * Creates a new named Logger.
+     * Convenience shorthand for `new Logger({ ...options, name })`.
+     *
+     * @param name - The name tag shown in log output.
+     * @param options - Additional configuration.
+     */
+    static create(name: string, options?: LoggerOptions): Logger;
+}
+/**
+ * Default transport that writes formatted log lines to `console.log`.
+ *
+ * Output format: `[LEVEL] message {meta}`
+ *
+ * When a logger has a name, the format becomes: `[LEVEL] [name] message {meta}`
+ */
+declare const consoleTransport: Transport$1;
+/**
+ * Default logger instance at `'info'` level with no name.
+ */
+declare const logger: Logger;
+
+/**
+ * A transport handles the formatted output of log entries.
+ */
+interface Transport {
+    log(level: LogLevel, message: string, meta?: Record<string, unknown>): void;
+}
+/**
+ * Creates a console transport that writes formatted log lines to `console.log`.
+ *
+ * The level prefix is optionally colored using ANSI escape codes:
+ * - `debug` → gray
+ * - `info`  → blue
+ * - `warn`  → yellow
+ * - `error` → red
+ *
+ * @param options - Configuration for the console transport.
+ * @param options.colors - Enable ANSI color output (default: `true`).
+ * @param options.timestamp - Prepend an ISO-8601 timestamp (default: `false`).
+ */
+declare function createConsoleTransport(options?: {
+    colors?: boolean;
+    timestamp?: boolean;
+}): Transport;
+/**
+ * Creates a transport that outputs structured JSON lines.
+ *
+ * Each log entry is serialized as a single JSON object with
+ * `timestamp`, `level`, `message`, and optional `meta` fields.
+ *
+ * @param options - Configuration for the JSON transport.
+ * @param options.stream - A writable stream (e.g. `process.stdout`).
+ *                         Defaults to `process.stdout` in Node.js, falls
+ *                         back to `console.log` in browsers.
+ */
+declare function createJsonTransport(options?: {
+    stream?: {
+        write(data: string): void;
+    };
+}): Transport;
+/**
+ * Creates a transport that appends log entries to a file.
+ *
+ * Each line is formatted as: `[timestamp] [LEVEL] message {meta}`
+ *
+ * ⚠️ Node.js only. Silently discards log entries when `fs` is unavailable
+ * (browsers, Deno, Bun — though Bun supports `fs`).
+ *
+ * @param filename - Path to the log file.
+ * @param options - Configuration for the file transport.
+ * @param options.maxSize - Maximum file size in bytes before rotation
+ *                          (default: 10 MB). **Note:** rotation is not
+ *                          yet implemented; this is reserved for future use.
+ */
+declare function createFileTransport(filename: string, _options?: {
+    maxSize?: number;
+}): Transport;
+/**
+ * Creates a buffered transport that batches log entries and flushes them
+ * to the underlying transport when either the buffer size or flush interval
+ * is reached (whichever comes first).
+ *
+ * Useful for reducing I/O pressure in high-throughput scenarios.
+ *
+ * @param transport - The underlying transport to flush to.
+ * @param options - Configuration for the buffer.
+ * @param options.maxSize - Maximum number of entries before forced flush
+ *                          (default: 100).
+ * @param options.flushIntervalMs - How often to auto-flush in milliseconds
+ *                                  (default: 5000). Set to `0` to disable
+ *                                  interval flushing.
+ */
+declare function createBufferedTransport(transport: Transport, options?: {
+    maxSize?: number;
+    flushIntervalMs?: number;
+}): Transport;
+
+export { type LogLevel as L, type Transport$1 as T, Logger as a, createBufferedTransport as b, consoleTransport as c, createConsoleTransport as d, createFileTransport as e, createJsonTransport as f, type Transport as g, type LogFn as h, type LoggerOptions as i, logger as l };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { DebounceOptions, DebouncedFunction, MemoizedFunction, RetryOptions, compose, debounce, deepClone, deepEqual, deepMerge, identity, memoize, noop, once, pipe, retry, throttle } from './core/index.js';
+export { DivisionByZeroError, add, approxEqual, average, ceil, clamp, combinations, correlation, div, factorial, floor, formatCurrency, gcd, geometricMean, inRange, isEven, isOdd, isPrime, lcm, lerp, mapRange, median, mode, mul, percentageOf, percentile, permutations, randomInt, range, round, sampleStddev, stddev, sub, sum, toDegrees, toRadians, weightedAverage } from './math/index.js';
+export { DateDiff, Duration, InvalidDateError, TIMEZONE_WIB, TIMEZONE_WIT, TIMEZONE_WITA, addBusinessDays, addDays, addMonths, addYears, calculateAge, dateDiff, dayOfYear, daysInMonth, endOfDay, endOfMonth, endOfYear, formatDate, formatDuration, formatInTimezone, getIndonesianHolidayNames, isAfter, isBefore, isBetween, isBusinessDay, isFuture, isHolidayIndonesia, isLeapYear, isPast, isSameDay, isToday, isTomorrow, isWeekend, isYesterday, lastFriday, lastMonday, lastSaturday, lastSunday, lastThursday, lastTuesday, lastWednesday, maxDate, minDate, nextFriday, nextMonday, nextSaturday, nextSunday, nextThursday, nextTuesday, nextWednesday, parseDate, parseDuration, quarter, startOfDay, startOfMonth, startOfYear, timeAgo, timeRemaining, toTimezone, weekOfYear } from './date/index.js';
+export { base64Decode, base64Encode, checksum, constantTimeEqual, generateOTP, generateToken, hash, randomHex, simpleHash, xorCipher } from './crypto/index.js';
+export { ParsedPath, basename, dirname, extname, format, isAbsolute, join, normalize, parse, relative, resolve } from './path/index.js';
+export { 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 } from './collection/index.js';
+export { camelCase, capitalize, charCount, countOccurrences, dedent, escapeHtml, formatBytes, formatRupiah, fuzzyMatch, isAnagram, isPalindrome, kebabCase, levenshtein, maskString, nanoid, pad, padEnd, padStart, pascalCase, pluralize, randomBoolean, randomString, reverse, similarity, slugify, snakeCase, stripHtml, swapCase, template, terbilang, toCobolCase, trim, trimEnd, trimStart, truncate, truncateWords, unescapeHtml, uuid, wordCount, words } from './string/index.js';
+export { Deferred, MemoizeAsyncOptions, Mutex, Queue, QueueOptions, RateLimiter, Semaphore, allSettledMap, batch, deferred, memoizeAsync, parallelMap, pipeline, raceWithTimeout, retryAsync, sleep, timeout, waterfall } from './async/index.js';
+export { CsvOptions, env, envBool, envInt, parseCsv, safeJsonParse, stringifyCsv } from './io/index.js';
+export { assertDefined, assertType, castArray, ensureArray, getType, isArray, isBoolean, isDate, isFunction, isMap, isNil, isNull, isNumber, isObject, isPromise, isRegExp, isSet, isString, isUndefined } from './type/index.js';
+export { scanProject } from './dep-exray/scanner/index.js';
+export { generateReport } from './dep-exray/reporter/index.js';
+export { analyzeUsage } from './dep-exray/analyzer/index.js';
+export { DependencyInfo, ReplacementSuggestion, ScanResult, ScannerConfig, SecurityIssue } from './dep-exray/types.js';
+export { KNOWN_CVES, KNOWN_MAPPINGS } from './dep-exray/known-mappings.js';
+export { NIKInfo, isEmail, isKodepos, isNIK, isNPWP, isNoBPJS, isNoKK, isNoRekening, isNoSIM, isPassport, isPhone, isPlatNomor, isURL, parseNIK } from './validation/index.js';
+export { ErrorCode, MultiError, TypedError, collectErrors, createError, isTypedError } from './error/index.js';
+export { L as LogLevel, a as Logger, T as Transport, c as consoleTransport, b as createBufferedTransport, d as createConsoleTransport, e as createFileTransport, f as createJsonTransport, l as logger } from './index-BgG21uJC.js';
+export { alpha, complementary, contrastRatio, darken, hexToHsl, hexToRgb, hslToHex, isDark, isLight, isValidHex, lighten, meetsWCAG, mix, randomColor, rgbToHex } from './color/index.js';