@kdtlabs/utils 0.0.3

package/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+
+## v0.0.3
+
+[compare changes](https://github.com/kdtlabs/utils/compare/v0.0.2...v0.0.3)
+
+## v0.0.2
+
+[compare changes](https://github.com/kdtlabs/utils/compare/v0.0.1...v0.0.2)
+
+### 🩹 Fixes
+
+- **release:** Build after changelog gen to prevent package.json version error ([459f06c](https://github.com/kdtlabs/utils/commit/459f06c))
+
+### ❤️ Contributors
+
+- Diep Dang <kdt310722@gmail.com>
+
+## v0.0.1
+
+
+### 🚀 Enhancements
+
+- Add SKILL.md for AI tool discovery of available utils ([e1dde1a](https://github.com/kdtlabs/utils/commit/e1dde1a))
+
+### 🩹 Fixes
+
+- **release:** Fix release script and add CHANGELOG.md to eslint ignore ([a72208c](https://github.com/kdtlabs/utils/commit/a72208c))
+
+### 🏡 Chore
+
+- Initial commit ([058e414](https://github.com/kdtlabs/utils/commit/058e414))
+- Add gitnexus to ignore files ([88c2d38](https://github.com/kdtlabs/utils/commit/88c2d38))
+
+### ❤️ Contributors
+
+- Diep Dang <kdt310722@gmail.com>
+

package/SKILL.md

@@ -0,0 +1,251 @@
+---
+name: kdtlabs-utils
+description: >
+  Provides 150+ TypeScript utility functions across 15 modules (arrays, objects, strings, numbers, promises, errors, etc.).
+  MUST check this library before writing any utility function. Do NOT reimplement functions that already exist here.
+  Use when writing TypeScript code that involves common operations like array manipulation, object transformation,
+  string processing, async control flow, error handling, or type guards.
+---
+
+# @kdtlabs/utils
+
+A comprehensive TypeScript utility library. Before writing any utility function, check if it already exists here.
+
+## Import
+
+```ts
+// Barrel import (all utils)
+import { unique, debounce, deepMerge } from '@kdtlabs/utils'
+
+// Per-module import (tree-shakeable)
+import { unique } from '@kdtlabs/utils/arrays'
+import { debounce } from '@kdtlabs/utils/functions'
+import { deepMerge } from '@kdtlabs/utils/objects'
+```
+
+## When you need function details
+
+For full type signatures, overloads, and options interfaces, read the `.d.ts` files directly:
+
+```text
+node_modules/@kdtlabs/utils/<module>/index.d.ts
+node_modules/@kdtlabs/utils/<module>/<file>.d.ts
+```
+
+## Arrays
+
+- `first<T>(array: T[]): T | undefined` — Get first element
+- `last<T>(array: T[]): T | undefined` — Get last element
+- `nth<T>(array: T[], index: number): T | undefined` — Get element at index (supports negative)
+- `unique<T>(array: T[]): T[]` — Remove duplicates via Set
+- `uniqueBy<T>(array: T[], equalFn): T[]` — Remove duplicates via custom equality
+- `groupBy<T, K>(array: T[], keyFn): Map<K, T[]>` — Group items by key
+- `keyBy<T, K>(array: T[], keyFn): Map<K, T>` — Create map keyed by function result
+- `chunk<T>(array: T[], size: number): T[][]` — Split into fixed-size chunks
+- `sortBy<T>(array: T[], ...keys): T[]` — Sort by key(s) with direction
+- `partition<T>(array: T[], predicate): [T[], T[]]` — Split into pass/fail arrays
+- `compact<T>(array: T[]): NonNullable<T>[]` — Remove null/undefined values
+- `wrap<T>(value: T | T[]): T[]` — Wrap non-array value into array
+- `toArray<T>(value): T[]` — Convert iterable/value to array
+- `range(from, to, step): number[]` — Create numeric range
+- `createArray<T>(length, valueFn): T[]` — Create array with factory function
+- `sample<T>(array: T[], quantity): T[]` — Random sampling
+
+Also: merge, flatten, shuffle, intersection, diff, symmetricDiff
+
+**Type guards:** isArray, isEmptyArray, isNonEmptyArray
+
+**Types:** MaybeArray, EmptyArray, NonEmptyArray, ElementOf, Head, Tail, Last, Flatten, TupleToUnion, FixedLength
+
+## Objects
+
+- `deepMerge<T>(base: T, override: DeepPartial<T>, options?): T` — Recursive deep merge with array mode control
+- `pick<T, K>(obj: T, ...keys: K[]): Pick<T, K>` — Pick keys to new object
+- `omit<T, K>(obj: T, ...keys: K[]): Omit<T, K>` — Omit keys from object
+- `filter(obj, predicate)` — Filter object entries
+- `filterByValue(obj, predicate)` — Filter by value only
+- `map(obj, fn)` — Map object entries
+- `entries(obj)` — Typed Object.entries
+- `resolveOptions(options, defaultValue)` — Merge options with defaults
+
+**Type guards:** isObject, isPlainObject, isEmptyObject, isKeyOf, isKeysOf
+
+**Types:** PartialBy, RequiredBy, Mutable, DeepPartial, DeepReadonly, KeysOfType, StringKeys, Dictionary, Constructor, AnyObject, UnknownObject
+
+## Functions
+
+- `debounce<T>(fn: T, wait: number): Debounced<T>` — Debounce with cancel/flush/pending
+- `throttle<T>(fn: T, wait: number): Throttled<T>` — Throttle with cancel/flush/pending
+- `memoize<T>(fn: T, options?): T` — Memoization with configurable cache
+- `pipe(...fns)` — Sequential function composition (up to 20 overloads)
+- `once<T>(fn: T): T & { reset(): void }` — Run once, with reset capability
+- `tap<T>(value: T, callback: (v: T) => void): T` — Side-effect, return original value
+- `transform<T, R>(value: T, callback: (v: T) => R): R` — Transform value
+- `tryCatch<T, F>(fn: () => T, fallback: F): T | F` — Try/catch wrapper
+
+Also: noop, invoke, invokes
+
+**Type guard:** isFunction
+
+**Types:** Fn, Args, TimingControlled
+
+## Promises
+
+- `withRetry<T>(fn, options?): Promise<T>` — Retry with exponential backoff, jitter, custom conditions
+- `withTimeout<T>(promise, ms, options?): Promise<T>` — Timeout wrapper
+- `poll<T>(fn, options): Promise<T>` — Repeated polling with interval and condition
+- `sleep(ms, options?): Promise<void>` — Delay with abort support
+- `abortable<T>(promise, signal, error?): Promise<T>` — Make promise abortable
+- `createDeferred<T>(options?): DeferredPromise<T>` — Deferred promise factory with resolve/reject
+- `createDeferredWithTimeout<T>(ms, options?): DeferredPromise<T>` — Deferred with auto-timeout
+- `pPipe(...fns)` — Async pipe composition
+- `pTap(callback)` — Async tap for promise chains
+- `tryCatchAsync<T, F>(fn, fallback): Promise<T | F>` — Async try/catch wrapper
+- `getRetryDelay(attempts, options)` — Calculate retry delay with backoff
+
+**Type guards:** isPromiseLike, isPromise
+
+**Types:** Awaitable
+
+## Errors
+
+- `BaseError` — Extended Error class with code, timestamp, retryable, cause chain
+- `normalizeError(error, options?)` — Normalize unknown value to Error instance
+- `ensureError(input, ctor?)` — Ensure value is Error, wrap if not
+- `stringifyError(error, options?)` — Human-readable error string with cause chain
+- `createAbortError(message?, name?)` — Create DOMException abort error
+- `createTimeoutError(message?, name?)` — Create timeout error
+- `createAbortController(timeout?, timeoutError?)` — AbortController with auto-timeout
+- `fromErrorLike(errorLike, ctor?)` — Create Error from error-like object
+- `combineSignals(...signals)` — Combine multiple AbortSignals into one
+
+**Type guards:** isError, isBaseError, isAbortError, isErrorLike
+
+**Types:** BaseErrorOptions, BaseErrorCode, Errorable, ErrorCtor, ErrorLike
+
+## Strings
+
+- `truncate(str, maxLength, omission?)` — Truncate with suffix (default "...")
+- `truncateMiddle(str, maxLength, omission?)` — Truncate from middle
+- `capitalize(str)` — Capitalize first character
+- `randomStr(length, characters?)` — Random string generator
+- `escapeRegExp(input)` — Escape regex special characters
+- `ensurePrefix(str, prefix)` — Add prefix if missing
+- `ensureSuffix(str, suffix)` — Add suffix if missing
+- `stripPrefix(str, prefix)` — Remove prefix
+- `stripSuffix(str, suffix)` — Remove suffix
+- `padZeroStart(num, targetLength)` — Zero-pad number
+
+Also: padStart, chunkStr, ltrim, rtrim, trim, trimRepeated
+
+**Type guards:** isEmptyString, isValidUrl, isHttpUrl, isWebSocketUrl, isValidProtocol, isStringEquals, isStringEqualsIgnoreCase, isIncludesAll, isIncludesAny, isIncludes, isHexString, isStrictHexString
+
+**Types:** UrlLike, HexString
+
+## Numbers
+
+- `clamp(value, min, max)` — Clamp value to range
+- `roundTo(value, decimals)` — Round to N decimal places
+- `lerp(start, end, t)` — Linear interpolation
+- `random(min, max)` — Random integer in range
+- `formatNumber(input, options?)` — Locale-aware number formatting
+- `toOrdinal(n)` — Convert to ordinal string (1st, 2nd, 3rd...)
+- `toPercent(value, total, decimals?)` — Calculate percentage
+
+Also: sum, avg, median, countLeadingZeros, toSubscriptDigits, parseExponential, BigIntMath
+
+**Type guards:** isNumberString, isNumberish, isPercentage, isValidRange, isInRange
+
+**Types:** NumberString, Numberish, Percentage
+
+## Core
+
+- `isNull(value)` / `isUndefined(value)` / `isNullish(value)` — Nullish checks
+- `notNull(value)` / `notUndefined(value)` / `notNullish(value)` — Non-null type guards
+- `isTrueLike(value, options?)` — Check truthy-like values (configurable true strings)
+
+Also: isBoolean, isSymbol, isBigInt, isNumber, isString, isDate, isPrimitive, isJsonablePrimitive, isGenerator, toString, typeOf
+
+**Types:** Primitive, Optional, Nullable, Nullish, Jsonable, JsonablePrimitive
+
+## Common
+
+- `isEmpty(value)` — Universal empty check (arrays, objects, collections, strings, maps, sets)
+- `assert(condition, message?, ctor?)` — Assert condition or throw (default Error)
+- `assertParam(condition, message?, ctor?)` — Assert parameter (default TypeError)
+
+## Collections
+
+- `LruMap<K, V>` — LRU eviction map with max size
+- `LruSet<T>` — LRU eviction set with max size
+- `FifoMap<K, V>` — FIFO eviction map with max size
+- `FifoSet<T>` — FIFO eviction set with max size
+
+**Type guards:** isIterable, isCollectionLike, isEmptyCollection, isSetLike, isMapLike
+
+**Types:** CollectionLike, SetLike, MapLike
+
+## Events
+
+- `Emitter<TEventMap>` — Typed event emitter with on, once, off, emit, removeAllListeners, listeners, listenersCount, eventNames
+
+**Types:** EventMap, EventNames, EventArgs, EventListener
+
+## Buffers
+
+- `bufferToString(buffer, encoding?)` — Convert buffer to string
+- `toUint8Array(buffer)` — Normalize any buffer to Uint8Array
+- `concatBuffers(buffers)` — Concatenate multiple buffers
+- `bufferEquals(a, b)` — Deep buffer comparison
+
+**Type guards:** isBuffer, isArrayBuffer, isSharedArrayBuffer, isArrayBufferView, isBufferLike
+
+**Types:** BufferLike
+
+## Times
+
+- `formatDate(date, format)` — Format date with token patterns
+- `humanizeMilliseconds(ms)` — Human-readable duration from ms
+- `humanizeSeconds(s)` — Human-readable duration from seconds
+- `humanizeNanoseconds(ns)` — Human-readable duration from ns
+- `timestamp()` — Current Unix timestamp (seconds)
+- `toUnixTimestamp(date)` — Date to Unix timestamp
+- `fromUnixTimestamp(timestamp)` — Unix timestamp to Date
+
+Also: isValidDate, startOfDay, endOfDay
+
+**Constants:** MS_PER_SECOND, MS_PER_MINUTE, MS_PER_HOUR, MS_PER_DAY, MS_PER_MONTH, MS_PER_YEAR
+
+## System
+
+- `fetch(request, options?)` — Fetch with built-in retry support
+- `pwd(importMeta, ...path)` — Resolve path relative to current module
+- `pathToString(path)` — Convert PathLike to string
+- `gracefulExit(exitCode?, maxWaitTime?)` — Graceful shutdown with exit handlers
+- `addExitHandler(handler, maxWaitTime?)` — Register exit handler
+
+Also: isInDevelopment, isInProduction, isInStaging, isInMode, isInDev, isInProd, isInStage
+
+**Types:** PathLike, FetchOptions
+
+## Serializer
+
+- `serialize(value, options?)` — Deep serialization of any value to JSON-safe format
+- `createContext(options?)` — Create serialization context for custom serialization
+- `createSymbolKeySerializer()` — Serialize Symbol keys to strings
+
+Handles: primitives, arrays, objects, errors, functions, binary data, blobs, collections, dates, regexps, URLs, circular references.
+
+## JSON-RPC
+
+- `createJsonRpcRequestMessage(id, method, params?)` — Create JSON-RPC 2.0 request
+- `createJsonRpcNotifyMessage(method, params?)` — Create notification (no id)
+- `createJsonRpcSuccessResponseMessage(id, result)` — Create success response
+- `createJsonRpcErrorResponseMessage(id, error)` — Create error response
+- `createJsonRpcErrorObject(code, message, data?)` — Create error object
+
+**Type guards:** isJsonRpcMessage, isJsonRpcRequestMessage, isJsonRpcNotifyMessage, isJsonRpcResponseMessage, isJsonRpcSuccessResponseMessage, isJsonRpcErrorResponseMessage, isJsonRpcError, isJsonRpcBatchRequest, isJsonRpcBatchResponse, isValidJsonRpcId
+
+**Constants:** JsonRpcErrorCode enum
+
+**Types:** JsonRpcRequestMessage, JsonRpcNotifyMessage, JsonRpcResponseMessage, JsonRpcSuccessResponseMessage, JsonRpcErrorResponseMessage, JsonRpcMessage, JsonRpcBatchRequest, JsonRpcBatchResponse

package/arrays/accessors.d.ts

@@ -0,0 +1,11 @@
+import type { EmptyArray, NonEmptyArray } from './types';
+export declare function nth(array: EmptyArray, index: number): undefined;
+export declare function nth<T>(array: NonEmptyArray<T>, index: number): T;
+export declare function nth<T>(array: T[], index: number): T | undefined;
+export declare function first(array: EmptyArray): undefined;
+export declare function first<T>(array: NonEmptyArray<T>): T;
+export declare function first<T>(array: T[]): T | undefined;
+export declare function last(array: EmptyArray): undefined;
+export declare function last<T>(array: NonEmptyArray<T>): T;
+export declare function last<T>(array: T[]): T | undefined;
+//# sourceMappingURL=accessors.d.ts.map

package/arrays/accessors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessors.d.ts","sourceRoot":"","sources":["../../src/arrays/accessors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAExD,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;AAChE,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAA;AACjE,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAA;AAMhE,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAAA;AACnD,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;AACpD,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAAA;AAMnD,wBAAgB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAAA;AAClD,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;AACnD,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAAA"}

package/arrays/conversions.d.ts

@@ -0,0 +1,6 @@
+import type { MaybeArray } from './types';
+import { type Nullable } from '../core';
+export declare const wrap: <T>(array: T | T[]) => T[];
+export declare function toArray<T>(value?: Nullable<MaybeArray<T>>): T[];
+export declare const compact: <T>(array: Array<Nullable<T>>) => T[];
+//# sourceMappingURL=conversions.d.ts.map

package/arrays/conversions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversions.d.ts","sourceRoot":"","sources":["../../src/arrays/conversions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,OAAO,EAAc,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAA;AAGnD,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,QAAuC,CAAA;AAE7E,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAMzD;AAED,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAG,CAAC,EAA8B,CAAA"}

package/arrays/factories.d.ts

@@ -0,0 +1,5 @@
+import type { EmptyArray, NonEmptyArray } from './types';
+export declare const createArray: <T, TStrict extends boolean = true, TLength extends number = number>(length: TLength, value: (index: number) => T) => TStrict extends false ? T[] : (TLength extends 0 ? EmptyArray : NonEmptyArray<T>);
+export declare const range: (from: number, to: number, step?: number) => number[];
+export declare const sample: <T>(array: T[], quantity?: number) => (T | undefined)[];
+//# sourceMappingURL=factories.d.ts.map

package/arrays/factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../../src/arrays/factories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAExD,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,OAAO,SAAS,OAAO,GAAG,IAAI,EAAE,OAAO,SAAS,MAAM,GAAG,MAAM,EAAE,QAAQ,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,KAC1F,OAAO,SAAS,KAAK,GAAG,CAAC,EAAE,GAAG,CAAC,OAAO,SAAS,CAAC,GAAG,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,CACjI,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,EAAE,IAAI,MAAM,EAAE,aAAQ,aAEvD,CAAA;AAED,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,iBAAY,sBAEjD,CAAA"}

package/arrays/guards.d.ts

@@ -0,0 +1,5 @@
+import type { EmptyArray, NonEmptyArray } from './types';
+export declare const isArray: <T = any>(value: unknown) => value is T[];
+export declare const isEmptyArray: <T = any, TStrict extends boolean = true>(value: T[]) => value is (TStrict extends true ? EmptyArray : T[]);
+export declare const isNonEmptyArray: <T = any, TStrict extends boolean = true>(value: T[]) => value is (TStrict extends true ? NonEmptyArray<T> : T[]);
+//# sourceMappingURL=guards.d.ts.map

package/arrays/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/arrays/guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAExD,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,OAAO,KAAG,KAAK,IAAI,CAAC,EAA0B,CAAA;AAEtF,eAAO,MAAM,YAAY,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,SAAS,OAAO,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,KAAG,KAAK,IAAI,CAAC,OAAO,SAAS,IAAI,GAAG,UAAU,GAAG,CAAC,EAAE,CAAuB,CAAA;AAE3J,eAAO,MAAM,eAAe,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,SAAS,OAAO,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,KAAG,KAAK,IAAI,CAAC,OAAO,SAAS,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAyB,CAAA"}

package/arrays/index.d.ts

@@ -0,0 +1,8 @@
+export * from './accessors';
+export * from './conversions';
+export * from './factories';
+export * from './guards';
+export * from './operations';
+export * from './set-operations';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/arrays/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/arrays/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAEhC,mBAAmB,SAAS,CAAA"}

package/arrays/index.js

@@ -0,0 +1,4 @@
+import{$b as w,Fb as a,Gb as b,Hb as c,Ib as d,Jb as e,Kb as f,Lb as g,Mb as h,Nb as i,Ob as j,Pb as k,Qb as l,Rb as m,Sb as n,Tb as o,Ub as p,Vb as q,Wb as r,Xb as s,Yb as t,Zb as u,_b as v,ac as x,bc as y}from"../chunk-c0p3wm8m.js";import"../chunk-qn6n0ff5.js";import"../chunk-c9mm50vv.js";export{g as wrap,v as uniqueBy,u as unique,h as toArray,y as symmetricDiff,s as sortBy,o as shuffle,l as sample,k as range,t as partition,a as nth,m as merge,c as last,q as keyBy,f as isNonEmptyArray,e as isEmptyArray,d as isArray,w as intersection,p as groupBy,n as flatten,b as first,x as diff,j as createArray,i as compact,r as chunk};
+
+//# debugId=7FF7885B231E2BF464756E2164756E21
+//# sourceMappingURL=index.js.map

package/arrays/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "7FF7885B231E2BF464756E2164756E21",
+  "names": []
+}

package/arrays/operations.d.ts

@@ -0,0 +1,16 @@
+import type { Nullable } from '../core';
+import type { MaybeArray } from './types';
+export declare const merge: <T>(...arrays: Array<Nullable<MaybeArray<T>>>) => T[];
+export declare const flatten: <T>(array?: Nullable<MaybeArray<T | T[]>>) => T[];
+export declare function shuffle<T>(array: T[]): T[];
+export declare function groupBy<T, K extends PropertyKey>(array: T[], keyFn: (item: T) => K): Record<K, T[]>;
+export declare function keyBy<T, K extends PropertyKey>(array: T[], keyFn: (item: T) => K): Record<K, T>;
+export declare function chunk<T>(array: T[], size: number): T[][];
+export type SortDirection = 'asc' | 'desc';
+export type SortKey<T> = ((item: T) => number | string) | {
+    fn: (item: T) => number | string;
+    order: SortDirection;
+};
+export declare function sortBy<T>(array: T[], ...keys: Array<SortKey<T>>): T[];
+export declare function partition<T>(array: T[], predicate: (item: T) => boolean): [T[], T[]];
+//# sourceMappingURL=operations.d.ts.map

package/arrays/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../src/arrays/operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,GAAG,QAAQ,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,QAA8C,CAAA;AAEhH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,QAAQ,QAAQ,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,KAA8B,CAAC,EAAE,CAAA;AAEjG,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAY1C;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAenG;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAQ/F;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,CAaxD;AAED,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,CAAA;AAE1C,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAAC,GAAG;IAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,CAAA;AAEpH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAmBrE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAapF"}

package/arrays/set-operations.d.ts

@@ -0,0 +1,6 @@
+export declare const unique: <T>(array: T[]) => T[];
+export declare const uniqueBy: <T>(array: T[], equalFn: (a: T, b: T) => boolean) => T[];
+export declare const intersection: <T>(a: T[], b: T[]) => T[];
+export declare const diff: <T>(a: T[], b: T[]) => T[];
+export declare const symmetricDiff: <T>(a: T[], b: T[]) => T[];
+//# sourceMappingURL=set-operations.d.ts.map

package/arrays/set-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-operations.d.ts","sourceRoot":"","sources":["../../src/arrays/set-operations.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,QAAwB,CAAA;AAE5D,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,QAEvE,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,QAAmC,CAAA;AAEjF,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,QAAoC,CAAA;AAE1E,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,QAAmC,CAAA"}

package/arrays/types.d.ts

@@ -0,0 +1,12 @@
+export type MaybeArray<T> = Iterable<T> | T | T[];
+export type EmptyArray = [];
+export type NonEmptyArray<T> = [T, ...T[]];
+export type ElementOf<T> = T extends Array<infer E> ? E : never;
+export type Head<T extends readonly unknown[]> = T extends readonly [infer H, ...unknown[]] ? H : never;
+export type Tail<T extends readonly unknown[]> = T extends readonly [unknown, ...infer R] ? R : [];
+export type Last<T extends readonly unknown[]> = T extends readonly [...unknown[], infer L] ? L : never;
+export type Flatten<T extends readonly unknown[]> = T extends ReadonlyArray<infer U> ? U extends ReadonlyArray<infer V> ? V[] : U[] : never;
+export type TupleToUnion<T extends readonly unknown[]> = T[number];
+export type FixedLength<T, N extends number, R extends T[] = []> = R['length'] extends N ? R : FixedLength<T, N, [...R, T]>;
+export type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
+//# sourceMappingURL=types.d.ts.map

package/arrays/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/arrays/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAA;AAEjD,MAAM,MAAM,UAAU,GAAG,EAAE,CAAA;AAE3B,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAA;AAE1C,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAE/D,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEvG,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,SAAS,CAAC,OAAO,EAAE,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAA;AAElG,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,SAAS,CAAC,GAAG,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEvG,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,KAAK,CAAA;AAE3I,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,CAAA;AAElE,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAE3H,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAA"}

package/buffers/conversions.d.ts

@@ -0,0 +1,4 @@
+import type { BufferLike } from './types';
+export declare function bufferToString(buffer: BufferLike, encoding?: BufferEncoding): string;
+export declare function toUint8Array(input: BufferLike): Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>;
+//# sourceMappingURL=conversions.d.ts.map

package/buffers/conversions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversions.d.ts","sourceRoot":"","sources":["../../src/buffers/conversions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,GAAE,cAAuB,UAUnF;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,yDAU7C"}

package/buffers/guards.d.ts

@@ -0,0 +1,7 @@
+import type { BufferLike } from './types';
+export declare const isBuffer: (value: unknown) => value is Buffer;
+export declare const isArrayBuffer: (value: unknown) => value is ArrayBuffer;
+export declare const isSharedArrayBuffer: (value: unknown) => value is SharedArrayBuffer;
+export declare const isArrayBufferView: (value: unknown) => value is ArrayBufferView;
+export declare const isBufferLike: (value: unknown) => value is BufferLike;
+//# sourceMappingURL=guards.d.ts.map

package/buffers/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/buffers/guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAgC,CAAA;AAEnF,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAA2C,CAAA;AAEnG,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,iBAAuD,CAAA;AAErH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,eAA4C,CAAA;AAExG,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,UAEtD,CAAA"}

package/buffers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './conversions';
+export * from './guards';
+export * from './operations';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/buffers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/buffers/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA;AAE5B,mBAAmB,SAAS,CAAA"}

package/buffers/index.js

@@ -0,0 +1,4 @@
+import{gb as a,hb as b,ib as c,jb as d,kb as e,lb as f,mb as g,nb as h,ob as i}from"../chunk-xp18wdk6.js";export{g as toUint8Array,c as isSharedArrayBuffer,e as isBufferLike,a as isBuffer,d as isArrayBufferView,b as isArrayBuffer,h as concatBuffers,f as bufferToString,i as bufferEquals};
+
+//# debugId=58E6E050C983599364756E2164756E21
+//# sourceMappingURL=index.js.map

package/buffers/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "58E6E050C983599364756E2164756E21",
+  "names": []
+}

package/buffers/operations.d.ts

@@ -0,0 +1,4 @@
+import type { BufferLike } from './types';
+export declare function concatBuffers(buffers: BufferLike[]): Uint8Array<ArrayBuffer>;
+export declare function bufferEquals(a: BufferLike, b: BufferLike): boolean;
+//# sourceMappingURL=operations.d.ts.map

package/buffers/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../src/buffers/operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,2BAsBlD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,WAgBxD"}

package/buffers/types.d.ts

@@ -0,0 +1,2 @@
+export type BufferLike = ArrayBuffer | ArrayBufferView | Buffer | SharedArrayBuffer;
+//# sourceMappingURL=types.d.ts.map

package/buffers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/buffers/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,eAAe,GAAG,MAAM,GAAG,iBAAiB,CAAA"}

package/chunk-4w1emwv7.js

@@ -0,0 +1,6 @@
+import{pd as f,td as b}from"./chunk-m4svr349.js";import{Kd as c,Pd as u}from"./chunk-c9mm50vv.js";class p extends Error{constructor(r,{code:e,details:t,exitCode:n,name:o,retryable:i,timestamp:s,...a}={}){super(r,a);Object.setPrototypeOf(this,new.target.prototype),this.defineValue("name",o??this.constructor.name),this.defineValue("timestamp",s??new Date),this.defineValue("cause",a.cause),this.defineValue("code",e),this.defineValue("details",t),this.defineValue("exitCode",n),this.defineValue("retryable",i)}withValue(r,e){if(Object.hasOwn(this,r))throw TypeError(`Cannot redefine property '${r}' on ${this.name}`);return this.defineValue(r,e)}defineValue(r,e){return Object.defineProperty(this,r,{configurable:!1,enumerable:!0,value:e,writable:!1}),this}}var v=(r)=>r instanceof Error,P=(r)=>r instanceof p,R=(r)=>r instanceof DOMException&&r.name==="AbortError",x=(r)=>f(r)&&b(r,"name")&&u(r.name);var O=(r="This operation was aborted",e="AbortError")=>new DOMException(r,e),C=(r="The operation was aborted due to a timeout",e="TimeoutError")=>O(r,e);function B(r,e){let t=new AbortController;if(c(r)&&r>0&&r<=Number.MAX_SAFE_INTEGER){let n,o=()=>{clearTimeout(n),t.signal.removeEventListener("abort",o)};t.signal.addEventListener("abort",o),n=setTimeout(()=>t.abort(d(e??C())),r)}return t}function d(r,e){if(typeof r==="string")return e?new e(r):Error(r);if(typeof r==="function")return d(r(),e);return r}function k({cause:r,message:e,name:t,stack:n,...o},i){let a=new(i??Error)(e,{cause:r});Object.defineProperty(a,"name",{configurable:!0,enumerable:!1,value:t,writable:!0}),Object.defineProperty(a,"stack",{configurable:!0,enumerable:!1,value:n,writable:!0});for(let[l,m]of Object.entries(o))Object.defineProperty(a,l,Object.getOwnPropertyDescriptor(o,l)??{configurable:!0,enumerable:!0,value:m,writable:!0});return a}function y(r,{defaultMessage:e="Unknown error",errorConstructor:t}={}){let n=t??Error;if(r instanceof n)return r;if(u(r))return d(r,t);if(x(r))return k(r,t);return new n(e,{cause:r})}function K(...r){let e=r.filter(c);if(e.length===0)return new AbortController().signal;if(e.length===1)return e[0];return AbortSignal.any(e)}var N={code:(r)=>`[${r}]`,message:(r)=>r,name:(r)=>`${r}:`};function A(r,e,t,n){let o=t+" ".repeat(n.causeIndent),i=[];if(r instanceof AggregateError&&r.errors.length>0)for(let s of r.errors)i.push(g(s,e-1,o,n.causePrefix,n));if(f(r.cause)||u(r.cause))i.push(g(r.cause,e-1,o,n.causePrefix,n));return i}function h(r,e,t,n,o,i){if(!i.includeCause||n<=0||e!==t&&e.cause===t)return;let s=A(e,n,o,i);if(s.length>0)r.push(`
+${s.join(`
+`)}`)}function M(r,e){let t=[];if(e.includeCode&&"code"in r&&c(r.code))t.push(e.formatters.code(String(r.code)));if(e.includeName)t.push(e.formatters.name(r.name));return t.push(e.formatters.message(r.message||e.defaultMessage)),t}function g(r,e,t,n,o){if(o.visited.has(r))return`${t}${n}${o.circularReferenceMessage}`;if(r instanceof Error)o.visited.add(r);if(r instanceof Error&&r.toString!==Error.prototype.toString){let a=[r.toString()];return h(a,r,r,e,t,o),t+n+a.join(" ")}let i=y(r,{...o.normalizeOptions,defaultMessage:o.defaultMessage});o.visited.add(i);let s=M(i,o);return h(s,i,r,e,t,o),t+n+s.join(" ")}function J(r,e={}){let{causeIndent:t=2,causePrefix:n="-> ",circularReferenceMessage:o="[Circular Reference]",defaultMessage:i="Unknown error",formatters:s={},includeCause:a=!0,includeCode:l=!0,includeName:m=!0,maxCauseDepth:E=Number.POSITIVE_INFINITY,...w}=e,S={causeIndent:t,causePrefix:n,circularReferenceMessage:o,defaultMessage:i,formatters:{...N,...s},includeCause:a,includeCode:l,includeName:m,maxCauseDepth:E,normalizeOptions:w,visited:new Set};return g(r,E,"","",S)}export{p as Zc,v as _c,P as $c,R as ad,x as bd,O as cd,C as dd,B as ed,d as fd,k as gd,y as hd,K as id,N as jd,A as kd,h as ld,M as md,g as nd,J as od};
+
+//# debugId=89966F1E1B5C279064756E2164756E21
+//# sourceMappingURL=chunk-4w1emwv7.js.map

package/chunk-4w1emwv7.js.map

@@ -0,0 +1,14 @@
+{
+  "version": 3,
+  "sources": ["../src/errors/base-error.ts", "../src/errors/guards.ts", "../src/errors/factories.ts", "../src/errors/operations.ts", "../src/errors/stringify.ts"],
+  "sourcesContent": [
+    "export type BaseErrorCode = number | string\n\nexport interface BaseErrorOptions extends ErrorOptions {\n    cause?: unknown\n    code?: BaseErrorCode\n    details?: string\n    exitCode?: number\n    name?: string\n    retryable?: boolean\n    timestamp?: Date\n}\n\nexport class BaseError extends Error {\n    public declare readonly timestamp: Date\n    public declare readonly code?: BaseErrorCode\n    public declare readonly cause?: unknown\n    public declare readonly details?: string\n    public declare readonly exitCode?: number\n    public declare readonly retryable?: boolean\n\n    public constructor(message: string, { code, details, exitCode, name, retryable, timestamp, ...options }: BaseErrorOptions = {}) {\n        super(message, options)\n\n        Object.setPrototypeOf(this, new.target.prototype)\n\n        this.defineValue('name', name ?? this.constructor.name)\n        this.defineValue('timestamp', timestamp ?? new Date())\n        this.defineValue('cause', options.cause)\n        this.defineValue('code', code)\n        this.defineValue('details', details)\n        this.defineValue('exitCode', exitCode)\n        this.defineValue('retryable', retryable)\n    }\n\n    public withValue<K extends string, V>(key: K, value: V): Record<K, V> & this {\n        if (Object.hasOwn(this, key)) {\n            throw new TypeError(`Cannot redefine property '${key}' on ${this.name}`)\n        }\n\n        return this.defineValue(key, value) as Record<K, V> & this\n    }\n\n    protected defineValue(key: string, value: unknown) {\n        Object.defineProperty(this, key, { configurable: false, enumerable: true, value, writable: false })\n\n        return this\n    }\n}\n",
+    "import type { ErrorLike } from './types'\nimport { isString } from '../core'\nimport { isKeysOf, isObject } from '../objects'\nimport { BaseError } from './base-error'\n\nexport const isError = (value: unknown): value is Error => value instanceof Error\n\nexport const isBaseError = (value: unknown): value is BaseError => value instanceof BaseError\n\nexport const isAbortError = (error: unknown): error is DOMException => error instanceof DOMException && error.name === 'AbortError'\n\nexport const isErrorLike = (value: unknown): value is ErrorLike => isObject(value) && isKeysOf(value, 'name') && isString(value.name)\n",
+    "import type { Errorable, ErrorCtor, ErrorLike } from './types'\nimport { isString, notNullish } from '../core'\nimport { isErrorLike } from './guards'\n\nexport const createAbortError = (message = 'This operation was aborted', name = 'AbortError') => new DOMException(message, name)\n\nexport const createTimeoutError = (message = 'The operation was aborted due to a timeout', name = 'TimeoutError') => createAbortError(message, name)\n\nexport function createAbortController(timeout?: number, timeoutError?: Errorable) {\n    const controller = new AbortController()\n\n    if (notNullish(timeout) && timeout > 0 && timeout <= Number.MAX_SAFE_INTEGER) {\n        let timeoutId: NodeJS.Timeout\n\n        const cleanup = () => {\n            clearTimeout(timeoutId)\n            controller.signal.removeEventListener('abort', cleanup)\n        }\n\n        controller.signal.addEventListener('abort', cleanup)\n        timeoutId = setTimeout(() => controller.abort(ensureError(timeoutError ?? createTimeoutError())), timeout)\n    }\n\n    return controller\n}\n\nexport function ensureError(input: Errorable, ctor?: ErrorCtor) {\n    if (typeof input === 'string') {\n        return ctor ? new ctor(input) : new Error(input)\n    }\n\n    if (typeof input === 'function') {\n        return ensureError(input(), ctor)\n    }\n\n    return input\n}\n\nexport function fromErrorLike({ cause, message, name, stack, ...properties }: ErrorLike, ctor?: ErrorCtor) {\n    const errorClass = ctor ?? Error\n    const error = new errorClass(message, { cause })\n\n    Object.defineProperty(error, 'name', { configurable: true, enumerable: false, value: name, writable: true })\n    Object.defineProperty(error, 'stack', { configurable: true, enumerable: false, value: stack, writable: true })\n\n    for (const [key, value] of Object.entries(properties)) {\n        Object.defineProperty(error, key, Object.getOwnPropertyDescriptor(properties, key) ?? { configurable: true, enumerable: true, value, writable: true })\n    }\n\n    return error\n}\n\nexport interface NormalizeErrorOptions {\n    defaultMessage?: string\n    errorConstructor?: ErrorCtor\n}\n\nexport function normalizeError(error: unknown, { defaultMessage = 'Unknown error', errorConstructor }: NormalizeErrorOptions = {}) {\n    const errorClass = errorConstructor ?? Error\n\n    if (error instanceof errorClass) {\n        return error\n    }\n\n    if (isString(error)) {\n        return ensureError(error, errorConstructor)\n    }\n\n    if (isErrorLike(error)) {\n        return fromErrorLike(error, errorConstructor)\n    }\n\n    return new errorClass(defaultMessage, { cause: error })\n}\n",
+    "import { notNullish, type Nullish } from '../core'\n\nexport function combineSignals(...signals: Array<Nullish<AbortSignal>>) {\n    const validSignals = signals.filter(notNullish)\n\n    if (validSignals.length === 0) {\n        return new AbortController().signal\n    }\n\n    if (validSignals.length === 1) {\n        return validSignals[0]!\n    }\n\n    return AbortSignal.any(validSignals)\n}\n",
+    "import { isString, notNullish } from '../core'\nimport { isObject } from '../objects'\nimport { normalizeError, type NormalizeErrorOptions } from './factories'\n\nexport interface StringifyErrorFormatters {\n    code?: (code: string) => string\n    message?: (message: string) => string\n    name?: (name: string) => string\n}\n\nexport interface StringifyErrorOptions extends NormalizeErrorOptions {\n    causeIndent?: number\n    causePrefix?: string\n    circularReferenceMessage?: string\n    formatters?: StringifyErrorFormatters\n    includeCause?: boolean\n    includeCode?: boolean\n    includeName?: boolean\n    maxCauseDepth?: number\n}\n\nexport const DEFAULT_STRINGIFY_FORMATTERS: Required<StringifyErrorFormatters> = {\n    code: (value) => `[${value}]`,\n    message: (value) => value,\n    name: (value) => `${value}:`,\n}\n\nexport interface StringifyErrorState {\n    causeIndent: number\n    causePrefix: string\n    circularReferenceMessage: string\n    defaultMessage: string\n    formatters: Required<StringifyErrorFormatters>\n    includeCause: boolean\n    includeCode: boolean\n    includeName: boolean\n    maxCauseDepth: number\n    normalizeOptions: NormalizeErrorOptions\n    visited: Set<unknown>\n}\n\nexport function collectCauses(error: Error, depth: number, indent: string, state: StringifyErrorState) {\n    const childIndent = indent + ' '.repeat(state.causeIndent)\n    const pointers: string[] = []\n\n    if (error instanceof AggregateError && error.errors.length > 0) {\n        for (const subError of error.errors) {\n            pointers.push(stringifyErrorNode(subError, depth - 1, childIndent, state.causePrefix, state))\n        }\n    }\n\n    if (isObject(error.cause) || isString(error.cause)) {\n        pointers.push(stringifyErrorNode(error.cause, depth - 1, childIndent, state.causePrefix, state))\n    }\n\n    return pointers\n}\n\nexport function appendCauses(parts: string[], error: Error, error_: unknown, depth: number, indent: string, state: StringifyErrorState) {\n    if (!state.includeCause || depth <= 0 || (error !== error_ && error.cause === error_)) {\n        return\n    }\n\n    const pointers = collectCauses(error, depth, indent, state)\n\n    if (pointers.length > 0) {\n        parts.push(`\\n${pointers.join('\\n')}`)\n    }\n}\n\nexport function buildErrorParts(error: Error, state: StringifyErrorState) {\n    const parts: string[] = []\n\n    if (state.includeCode && 'code' in error && notNullish(error.code)) {\n        parts.push(state.formatters.code(String(error.code)))\n    }\n\n    if (state.includeName) {\n        parts.push(state.formatters.name(error.name))\n    }\n\n    parts.push(state.formatters.message(error.message || state.defaultMessage))\n\n    return parts\n}\n\nexport function stringifyErrorNode(error_: unknown, depth: number, indent: string, prefix: string, state: StringifyErrorState): string {\n    if (state.visited.has(error_)) {\n        return `${indent}${prefix}${state.circularReferenceMessage}`\n    }\n\n    if (error_ instanceof Error) {\n        state.visited.add(error_)\n    }\n\n    if (error_ instanceof Error && error_.toString !== Error.prototype.toString) {\n        const parts = [error_.toString()]\n        appendCauses(parts, error_, error_, depth, indent, state)\n\n        return indent + prefix + parts.join(' ')\n    }\n\n    const error = normalizeError(error_, { ...state.normalizeOptions, defaultMessage: state.defaultMessage })\n\n    state.visited.add(error)\n\n    const parts = buildErrorParts(error, state)\n    appendCauses(parts, error, error_, depth, indent, state)\n\n    return indent + prefix + parts.join(' ')\n}\n\nexport function stringifyError(error: unknown, options: StringifyErrorOptions = {}) {\n    const { causeIndent = 2, causePrefix = '-> ', circularReferenceMessage = '[Circular Reference]', defaultMessage = 'Unknown error', formatters: formatters_ = {}, includeCause = true, includeCode = true, includeName = true, maxCauseDepth = Number.POSITIVE_INFINITY, ...normalizeOptions } = options\n\n    const state: StringifyErrorState = {\n        causeIndent,\n        causePrefix,\n        circularReferenceMessage,\n        defaultMessage,\n        formatters: { ...DEFAULT_STRINGIFY_FORMATTERS, ...formatters_ },\n        includeCause,\n        includeCode,\n        includeName,\n        maxCauseDepth,\n        normalizeOptions,\n        visited: new Set<unknown>(),\n    }\n\n    return stringifyErrorNode(error, maxCauseDepth, '', '', state)\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "89966F1E1B5C279064756E2164756E21",
+  "names": []
+}

package/chunk-6kdnnxe0.js

@@ -0,0 +1,4 @@
+var u={isEven(t){return t%2n===0n},isOdd(t){return t%2n!==0n},divMod(t,r){if(r===0n)throw RangeError("Division by zero");return[t/r,t%r]},abs(t){return t<0n?-t:t},max(t,r){return t>r?t:r},min(t,r){return t<r?t:r},pow(t,r){return t**r},sign(t){return t===0n?0n:t<0n?-1n:1n},mod(t,r){return(t%r+r)%r},modPow(t,r,n){if(r<0n)throw RangeError("Exponent must be non-negative");if(n===1n)return 0n;let e=1n;t=u.mod(t,n);while(r>0n){if(r%2n===1n)e=u.mod(e*t,n);r>>=1n,t=u.mod(t*t,n)}return e},gcd(t,r){t=u.abs(t),r=u.abs(r);while(r!==0n)[t,r]=[r,t%r];return t},lcm(t,r){return t/u.gcd(t,r)*r},clamp(t,r,n){return u.min(u.max(t,r),n)},sqrt(t){if(t<0n)throw RangeError("Square root of negative bigint is undefined");if(t<2n)return t;let r=t,n=(r+1n)/2n;while(n<r)r=n,n=(r+t/r)/2n;return r},factorial(t){if(t<0n)throw RangeError("Factorial of negative bigint is undefined");if(t===0n)return 1n;let r=1n;for(let n=1n;n<=t;n++)r*=n;return r},sum(t){return t.reduce((r,n)=>r+n,0n)},avg(t){if(t.length===0)return 0n;return u.sum(t)/BigInt(t.length)},isPrime(t){if(t<2n)return!1;if(t<4n)return!0;if(t%2n===0n||t%3n===0n)return!1;let r=u.sqrt(t);for(let n=5n;n<=r;n+=6n)if(t%n===0n||t%(n+2n)===0n)return!1;return!0},compare(t,r){return t===r?0:t<r?-1:1}};var l=new Set(["+Infinity","-Infinity","Infinity","NaN"]),d={0:"₀",1:"₁",2:"₂",3:"₃",4:"₄",5:"₅",6:"₆",7:"₇",8:"₈",9:"₉"};import{transform as I}from"@/functions";var F=(t)=>t.reduce((r,n)=>r+n,0),D=(t)=>t.length===0?0:F(t)/t.length,C=(t,r,n)=>Math.min(Math.max(t,r),n),h=(t,r)=>I(10**r,(n)=>Math.round(t*n)/n),O=(t,r,n)=>t+(r-t)*n;function q(t){if(t.length===0)return 0;let r=[...t].toSorted((e,i)=>e-i),n=Math.floor(r.length/2);if(r.length%2===0)return(r[n-1]+r[n])/2;return r[n]}function x(t){let r="";for(let n of t.toString())r+=d[n]??n;return r}function w(t){let r=t.toString().toLowerCase(),[n,e]=r.split("e");if(e===void 0)return r;let[i,m=""]=n?.split(".")??[];if(!i)return r;let f=i.startsWith("-")?"-":"",g=f?i.slice(1):i,s=Number(e);if(s>=0){let p=Math.max(0,s-m.length),o=m+"0".repeat(p);if(o.length>s)return`${f}${g}${o.slice(0,s)}.${o.slice(s)}`;return`${f}${g}${o}`}let a=-s,c=g+m,b=Math.max(0,a-g.length);return`${f}0.${"0".repeat(b)}${c}`}function U(t){let r=Math.abs(t)%100,n=r%10;if(r>=11&&r<=13)return`${t}th`;switch(n){case 1:return`${t}st`;case 2:return`${t}nd`;case 3:return`${t}rd`;default:return`${t}th`}}function j(t,r,n){if(r===0)return 0;let e=t/r*100;if(n===void 0)return e;return h(e,n)}function V(t,r){let n=Math.min(t,r),e=Math.max(t,r);return Math.floor(Math.random()*(e-n+1))+n}function N(t){let r=0;for(let n=0;n<t.length&&t[n]==="0";n++)r++;return r}function G(t,r={}){let{formatLeadingZeros:n=(o)=>`0${x(o)}`,groupFractionLeadingZeros:e=!0,locales:i="en-US",maximumFractionDigits:m=4,...f}=r,g=(o)=>new Intl.NumberFormat(i,{...f,maximumFractionDigits:o}).format(t);if(!e)return g(m);let s=w(t),[,a=""]=s.split(".",2),c=N(a);if(c<=1)return g(m);let b=(o)=>{if(o.type==="fraction")return`${n(c)}${o.value.slice(c)}`;return o.value};return new Intl.NumberFormat(i,{...f,maximumFractionDigits:m+c}).formatToParts(t).map(b).join("")}import{isBigInt as S,isNumber as M,isString as T}from"@/core";var L=/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/iu,P=(t)=>l.has(t);function R(t){if(P(t))return!0;return L.test(t)}var X=(t)=>M(t)||S(t)||T(t)&&R(t),Y=(t)=>t>=0&&t<=100;import{notNullish as $}from"@/core";function tt(t,r,n=!0,e,i){if($(e)&&t<e)return!1;if($(i)&&r>i)return!1;return n?t<=r:t<r}var rt=(t,r,n,e=!0)=>e?t>=r&&t<=n:t>r&&t<n;export{u as J,l as K,d as L,F as M,D as N,C as O,h as P,O as Q,q as R,x as S,w as T,U,j as V,V as W,N as X,G as Y,P as Z,R as _,X as $,Y as aa,tt as ba,rt as ca};
+
+//# debugId=372A1B62607032A564756E2164756E21
+//# sourceMappingURL=chunk-6kdnnxe0.js.map