@vielzeug/toolkit 1.1.3 → 2.0.0

package/dist/toolkit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolkit.js","names":["#scheduler"],"sources":["../src/function/assert.ts","../src/typed/isArray.ts","../src/typed/isString.ts","../src/array/chunk.ts","../src/typed/isEqual.ts","../src/array/contains.ts","../src/array/fold.ts","../src/array/group.ts","../src/array/keyBy.ts","../src/string/similarity.ts","../src/typed/isNil.ts","../src/typed/isNumber.ts","../src/typed/isObject.ts","../src/typed/isWithin.ts","../src/object/seek.ts","../src/array/search.ts","../src/array/list.ts","../src/array/pick.ts","../src/array/remoteList.ts","../src/array/replace.ts","../src/array/rotate.ts","../src/array/select.ts","../src/function/compare.ts","../src/function/compareBy.ts","../src/array/sort.ts","../src/array/toggle.ts","../src/array/uniq.ts","../src/async/predict.ts","../src/async/sleep.ts","../src/async/retry.ts","../src/async/attempt.ts","../src/async/defer.ts","../src/async/parallel.ts","../src/async/scheduler.ts","../src/async/pool.ts","../src/async/queue.ts","../src/async/race.ts","../src/async/waitFor.ts","../src/date/expires.ts","../src/typed/isDate.ts","../src/date/interval.ts","../src/date/timeDiff.ts","../src/function/assertParams.ts","../src/function/compose.ts","../src/function/curry.ts","../src/function/debounce.ts","../src/function/fp.ts","../src/function/memo.ts","../src/function/once.ts","../src/function/pipe.ts","../src/function/throttle.ts","../src/math/abs.ts","../src/math/allocate.ts","../src/math/sum.ts","../src/math/average.ts","../src/math/clamp.ts","../src/math/distribute.ts","../src/math/linspace.ts","../src/math/max.ts","../src/math/median.ts","../src/math/min.ts","../src/math/percent.ts","../src/math/range.ts","../src/math/round.ts","../src/money/currency.ts","../src/money/exchange.ts","../src/object/stash.ts","../src/object/diff.ts","../src/object/merge.ts","../src/object/parseJSON.ts","../src/object/path.ts","../src/object/proxy.ts","../src/typed/isEmpty.ts","../src/object/prune.ts","../src/random/random.ts","../src/random/draw.ts","../src/random/shuffle.ts","../src/random/uuid.ts","../src/string/_caseUtils.ts","../src/string/camelCase.ts","../src/string/kebabCase.ts","../src/string/pascalCase.ts","../src/string/snakeCase.ts","../src/string/truncate.ts","../src/typed/isBoolean.ts","../src/typed/isDefined.ts","../src/typed/isEven.ts","../src/typed/isFunction.ts","../src/typed/isMatch.ts","../src/typed/isNegative.ts","../src/typed/isOdd.ts","../src/typed/isPositive.ts","../src/typed/isPrimitive.ts","../src/typed/isPromise.ts","../src/typed/isRegex.ts","../src/typed/isZero.ts","../src/typed/typeOf.ts","../src/typed/is.ts"],"sourcesContent":["import type { Obj } from '../types';\n\ntype AssertOptions = { args?: Obj; bypass?: boolean; type?: ErrorConstructor };\n\n/**\n * Asserts that a condition is true. Throws (or warns, with `bypass`) otherwise.\n *\n * @example\n * ```ts\n * assert(Array.isArray([]));                      // ok\n * assert(x > 0, 'x must be positive');            // throws if false\n * assert(x > 0, 'x must be positive', { args: { x } });\n * assert(ok, 'not ok', { bypass: true });         // logs warning instead of throwing\n * assertAll([cond1, cond2], 'One failed');         // throws if any is false\n * ```\n *\n * @param condition - The boolean condition to assert.\n * @param [message] - Error message (default: `'Assertion failed'`).\n * @param [options.type] - Error class to throw (default: `Error`).\n * @param [options.args] - Debugging info appended to the message.\n * @param [options.bypass] - Log a warning instead of throwing.\n *\n * @throws {Error} If `condition` is false and `bypass` is not set.\n */\nexport function assert(\n  condition: boolean,\n  message = 'Assertion failed',\n  { args, bypass = false, type = Error }: AssertOptions = {},\n): void {\n  if (condition) return;\n\n  const errorDetails = args ? `\\nArguments: ${JSON.stringify(args, null, 2)}` : '';\n  const fullMessage = `${message}${errorDetails}`;\n\n  if (bypass) console.warn(fullMessage);\n  else throw new type(fullMessage);\n}\n\n/**\n * Asserts that every condition in the array is true.\n *\n * @example\n * ```ts\n * assertAll([cond1, cond2, cond3], 'One or more conditions failed');\n * ```\n */\nexport function assertAll(conditions: boolean[], message = 'Assertion failed', options: AssertOptions = {}): void {\n  assert(conditions.every(Boolean), message, options);\n}\n","/**\n * Determines if the passed value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]) // true\n * isArray(1, 2, 3) // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is an array, else `false`.\n */\nexport function isArray(arg: unknown): arg is Array<unknown> {\n  return Array.isArray(arg);\n}\n\nexport const IS_ARRAY_ERROR_MSG = 'Expected an array';\n","/**\n * Determines if the passed value is a String.\n *\n * @example\n * ```ts\n * isString('Hello World'); // true\n * isString(42); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a String, else `false`.\n */\nexport function isString(arg: unknown): arg is string {\n  return typeof arg === 'string';\n}\n\nexport const IS_STRING_ERROR_MSG = 'Expected a string';\n","import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isString } from '../typed/isString';\n\n// #region ChunkTypes\ntype ChunkOptions = {\n  overlap?: boolean;\n  pad?: string;\n};\n\ntype ChunkResult<T> = (T extends string ? string : T[])[];\n// #endregion ChunkTypes\n\n/**\n * Splits an array or string into chunks of a specified size.\n *\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]\n * chunk(\"hello\", 2) // [\"he\", \"ll\", \"o\"]\n * chunk(\"hello\", 2, { overlap: true }) // [\" h\", \"he\", \"el\", \"ll\", \"lo\", \"o \"]\n * ```\n *\n * @param input - The input array or string to be chunked.\n * @param size - The size of each chunk.\n * @param [options] - Additional options for chunking.\n * @param [options.overlap] -\n * @param [options.pad] -\n *\n * @returns An array of chunks.\n *\n * @throws {RangeError} If the chunk size is invalid.\n * @throws {TypeError} If the input type is invalid.\n */\nexport function chunk<T>(input: T[] | string, size = 2, options: ChunkOptions = {}): ChunkResult<T> {\n  assert(isArray(input as T[]) || isString(input), 'Argument must be an array or string.', {\n    args: { input },\n    type: TypeError,\n  });\n\n  assert(size >= 1, 'Chunk size must be at least 1.', {\n    args: { size },\n    type: RangeError,\n  });\n\n  const { overlap = false, pad = ' ' } = options;\n\n  if (isString(input) && overlap) {\n    const padded = pad + input + pad;\n    const numChunks = padded.length - size + 1;\n\n    return Array.from({ length: numChunks }, (_, i) => padded.slice(i, i + size)) as ChunkResult<T>;\n  }\n\n  return Array.from({ length: Math.ceil(input.length / size) }, (_, i) =>\n    input.slice(i * size, i * size + size),\n  ) as ChunkResult<T>;\n}\n","/**\n * Deeply compares two values for equality, including objects, arrays, and primitives.\n * Detects circular references and optimizes performance.\n *\n * @example\n * ```ts\n * isEqual([1, 2, 3], [1, 2, 3]); // true\n * isEqual([1, 2], [1, 2, 3]); // false\n * isEqual({ a: 1, b: 2 }, { a: 1, b: 2 }); // true\n * isEqual({ a: { b: 2 } }, { a: { b: 2 } }); // true\n * isEqual({ a: 1 }, { a: 2 }); // false\n * isEqual({ a: 1 }, { b: 1 }); // false\n * isEqual(new Date('2023-01-01'), new Date('2023-01-01')); // true\n * isEqual(new Date('2023-01-01'), new Date('2023-01-02')); // false\n * isEqual(new Date('2023-01-01'), 1); // false\n * ```\n *\n * @param a - First value to compare.\n * @param b - Second value to compare.\n * @returns Whether the values are deeply equal.\n */\nexport function isEqual(a: unknown, b: unknown): boolean {\n  return safeIsEqual(a, b, new WeakMap());\n}\n\nfunction safeIsEqual(a: unknown, b: unknown, visited: WeakMap<object, object>): boolean {\n  // Check for strict equality (handles primitives and references)\n  if (a === b) return true;\n\n  // If either is null or not an object, they're not equal\n  if (a == null || b == null || typeof a !== typeof b || typeof a !== 'object' || typeof b !== 'object') return false;\n\n  // Check for circular references\n  // We only track 'a' because if 'a' is cyclical, 'b' must also be cyclic to be equal\n  if (visited.has(a as object)) {\n    return visited.get(a as object) === b;\n  }\n\n  visited.set(a as object, b as object);\n\n  // Array comparison\n  if (Array.isArray(a) || Array.isArray(b)) {\n    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;\n\n    return a.every((item, idx) => safeIsEqual(item, b[idx], visited));\n  }\n\n  // Date comparison\n  if (a instanceof Date && b instanceof Date) {\n    return a.getTime() === b.getTime();\n  }\n\n  // Map comparison\n  if (a instanceof Map && b instanceof Map) {\n    if (a.size !== b.size) return false;\n\n    for (const [k, v] of a) {\n      if (!b.has(k) || !safeIsEqual(v, b.get(k), visited)) return false;\n    }\n\n    return true;\n  }\n\n  // Set comparison\n  if (a instanceof Set && b instanceof Set) {\n    if (a.size !== b.size) return false;\n\n    for (const v of a) {\n      if (![...b].some((bv) => safeIsEqual(v, bv, visited))) return false;\n    }\n\n    return true;\n  }\n\n  // Object comparison\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n\n  if (keysA.length !== keysB.length) return false;\n\n  for (const key of keysA) {\n    if (\n      !Object.hasOwn(b, key) ||\n      !safeIsEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key], visited)\n    )\n      return false;\n  }\n\n  return true;\n}\n\nexport const IS_EQUAL_ERROR_MSG = 'Expected two values to be equal';\n","import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isEqual } from '../typed/isEqual';\n\n/**\n * Checks if a value is present in an array.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, { a: 1 }, 'hello'];\n * const value = { a: 1 };\n * contains(arr, value) // true;\n * ```\n *\n * @param array - The array to check.\n * @param value - The value to search for.\n *\n * @returns true if the value is present in the array, else false.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\n\nexport function contains<T>(array: T[], value: unknown): boolean {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  return array.some((val) => isEqual(val, value));\n}\n","import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Folds an array down to a single value by applying a callback to each pair of\n * elements (reduce without an initial value).\n *\n * @example\n * ```ts\n * fold([1, 2, 3], (a, b) => a + b) // 6\n * fold([1, 2, 3], (a, b) => a > b ? a : b) // 3\n * fold([{ a: 1 }, { a: 2 }], (a, b) => ({ a: a.a + b.a })) // { a: 3 }\n * fold([], (a, b) => a + b) // undefined\n * fold([1], (a, b) => a + b) // 1\n * ```\n *\n * @param array - The array to fold.\n * @param callback - The function to invoke for each pair of elements.\n * @returns The folded value, or `undefined` if the array is empty.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function fold<T>(array: readonly T[], callback: (a: T, b: T) => T): T | undefined {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, {\n    args: { array, callback },\n    type: TypeError,\n  });\n\n  let result = array[0];\n\n  for (let i = 1; i < array.length; i++) {\n    result = callback(result, array[i]);\n  }\n\n  return result;\n}\n","import type { Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Groups the elements of an array based on the given key.\n *\n * @example\n * ```ts\n * const data = [{ a: 2 }, { a: 1 }];\n * group(data, 'a') // { '2': [{ a: 2 }], '1': [{ a: 1 }] };\n * ```\n *\n * @param array - The array to group.\n * @param selector - The function to generate the key for each element. It can be a string representing the key or a function that returns the key.\n *\n * @returns an object with keys as the grouped values and values as arrays of elements.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function group<T>(array: T[], selector: Selector<T>): Record<string, T[]> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result: Record<string, T[]> = {};\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  for (const item of array) {\n    const rawKey = getKey(item);\n    const key = rawKey === undefined || rawKey === null ? '_' : String(rawKey);\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n\n    result[key].push(item);\n  }\n\n  return result;\n}\n","import type { Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Creates an object keyed by a property or selector function. When multiple\n * items share the same key, the last one wins.\n *\n * @example\n * ```ts\n * const data = [{ a: 'x', v: 1 }, { a: 'y', v: 2 }, { a: 'x', v: 3 }];\n * keyBy(data, 'a') // { x: { a: 'x', v: 3 }, y: { a: 'y', v: 2 } }\n * keyBy(data, item => item.a) // same result\n * ```\n *\n * @param array - The array to index.\n * @param selector - A property key or a function returning the key for each element.\n * @returns A record mapping each key to the corresponding element.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function keyBy<T>(array: T[], selector: Selector<T>): Record<string, T> {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result: Record<string, T> = {};\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  for (const item of array) {\n    const key = String(getKey(item));\n\n    result[key] = item;\n  }\n\n  return result;\n}\n","/**\n * Calculate the similarity between two strings using the Levenshtein distance algorithm.\n *\n * @example\n * ```ts\n * similarity('abc', 'abc') // 1\n * similarity('a', 'b') // 0\n * similarity('ab', 'ac') // 0.5\n * similarity('doe', 'John Doe') // 0.25\n * similarity('abc', 'axc') // 0.6666666666666667\n * similarity('kitten', 'sitting') // 0.5714285714285714\n * ```\n *\n * @param str1 - The first string.\n * @param str2 - The second string.\n *\n * @returns A number between 0 and 1 representing the similarity between the two strings.\n */\nexport function similarity(str1: string, str2: string): number {\n  const a = str1.toLowerCase();\n  const b = str2.toLowerCase();\n\n  if (a === b) return 1;\n\n  if (a.length === 0) return b.length === 0 ? 1 : 0;\n\n  if (b.length === 0) return 0;\n\n  // Swap to ensure we use the smaller string for columns (O(min(A,B)) space)\n  const [shorter, longer] = a.length < b.length ? [a, b] : [b, a];\n  const shorterLength = shorter.length;\n  const longerLength = longer.length;\n\n  let prevRow = Array.from({ length: shorterLength + 1 }, (_, i) => i);\n  let currRow = new Array(shorterLength + 1);\n\n  for (let i = 1; i <= longerLength; i++) {\n    currRow[0] = i;\n    for (let j = 1; j <= shorterLength; j++) {\n      const cost = longer[i - 1] === shorter[j - 1] ? 0 : 1;\n\n      currRow[j] = Math.min(\n        currRow[j - 1] + 1, // insertion\n        prevRow[j] + 1, // deletion\n        prevRow[j - 1] + cost, // substitution\n      );\n    }\n    // Swap rows for the next iteration (avoid allocation)\n    [prevRow, currRow] = [currRow, prevRow];\n  }\n\n  // After the loop, a result is in prevRow because of the swap\n  const distance = prevRow[shorterLength];\n\n  return 1 - distance / Math.max(a.length, b.length);\n}\n","/**\n * Determines if the passed value is null or undefined.\n *\n * @example\n * ```ts\n * isNil(null); // true\n * isNil(undefined); // true\n * isNil(''); // false\n * isNil(0); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is null or undefined, else `false`.\n */\nexport function isNil(arg: unknown): arg is null | undefined {\n  return arg === undefined || arg === null;\n}\n","/**\n * Determines if the passed value is a number.\n *\n * @example\n * ```ts\n * isNumber(123); // true\n * isNumber('hello world'); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a number, else `false`.\n */\nexport function isNumber(arg: unknown): arg is number {\n  return typeof arg === 'number' && !Number.isNaN(arg);\n}\n\nexport const IS_NUMBER_ERROR_MSG = 'Expected a number';\n","/**\n * Determines if the passed value is an object.\n *\n * @example\n * ```ts\n * const value = { key: 'value' };\n * isObject(value); // true\n * isObject('hello world'); // false\n * isObject(value, 1); // false\n * isObject(value, value); // true\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is an object, else `false`.\n */\nexport function isObject(arg: unknown): arg is object {\n  return typeof arg === 'object' && arg !== null && !Array.isArray(arg);\n}\n\nexport const IS_OBJECT_ERROR_MSG = 'Expected an object';\n","import { isNumber } from './isNumber';\n\n/**\n * Checks if a value is within a specified range.\n *\n * @example\n * ```ts\n * isWithin(1, 0, 1); // true\n * isWithin(1, 0, 1, false); // false\n * isWithin(0.5, 0, 1); // true\n * ```\n *\n * @param arg - The value to be checked.\n * @param min - The minimum value of the range.\n * @param max - The maximum value of the range.\n * @param inclusive - Whether the range is inclusive or exclusive. (defaults: `true`).\n *\n * @returns `true` if the value is in between, else `false`.\n */\nexport function isWithin(arg: unknown, min: unknown, max: unknown, inclusive = true): boolean {\n  if (!isNumber(arg) || !isNumber(min) || !isNumber(max)) {\n    return false;\n  }\n\n  return inclusive ? arg >= min && arg <= max : arg > min && arg < max;\n}\n\nexport const IS_WITHIN_ERROR_MSG = 'Expected a number within a specified range';\n","import { assert } from '../function/assert';\nimport { similarity } from '../string/similarity';\nimport { isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport { isNumber } from '../typed/isNumber';\nimport { isObject } from '../typed/isObject';\nimport { isString } from '../typed/isString';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\n\n/**\n * Recursively checks if an object contains a value similar to the search string.\n *\n * @example\n * ```ts\n * const obj = { a: 'hello', b: { c: 'world' }, d: [1, 2, 3] };\n *\n * seek(obj, 'hello'); // true\n * seek(obj, 'world'); // true\n * seek(obj, 'foo'); // false\n * seek(obj, 'hello', 0.5); // true\n * seek(obj, 'hello', 0.8); // true\n * seek(obj, 'hello', 1); // true\n * seek(obj, 'hello', 1.5); // false\n * seek(obj, 'hello', -1); // false\n * seek(obj, 'hello', 0); // false\n * ```\n *\n * @param item - The object to search within.\n * @param query - The search string.\n * @param [tone=1] - The similarity threshold.\n *\n * @returns Whether the object contains a matching value.\n */\nfunction _seek<T>(item: T, query: string, tone: number): boolean {\n  if (isNil(item)) return false;\n\n  if (isString(item) || isNumber(item)) {\n    return similarity(String(item), query) >= tone;\n  }\n\n  if (isArray(item)) {\n    return (item as unknown[]).some((value) => _seek(value, query, tone));\n  }\n\n  if (isObject(item)) {\n    return Object.values(item as Record<string, unknown>).some((value) =>\n      isNil(value) ? false : _seek(value, query, tone),\n    );\n  }\n\n  return false;\n}\n\nexport function seek<T>(item: T, query: string, tone = 1): boolean {\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  return _seek(item, query, tone);\n}\n","import { assert } from '../function/assert';\nimport { seek } from '../object/seek';\nimport { IS_STRING_ERROR_MSG, isString } from '../typed/isString';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\n\n/**\n * Performs a search on an array of objects, checking all values for a match with the search string.\n *\n * @example\n * ```ts\n * const data = [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }];\n * search(data, 'doe', 0.5); // [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }]\n * ```\n *\n * @param array - The array of objects to search.\n * @param query - The string to search for.\n * @param [tone=0.25] - Degree of similarity between 0 and 1.\n *\n * @returns The filtered array of objects that match the search string.\n *\n * @throws {Error} If input values are invalid.\n */\nexport function search<T>(array: T[], query: string, tone = 0.25): T[] {\n  assert(isString(query), IS_STRING_ERROR_MSG, { args: { query }, type: TypeError });\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  if (!query) return [...array];\n\n  const searchTerm = query.toLowerCase();\n\n  return array.filter((obj) => seek(obj as object, searchTerm, tone));\n}\n","import type { Predicate, Sorter } from '../types';\n\nimport { search as defaultSearch } from './search';\n\n// #region BaseMeta\n/** Minimal pagination metadata shared by both `list` and `remoteList`. */\nexport type BaseMeta = Readonly<{\n  end: number;\n  isEmpty: boolean;\n  isFirst: boolean;\n  isLast: boolean;\n  limit: number;\n  page: number;\n  pages: number;\n  start: number;\n  total: number;\n}>;\n// #endregion BaseMeta\n\n// #region BaseList\n/**\n * Minimal shared interface satisfied by both `list()` and `remoteList()` results.\n * Use this type for code that works with either.\n */\nexport type BaseList<T> = {\n  readonly current: readonly T[];\n  readonly meta: BaseMeta;\n  subscribe(listener: () => void): () => void;\n};\n// #endregion BaseList\n\n// #region Meta\nexport type Meta = BaseMeta;\n// #endregion Meta\n\n// #region List\nexport type List<T, F, S> = {\n  // Batch updates across properties in one recompute/refetch\n  batch(\n    mutator: (ctx: {\n      goTo(p: number): void; // 1-based\n      setData?(d: readonly T[]): void; // local-only\n      setFilter(f: F): void;\n      setLimit(n: number): void;\n      setQuery(q: string): void;\n      setSort(s?: S): void;\n    }) => void,\n  ): void;\n  readonly current: readonly T[];\n  goTo(page: number): void;\n\n  readonly meta: Meta;\n  next(): void;\n  prev(): void;\n  reset(): void;\n  search(query: string, opts?: { immediate?: boolean }): void;\n  setData?(data: readonly T[]): void; // implemented by local\n  setFilter(filter: F): void;\n  setLimit(n: number): void;\n  setSort(sort?: S): void;\n\n  subscribe(listener: () => void): () => void;\n};\n// #endregion List\n\n// #region LocalConfig\ntype LocalConfig<T> = Readonly<{\n  debounceMs?: number;\n  filterFn?: Predicate<T>;\n  limit?: number;\n  searchFn?: (items: readonly T[], query: string, tone: number) => readonly T[];\n  searchTone?: number;\n  sortFn?: Sorter<T>;\n}>;\n// #endregion LocalConfig\n\nexport function list<T>(initialData: readonly T[], cfg: LocalConfig<T> = {}): List<T, Predicate<T>, Sorter<T>> {\n  const listeners = new Set<() => void>();\n\n  const DEFAULTS = { debounceMs: 300, limit: 10, searchTone: 0.5 } as const;\n\n  let rawData: readonly T[] = [...initialData];\n  let limit = Math.max(1, cfg.limit ?? DEFAULTS.limit);\n  let filterFn: Predicate<T> = cfg.filterFn ?? (() => true);\n  let sortFn: Sorter<T> | undefined = cfg.sortFn;\n  const searchFn = cfg.searchFn ?? ((items: readonly T[], q: string, t: number) => defaultSearch([...items], q, t));\n  const searchTone = cfg.searchTone ?? DEFAULTS.searchTone;\n\n  let query = '';\n  let offset = 0;\n  let view: readonly T[] = [];\n\n  const notify = () => {\n    for (const l of listeners) {\n      l();\n    }\n  };\n\n  const recompute = () => {\n    let arr = rawData;\n\n    if (query) arr = searchFn(arr, query, searchTone);\n\n    if (filterFn) arr = arr.filter(filterFn);\n\n    arr = sortFn ? [...arr].sort(sortFn) : [...arr];\n\n    const pages = Math.max(1, Math.ceil(arr.length / limit));\n\n    offset = Math.min(offset, pages - 1);\n    view = arr;\n  };\n\n  const slice = (): readonly T[] => {\n    if (!view.length) return [];\n\n    const start = offset * limit;\n\n    return view.slice(start, start + limit);\n  };\n\n  const update = () => {\n    recompute();\n    notify();\n  };\n\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const debouncedSearch = (q: string, ms: number) => {\n    if (timer) clearTimeout(timer);\n\n    timer = setTimeout(() => {\n      query = q;\n      timer = undefined;\n      void update();\n    }, ms);\n  };\n\n  // initial compute\n  recompute();\n\n  return {\n    batch(mutator) {\n      let nextLimit = limit;\n      let nextFilter = filterFn;\n      let nextSort = sortFn;\n      let nextQuery = query;\n      let nextData = rawData;\n      let nextOffset = offset;\n\n      const clamp = (i: number, total: number, lim: number) =>\n        Math.max(0, Math.min(i, Math.max(0, Math.ceil(total / lim) - 1)));\n\n      mutator({\n        goTo: (p) => {\n          nextOffset = clamp(p - 1, view.length, nextLimit);\n        },\n        setData: (d) => {\n          nextData = [...d];\n          nextOffset = 0;\n        },\n        setFilter: (f) => {\n          nextFilter = f;\n        },\n        setLimit: (n) => {\n          nextLimit = Math.max(1, n);\n        },\n        setQuery: (q) => {\n          nextQuery = q;\n          nextOffset = 0;\n        },\n        setSort: (s) => {\n          nextSort = s;\n        },\n      });\n\n      // apply once\n      limit = nextLimit;\n      filterFn = nextFilter;\n      sortFn = nextSort;\n      query = nextQuery;\n      rawData = nextData;\n      offset = nextOffset;\n\n      update();\n    },\n    get current() {\n      return slice();\n    },\n    goTo(page) {\n      const pages = Math.max(1, Math.ceil(view.length / limit));\n\n      offset = Math.max(0, Math.min(page - 1, pages - 1));\n      notify();\n    },\n    get meta() {\n      const total = view.length;\n      const pages = Math.max(1, Math.ceil(total / limit));\n      const isEmpty = total === 0;\n      const page = Math.min(offset + 1, pages);\n      const start = isEmpty ? 0 : (page - 1) * limit + 1;\n      const end = isEmpty ? 0 : Math.min(page * limit, total);\n\n      return {\n        end,\n        isEmpty,\n        isFirst: page <= 1,\n        isLast: page >= pages,\n        limit,\n        page,\n        pages,\n        start,\n        total,\n      };\n    },\n    next() {\n      const pages = Math.max(1, Math.ceil(view.length / limit));\n\n      if (offset < pages - 1) {\n        offset++;\n        notify();\n      }\n    },\n    prev() {\n      if (offset > 0) {\n        offset--;\n        notify();\n      }\n    },\n    reset() {\n      limit = Math.max(1, cfg.limit ?? DEFAULTS.limit);\n      filterFn = cfg.filterFn ?? (() => true);\n      sortFn = cfg.sortFn;\n      query = '';\n      offset = 0;\n      update();\n    },\n    search(q, opts) {\n      if (opts?.immediate) {\n        query = q;\n        offset = 0;\n        update();\n      } else {\n        debouncedSearch(q, cfg.debounceMs ?? DEFAULTS.debounceMs);\n      }\n    },\n    setData(data) {\n      rawData = [...data];\n      offset = 0;\n      update();\n    },\n    setFilter(f) {\n      filterFn = f;\n      offset = 0;\n      update();\n    },\n    setLimit(n) {\n      limit = Math.max(1, n);\n      offset = 0;\n      update();\n    },\n    setSort(s) {\n      sortFn = s;\n      update();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n\n      return () => listeners.delete(listener);\n    },\n  };\n}\n","import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\n\n/**\n * Picks the first element from an array that satisfies a predicate function\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * pick(arr, x => x * x, x => x > 2) // 9\n * ```\n *\n * @param array - The array to search.\n * @param callback - A function that is called for each element in the array.\n * @param predicate - A function that is called to validate each element in the array.\n *\n * @return The first element that satisfies the predicate, or undefined if no such element is found.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function pick<T, R = T>(\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => R,\n  predicate?: (item: T, index: number, array: T[]) => boolean,\n): R | undefined {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      return callback(array[index], index, array);\n    }\n  }\n\n  return undefined;\n}\n","import type { BaseList } from './list';\n\n// #region RemoteMeta\nexport type RemoteMeta = Readonly<{\n  end: number; // inclusive\n  error: string | null;\n  isEmpty: boolean;\n  isFirst: boolean;\n  isLast: boolean;\n  limit: number;\n  loading: boolean;\n  page: number; // 1-based\n  pages: number;\n  start: number; // 1-based\n  total: number;\n}>;\n// #endregion RemoteMeta\n\n// #region RemoteList\nexport type RemoteList<T, F, S> = BaseList<T> & {\n  // Batch updates across properties in one recompute/refetch\n  batch(\n    mutator: (ctx: {\n      goTo(p: number): void; // 1-based\n      setData?(d: readonly T[]): void; // local-only\n      setFilter(f: F): void;\n      setLimit(n: number): void;\n      setQuery(q: string): void;\n      setSort(s?: S): void;\n    }) => void,\n  ): Promise<void>;\n  readonly current: readonly T[];\n  goTo(page: number): Promise<void>;\n\n  invalidate?(): void;\n  readonly meta: RemoteMeta;\n  next(): Promise<void>;\n  prev(): Promise<void>;\n  refresh(): Promise<void>;\n  reset(): Promise<void>;\n  search(query: string, opts?: { immediate?: boolean }): Promise<void>;\n  setFilter(filter: F): Promise<void>;\n  setLimit(n: number): Promise<void>;\n  setSort(sort?: S): Promise<void>;\n  subscribe(listener: () => void): () => void;\n};\n// #endregion RemoteList\n\n// #region RemoteConfig\ntype RemoteQuery<F, S> = Readonly<{\n  filter?: F;\n  limit: number;\n  page: number; // 1-based\n  search?: string;\n  sort?: S;\n}>;\n\ntype RemoteResult<T> = Readonly<{ items: readonly T[]; total: number }>;\n\ntype RemoteConfig<T, F, S> = Readonly<{\n  cacheTtl?: number; // milliseconds; omit (or 0) to cache indefinitely\n  debounceMs?: number;\n  fetch: (q: RemoteQuery<F, S>) => Promise<RemoteResult<T>>;\n  initialFilter?: F;\n  initialSort?: S;\n  limit?: number;\n}>;\n// #endregion RemoteConfig\n\nexport function remoteList<T, F = Record<string, unknown>, S = { dir?: 'asc' | 'desc'; key?: string }>(\n  cfg: RemoteConfig<T, F, S>,\n): RemoteList<T, F, S> {\n  const listeners = new Set<() => void>();\n\n  const limitDefault = Math.max(1, cfg.limit ?? 10);\n  const debounceMs = cfg.debounceMs ?? 300;\n\n  let page = 1;\n  let limit = limitDefault;\n  let search = '';\n  let filter = cfg.initialFilter as F | undefined;\n  let sort = cfg.initialSort as S | undefined;\n\n  let items: readonly T[] = [];\n  let total = 0;\n  let loading = false;\n  let error: string | null = null;\n\n  const cache = new Map<string, { result: RemoteResult<T>; ts: number }>();\n  const inflight = new Map<string, Promise<void>>();\n\n  const keyOf = (q: RemoteQuery<F, S>) => JSON.stringify(q);\n  const queryOf = (): RemoteQuery<F, S> => ({\n    filter,\n    limit,\n    page,\n    search: search || undefined,\n    sort,\n  });\n\n  const assign = (res: RemoteResult<T>) => {\n    items = res.items;\n    total = res.total ?? 0;\n\n    const pages = Math.max(1, Math.ceil(total / limit));\n\n    page = Math.min(Math.max(1, page), pages);\n  };\n\n  const notify = () => {\n    for (const l of listeners) {\n      l();\n    }\n  };\n\n  const fetchQuery = async (q: RemoteQuery<F, S>) => {\n    const k = keyOf(q);\n    const entry = cache.get(k);\n    const ttl = cfg.cacheTtl;\n\n    if (entry && (!ttl || Date.now() - entry.ts < ttl)) {\n      assign(entry.result);\n\n      return;\n    }\n\n    if (inflight.has(k)) {\n      await inflight.get(k);\n      assign(cache.get(k)!.result);\n\n      return;\n    }\n\n    loading = true;\n    error = null;\n    notify();\n\n    const p = cfg\n      .fetch(q)\n      .then((res) => {\n        cache.set(k, { result: res, ts: Date.now() });\n        assign(res);\n      })\n      .catch((e) => {\n        error = e?.message ?? 'Request failed';\n        items = [];\n        total = 0;\n      })\n      .finally(() => {\n        inflight.delete(k);\n        loading = false;\n        notify();\n      });\n\n    inflight.set(k, p);\n    await p;\n  };\n\n  const update = async () => {\n    await fetchQuery(queryOf());\n  };\n\n  // debounced search\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const debounced = () => {\n    if (timer) clearTimeout(timer);\n\n    timer = setTimeout(() => {\n      timer = undefined;\n      void update();\n    }, debounceMs);\n  };\n\n  // initial fetch is on the first subscriber or call to refresh; up to you\n  return {\n    async batch(mutator) {\n      // Stage local copies\n      let nextPage = page;\n      let nextLimit = limit;\n      let nextSearch = search;\n      let nextFilter = filter as F | undefined;\n      let nextSort = sort as S | undefined;\n\n      mutator({\n        goTo: (p: number) => {\n          nextPage = Math.max(1, p | 0);\n        },\n        setFilter: (f: F) => {\n          nextFilter = f;\n          nextPage = 1;\n        },\n        setLimit: (n) => {\n          nextLimit = Math.max(1, n);\n          nextPage = 1;\n        },\n        setQuery: (q: string) => {\n          nextSearch = q;\n          nextPage = 1;\n        },\n        setSort: (s?: S) => {\n          nextSort = s;\n          nextPage = 1;\n        },\n      });\n\n      // Apply and update at once\n      page = nextPage;\n      limit = nextLimit;\n      search = nextSearch;\n      filter = nextFilter;\n      sort = nextSort;\n\n      await update();\n    },\n    get current() {\n      return items;\n    },\n    async goTo(p) {\n      page = Math.max(1, p | 0);\n      await update();\n    },\n    invalidate() {\n      cache.clear();\n    },\n    get meta() {\n      const isEmpty = total === 0;\n      const pages = Math.max(1, Math.ceil(total / limit));\n      const safePage = Math.min(page, pages);\n      const start = isEmpty ? 0 : (safePage - 1) * limit + 1;\n      const end = isEmpty ? 0 : Math.min(safePage * limit, total);\n\n      return {\n        end,\n        error,\n        isEmpty,\n        isFirst: safePage <= 1,\n        isLast: safePage >= pages,\n        limit,\n        loading,\n        page: safePage,\n        pages,\n        start,\n        total,\n      };\n    },\n    async next() {\n      page += 1;\n      await update();\n    },\n    async prev() {\n      page = Math.max(1, page - 1);\n      await update();\n    },\n    async refresh() {\n      cache.delete(keyOf(queryOf()));\n      await update();\n    },\n    async reset() {\n      page = 1;\n      limit = limitDefault;\n      search = '';\n      filter = cfg.initialFilter as F | undefined;\n      sort = cfg.initialSort as S | undefined;\n      cache.clear();\n      await update();\n    },\n    async search(q, opts) {\n      search = q;\n      page = 1;\n\n      if (opts?.immediate) await update();\n      else debounced();\n    },\n    async setFilter(f) {\n      filter = f;\n      page = 1;\n      await update();\n    },\n    async setLimit(n) {\n      limit = Math.max(1, n);\n      page = 1;\n      await update();\n    },\n    async setSort(s) {\n      sort = s;\n      page = 1;\n      await update();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n\n      // optional: trigger an initial load on the first subscription\n      if (listeners.size === 1 && items.length === 0 && !loading) {\n        void update();\n      }\n\n      return () => listeners.delete(listener);\n    },\n  };\n}\n","import type { Predicate } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Replaces the first element in an array that satisfies the provided predicate\n * function with a new value.\n *\n * @example\n * ```ts\n * replace([1, 2, 3], (n) => n === 2, 4) // [1, 4, 3]\n * ```\n *\n * @param array - The array to search.\n * @param predicate - A function to test each element of the array.\n * @param value - The new value to replace the found element.\n *\n * @return A new array with the replaced value.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function replace<T>(array: T[], predicate: Predicate<T>, value: T): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const index = array.findIndex(predicate);\n\n  if (index === -1) return array;\n\n  return [...array.slice(0, index), value, ...array.slice(index + 1)];\n}\n","import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { IS_NUMBER_ERROR_MSG, isNumber } from '../typed/isNumber';\n\n/**\n * Rotates the elements of an array by a specified number of positions.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * rotate(arr, 2); // [3, 4, 5]\n * rotate(arr, 2, { wrap: true }); // [3, 4, 5, 1, 2]\n * ```\n * @param array - The array to rotate.\n * @param positions - The number of positions to rotate the array.\n * @param [options] - Options for the rotate operation.\n * @param [options.wrap] - If `true`, the rotated-out elements are appended to the end.\n *\n * @returns A new array with the elements rotated.\n *\n * @throws {TypeError} If the first argument is not an array, or the second argument is not a number.\n */\nexport function rotate<T>(array: T[], positions: number, { wrap = false }: { wrap?: boolean } = {}): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n  assert(isNumber(positions), IS_NUMBER_ERROR_MSG, { args: { positions }, type: TypeError });\n\n  if (array.length === 0) return array;\n\n  const normalizedPos = ((positions % array.length) + array.length) % array.length;\n  const rotated = array.slice(normalizedPos);\n\n  return wrap ? [...rotated, ...array.slice(0, normalizedPos)] : rotated;\n}\n","import type { Predicate } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\n\n/**\n * Selects elements from an array based on a callback function and an optional predicate function.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * select(arr, x => x * x, x => x > 2) // [9, 16]\n * select(arr, x => x * x) // [1, 4, 9, 16]\n * ```\n *\n * @param array - The array to select from.\n * @param callback - The function to map the values.\n * @param [predicate] - (optional) The function to filter the values.\n *\n * @returns A new array with the selected values.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function select<T, R>(\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => R,\n  predicate?: Predicate<T>,\n): R[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const isValid = predicate ?? ((value: T) => !isNil(value));\n  const result: R[] = [];\n\n  for (let index = 0; index < array.length; index++) {\n    if (isValid(array[index], index, array)) {\n      result.push(callback(array[index], index, array));\n    }\n  }\n\n  return result;\n}\n","/**\n * Compares two values and returns:\n * - 0 if they are equal\n * - 1 if the first value is greater\n * - -1 if the second value is greater\n *\n * @example\n * ```ts\n * compare('a', 'b'); // -1\n * compare(1, 2); // -1\n * compare(new Date('2023-01-01'), new Date('2023-01-02')); // -1\n * compare('a', 'a'); // 0\n * compare(1, 1); // 0\n * compare(new Date('2023-01-01'), new Date('2023-01-01')); // 0\n * ```\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n *\n * @returns 0 if equal, 1 if the first value is greater, -1 if the second value is greater.\n */\nexport const compare = (a: unknown, b: unknown): number => {\n  if (a === b) return 0;\n\n  if (a === undefined) return 1;\n\n  if (b === undefined) return -1;\n\n  if (a === null) return b === null ? 0 : -1;\n\n  if (b === null) return 1;\n\n  if (typeof a === 'string' && typeof b === 'string') {\n    return a.localeCompare(b);\n  }\n\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a === b ? 0 : a > b ? 1 : -1;\n  }\n\n  if (a instanceof Date && b instanceof Date) {\n    const at = a.getTime();\n    const bt = b.getTime();\n\n    return at === bt ? 0 : at > bt ? 1 : -1;\n  }\n\n  if (typeof a === 'object' && typeof b === 'object') {\n    const aString = JSON.stringify(a);\n    const bString = JSON.stringify(b);\n\n    return aString.localeCompare(bString);\n  }\n\n  return String(a).localeCompare(String(b));\n};\n","import { compare } from './compare';\n\n/**\n * Compares two objects based on multiple selectors.\n * The comparison is done in the order of the selectors provided.\n * Each selector can be 'asc' for ascending or 'desc' for descending order.\n *\n * @example\n * ```ts\n * const compareByNameAndAge = compareBy<{ name: string; age: number }>({\n *   name: 'asc',\n *   age: 'desc',\n * });\n *\n * const a = { name: 'Alice', age: 30 };\n * const b = { name: 'Bob', age: 25 };\n *\n * console.log(compareByNameAndAge(a, b)); // -1 (Alice < Bob)\n * ```\n *\n * @param selectors - An object where keys are properties to compare and values are 'asc' or 'desc'.\n *\n * @returns A comparison function that can be used with array sorting methods.\n */\nexport const compareBy = <T>(selectors: Partial<Record<keyof T, 'asc' | 'desc'>>) => {\n  const entries = Object.entries(selectors) as [keyof T, 'asc' | 'desc'][];\n\n  return (a: T, b: T) => {\n    for (const [key, direction] of entries) {\n      const v1 = a[key];\n      const v2 = b[key];\n      const dir = direction === 'desc' ? -1 : 1;\n\n      const cmp = compare(v1, v2);\n\n      if (cmp !== 0) return cmp * dir;\n    }\n\n    return 0;\n  };\n};\n","import { assert } from '../function/assert';\nimport { compare } from '../function/compare';\nimport { compareBy } from '../function/compareBy';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\nexport type SortDirection = 'asc' | 'desc';\nexport type SortSelectors<T> = Partial<Record<keyof T, SortDirection>>;\n\n/**\n * Sorts an array by a selector function (single-field) or by a multi-field\n * object of `{ key: 'asc' | 'desc' }` entries.\n *\n * @example\n * ```ts\n * // Single field\n * sort([{ a: 2 }, { a: 1 }], item => item.a); // [{ a:1 }, { a:2 }]\n * sort([{ a: 2 }, { a: 1 }], item => item.a, 'desc'); // [{ a:2 }, { a:1 }]\n *\n * // Multi-field\n * sort(users, { name: 'asc', age: 'desc' });\n * ```\n *\n * @param array - The array to sort.\n * @param selector - A function extracting the sort key, or a multi-field object.\n * @param direction - `'asc'` (default) or `'desc'` — only applies to single-field mode.\n * @returns A new sorted array.\n *\n * @throws {TypeError} If the first argument is not an array.\n */\nexport function sort<T>(array: T[], selector: (item: T) => unknown, direction?: SortDirection): T[];\nexport function sort<T>(array: T[], selectors: SortSelectors<T>): T[];\nexport function sort<T>(\n  array: T[],\n  selectorOrSelectors: ((item: T) => unknown) | SortSelectors<T>,\n  direction: SortDirection = 'asc',\n): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  if (typeof selectorOrSelectors === 'function') {\n    const multiplier = direction === 'desc' ? -1 : 1;\n\n    return [...array].sort((a, b) => compare(selectorOrSelectors(a), selectorOrSelectors(b)) * multiplier);\n  }\n\n  return [...array].sort(compareBy(selectorOrSelectors));\n}\n","import type { Primitive } from '../types';\n\n/**\n * Either adds or removes an item from an array, based on whether it already\n * exists in the array (toggle behaviour).\n *\n * @example\n * ```ts\n * toggle([1, 2, 3], 4) // [1, 2, 3, 4]\n * toggle([1, 2, 3], 2) // [1, 3]\n *\n * toggle(\n *   [{ id: 1 }, { id: 2 }],\n *   { id: 3 },\n *   (obj) => obj.id,\n *   { strategy: 'prepend' }\n * ) // [{ id: 3 }, { id: 1 }, { id: 2 }]\n * ```\n *\n * @param array - The array to modify.\n * @param item - The item to add or remove.\n * @param selector - A function to determine item identity.\n * @param [options] - Options for the toggle operation.\n * @param [options.strategy] - Where to insert when adding: 'prepend' or 'append' (default).\n * @returns A new array with the item toggled.\n */\nexport function toggle<T>(\n  array: T[],\n  item: T,\n  selector?: (item: T) => Primitive,\n  options: { strategy?: 'prepend' | 'append' } = {},\n): T[] {\n  const { strategy = 'append' } = options;\n  const compareFn = selector ? (el: T) => selector(el) === selector(item) : (el: T) => el === item;\n\n  const index = array.findIndex(compareFn);\n\n  if (index !== -1) {\n    return [...array.slice(0, index), ...array.slice(index + 1)];\n  }\n\n  return strategy === 'prepend' ? [item, ...array] : [...array, item];\n}\n","import type { Primitive, Selector } from '../types';\n\nimport { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Creates a new array with duplicate values removed.\n *\n * @example\n * ```ts\n * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]\n * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];\n * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]\n * ```\n *\n * @param array - The array to process.\n * @param [selector] - The key(s) to compare objects or a function to generate comparison values.\n\n * @returns A new duplicate-free array.\n\n * @throws {TypeError} - If the input is not an array or if the key is invalid.\n */\nexport function uniq<T>(array: T[], selector?: Selector<T>): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { type: TypeError });\n\n  if (array.length <= 1) {\n    return [...array];\n  }\n\n  if (!selector) {\n    return [...new Set(array)];\n  }\n\n  const seen = new Set<Primitive>();\n  const getKey = typeof selector === 'function' ? selector : (item: T) => item[selector];\n\n  return array.filter((item) => {\n    const key = getKey(item) as Primitive;\n\n    if (seen.has(key)) {\n      return false;\n    }\n\n    seen.add(key);\n\n    return true;\n  });\n}\n","/**\n * Creates a Promise that can be aborted using an AbortController.\n *\n * @example\n * ```ts\n * const slowFn = () => new Promise(resolve => setTimeout(() => resolve('slow'), 10000));\n * const fastFn = () => new Promise(resolve => setTimeout(() => resolve('fast'), 5000));\n *\n * predict(slowFn); // rejects after 7 seconds\n * predict(fastFn); // resolves with 'fast' after 5 seconds\n * ```\n *\n * @param fn - The function to execute, which receives an AbortSignal.\n * @param options - The options for the abortable function.\n * @param [options.signal] - The AbortSignal to use for aborting the Promise.\n * @param [options.timeout=7000] - The timeout in milliseconds after which the Promise will be aborted.\n *\n * @returns - A Promise that resolves with the result of the callback or rejects if aborted.\n */\nexport function predict<T>(\n  fn: (signal: AbortSignal) => Promise<T>,\n  options: { signal?: AbortSignal; timeout?: number } = {},\n): Promise<T> {\n  const { signal, timeout = 7000 } = options;\n  const abortSignal = signal ? AbortSignal.any([AbortSignal.timeout(timeout), signal]) : AbortSignal.timeout(timeout);\n\n  return Promise.race([\n    fn(abortSignal),\n    new Promise<never>((_, reject) => {\n      abortSignal.addEventListener('abort', () => reject(abortSignal.reason), { once: true });\n    }),\n  ]);\n}\n","import { assert } from '../function/assert';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n *\n * @throws {TypeError} If timeout is not a non-negative number.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  assert(\n    typeof timeout === 'number' && timeout >= 0 && Number.isFinite(timeout),\n    'Timeout must be a non-negative finite number',\n    { args: { timeout }, type: TypeError },\n  );\n\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n","import { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.delay=250] - The delay in milliseconds between retries. Ignored when `retryDelay` is provided.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff). Ignored when `retryDelay` is provided.\n * @param [options.retryDelay] - Per-attempt delay function. `attempt` is 0-based (0 = waiting before the 2nd try). Supersedes `delay` and `backoff`.\n * @param [options.signal] - `AbortSignal` to cancel retries; throws the signal's `reason` on abort.\n * @param [options.shouldRetry] - Return `false` to stop retrying immediately for a specific error. `attempt` is 0-based failure count.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    backoff = 1,\n    delay = 250,\n    retryDelay,\n    shouldRetry,\n    signal,\n    times = 3,\n  }: {\n    backoff?: number | ((attempt: number, currentDelay: number) => number);\n    delay?: number;\n    /** Per-attempt delay override. `attempt` is 0-based (0 = before the 2nd try). Supersedes `delay` and `backoff`. */\n    retryDelay?: (attempt: number) => number;\n    /** Return `false` to stop retrying for a specific error. `attempt` is 0-based failure count. */\n    shouldRetry?: (error: unknown, attempt: number) => boolean;\n    signal?: AbortSignal;\n    times?: number;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) throw signal.reason ?? new DOMException('Retry aborted', 'AbortError');\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      if (shouldRetry && !shouldRetry(err, attempt - 1)) throw err;\n\n      const ms = retryDelay ? retryDelay(attempt - 1) : currentDelay;\n\n      if (ms > 0) await sleep(ms);\n\n      if (!retryDelay) {\n        currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n      }\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n","import type { Fn } from '../types';\n\nimport { predict } from './predict';\nimport { retry } from './retry';\n\ntype AttemptOptions = {\n  onError?: (err: unknown) => void;\n  timeout?: number;\n  times?: number;\n};\n\nexport type AttemptResult<R> = { ok: true; value: R } | { error: unknown; ok: false };\n\n/**\n * Attempts to execute a function with retry logic and an optional timeout.\n * Returns a discriminated union so callers can handle success and failure\n * explicitly without relying on `undefined`.\n *\n * @example\n * ```ts\n * const result = await attempt(fetchUser, { times: 3, timeout: 5000 });\n *\n * if (result.ok) {\n *   console.log(result.value);\n * } else {\n *   console.error(result.error);\n * }\n * ```\n *\n * @param fn - The function to be executed.\n * @param [options] - Configuration options.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.onError] - Called with the error when all attempts fail.\n * @param [options.timeout=7000] - Per-attempt timeout in milliseconds.\n *\n * @returns `{ ok: true, value }` on success or `{ ok: false, error }` on failure.\n */\nexport async function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(\n  fn: T,\n  { onError, timeout = 7000, times = 3 }: AttemptOptions = {},\n): Promise<AttemptResult<R>> {\n  try {\n    const value = await retry(() => predict<R>(() => fn(), { timeout }), { times });\n\n    return { ok: true, value };\n  } catch (err) {\n    onError?.(err);\n\n    return { error: err, ok: false };\n  }\n}\n","/**\n * Creates a deferred promise with resolve and reject methods exposed.\n * Useful for creating promises that are resolved/rejected externally.\n *\n * @example\n * ```ts\n * const deferred = defer<string>();\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!');\n * }, 1000);\n *\n * const result = await deferred.promise; // 'Done!'\n * ```\n *\n * @returns Object with promise and resolve/reject methods\n */\nexport function defer<T = void>(): {\n  promise: Promise<T>;\n  reject: (reason?: unknown) => void;\n  resolve: (value: T | PromiseLike<T>) => void;\n} {\n  const { promise, reject, resolve } = Promise.withResolvers<T>();\n\n  return { promise, reject, resolve };\n}\n","/**\n * Processes an array with an async callback with controlled parallelism.\n * Similar to Promise.all, but limits how many items are processed concurrently.\n * Returns an ordered array of results.\n *\n * @example\n * ```ts\n * // Process 3 items at a time\n * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {\n *   await delay(100);\n *   return n * 2;\n * });\n * // [2, 4, 6, 8, 10]\n *\n * // With abort signal\n * const controller = new AbortController();\n * const results = await parallel(2, items, async (item) => {\n *   return processItem(item);\n * }, controller.signal);\n * ```\n *\n * @param limit - Maximum number of concurrent operations (must be >= 1)\n * @param array - Array of items to process\n * @param callback - Async function to process each item\n * @param signal - Optional AbortSignal to cancel processing\n * @returns Promise resolving to an ordered array of results\n * @throws {Error} If limit is less than 1\n * @throws {DOMException} If aborted via signal\n */\nexport async function parallel<T, R>(\n  limit: number,\n  array: T[],\n  callback: (item: T, index: number, array: T[]) => Promise<R>,\n  signal?: AbortSignal,\n): Promise<R[]> {\n  if (limit < 1) {\n    throw new Error('Limit must be at least 1');\n  }\n\n  if (signal?.aborted) {\n    throw new DOMException('Aborted', 'AbortError');\n  }\n\n  const results: R[] = new Array(array.length);\n  let currentIndex = 0;\n  let hasError = false;\n  let error: unknown;\n\n  const worker = async (): Promise<void> => {\n    while (currentIndex < array.length && !hasError) {\n      if (signal?.aborted) {\n        hasError = true;\n        error = new DOMException('Aborted', 'AbortError');\n        break;\n      }\n\n      const index = currentIndex++;\n\n      try {\n        results[index] = await callback(array[index], index, array);\n      } catch (err) {\n        hasError = true;\n        error = err;\n        break;\n      }\n    }\n  };\n\n  // Create workers up to the limit\n  const workers: Promise<void>[] = [];\n  const workerCount = Math.min(limit, array.length);\n\n  for (let i = 0; i < workerCount; i++) {\n    workers.push(worker());\n  }\n\n  // Wait for all workers to complete\n  await Promise.all(workers);\n\n  // If there was an error, throw it\n  if (hasError) {\n    throw error;\n  }\n\n  return results;\n}\n","/**\n * Scheduler.postTask helper for environments with or without native support.\n *\n * `new Scheduler()` guarantees that `globalThis.scheduler.postTask` exists,\n * using the native API when available and installing a small fallback otherwise.\n *\n * `polyfillScheduler()` remains available when explicit installation is preferred.\n *\n * The polyfill provides:\n * - Delayed execution via the `delay` option\n * - AbortSignal support for cancellation\n * - Priority hint support (though priorities are not enforced in the polyfill)\n *\n * @example\n * ```ts\n * import { Scheduler } from '@vielzeug/toolkit';\n *\n * const scheduler = new Scheduler();\n * await scheduler.postTask(() => console.log('hello'), { delay: 100 });\n * ```\n */\n\nexport type TaskPriority = 'background' | 'user-blocking' | 'user-visible';\n\nexport type SchedulerLike = {\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T>;\n};\n\ntype SchedulerGlobal = { scheduler?: SchedulerLike };\n\nfunction createPolyfill(): SchedulerLike {\n  return {\n    postTask: <T>(\n      callback: () => T | PromiseLike<T>,\n      options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n    ) => {\n      const delay = options?.delay ?? 0;\n      const signal = options?.signal;\n\n      return new Promise<T>((resolve, reject) => {\n        if (signal?.aborted) {\n          reject(signal.reason);\n\n          return;\n        }\n\n        const id = setTimeout(() => {\n          signal?.removeEventListener('abort', onAbort);\n\n          try {\n            resolve(callback());\n          } catch (error) {\n            reject(error);\n          }\n        }, delay);\n\n        const onAbort = () => {\n          clearTimeout(id);\n          reject(signal!.reason);\n        };\n\n        signal?.addEventListener('abort', onAbort, { once: true });\n      });\n    },\n  };\n}\n\n/**\n * Install the scheduler polyfill if not natively supported.\n *\n * Safe to call multiple times - it only installs if not already present.\n */\nexport function polyfillScheduler(): void {\n  if ('scheduler' in globalThis) {\n    return;\n  }\n\n  Object.defineProperty(globalThis, 'scheduler', {\n    configurable: true,\n    value: createPolyfill(),\n    writable: true,\n  });\n}\n\n/**\n * Lightweight scheduler wrapper.\n *\n * Creating an instance guarantees that a scheduler exists (native or polyfilled)\n * and exposes a stable postTask API.\n */\nexport class Scheduler implements SchedulerLike {\n  #scheduler: SchedulerLike;\n\n  constructor() {\n    const g = globalThis as unknown as SchedulerGlobal;\n\n    if (g.scheduler === undefined) {\n      polyfillScheduler();\n    }\n\n    this.#scheduler = (globalThis as unknown as SchedulerGlobal).scheduler!;\n  }\n\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T> {\n    return this.#scheduler.postTask(callback, options);\n  }\n}\n","import { assert } from '../function/assert';\n\n/**\n * Creates a promise pool that limits the number of concurrent promises.\n * Useful for rate limiting API calls or controlling resource usage.\n *\n * @example\n * ```ts\n * const requestPool = pool(3);\n *\n * const results = await Promise.all([\n *   requestPool(() => fetch('/api/1')),\n *   requestPool(() => fetch('/api/2')),\n *   requestPool(() => fetch('/api/3')),\n *   requestPool(() => fetch('/api/4')), // Will wait for one of the above to finish\n * ]);\n * ```\n *\n * @param limit - Maximum number of concurrent promises\n * @returns Function that accepts a promise-returning function and executes it when a slot is available\n */\nexport function pool(limit: number): <T>(fn: () => Promise<T>) => Promise<T> {\n  assert(limit >= 1, 'Pool limit must be at least 1', { args: { limit }, type: RangeError });\n\n  let activeCount = 0;\n  const queue: Array<() => void> = [];\n\n  const dequeue = (): void => {\n    if (queue.length > 0 && activeCount < limit) {\n      const next = queue.shift();\n\n      next?.();\n    }\n  };\n\n  return async <T>(fn: () => Promise<T>): Promise<T> => {\n    while (activeCount >= limit) {\n      await new Promise<void>((resolve) => queue.push(resolve));\n    }\n\n    activeCount++;\n\n    try {\n      return await fn();\n    } finally {\n      activeCount--;\n      dequeue();\n    }\n  };\n}\n","import { assert } from '../function/assert';\nimport { Scheduler } from './scheduler';\n\n/**\n * Creates a promise queue that processes promises sequentially with optional concurrency limit.\n *\n * @example\n * ```ts\n * const requestQueue = queue({ concurrency: 2 });\n *\n * requestQueue.add(() => fetch('/api/1'));\n * requestQueue.add(() => fetch('/api/2'));\n * requestQueue.add(() => fetch('/api/3'));\n *\n * await requestQueue.onIdle(); // Wait for all tasks to complete\n * ```\n *\n * @param options - Queue configuration\n * @param options.concurrency - Maximum number of concurrent promises (default: 1)\n * @returns Queue instance with add, onIdle, and clear methods\n */\nexport function queue(options: { concurrency?: number } = {}) {\n  const { concurrency = 1 } = options;\n\n  assert(concurrency >= 1, 'Concurrency must be at least 1', {\n    args: { concurrency },\n    type: RangeError,\n  });\n\n  let activeCount = 0;\n  let idlePromise: Promise<void> | null = null;\n  let idleResolve: (() => void) | null = null;\n\n  const tasks: Array<{\n    fn: () => Promise<unknown>;\n    reject: (error: unknown) => void;\n    resolve: (value: unknown) => void;\n  }> = [];\n\n  let flushQueued = false;\n\n  const scheduleNext = (): void => {\n    if (flushQueued) return;\n\n    flushQueued = true;\n\n    const scheduler = new Scheduler();\n\n    void scheduler.postTask(\n      () => {\n        flushQueued = false;\n        next();\n      },\n      { priority: 'user-visible' },\n    );\n  };\n\n  const next = (): void => {\n    if (activeCount < concurrency && tasks.length > 0) {\n      const task = tasks.shift()!;\n\n      activeCount++;\n\n      task\n        .fn()\n        .then(task.resolve)\n        .catch(task.reject)\n        .finally(() => {\n          activeCount--;\n          scheduleNext();\n\n          if (activeCount === 0 && tasks.length === 0 && idleResolve) {\n            idleResolve();\n            idlePromise = null;\n            idleResolve = null;\n          }\n        });\n    }\n  };\n\n  return {\n    /**\n     * Adds a promise-returning function to the queue\n     */\n    add: <T>(fn: () => Promise<T>): Promise<T> => {\n      const { promise, reject, resolve } = Promise.withResolvers<T>();\n\n      tasks.push({\n        fn: fn as () => Promise<unknown>,\n        reject,\n        resolve: resolve as (value: unknown) => void,\n      });\n      scheduleNext();\n\n      return promise;\n    },\n\n    /**\n     * Clears all pending tasks from the queue\n     */\n    clear: (): void => {\n      tasks.length = 0;\n    },\n\n    /**\n     * Returns a promise that resolves when the queue becomes idle\n     */\n    onIdle: (): Promise<void> => {\n      if (activeCount === 0 && tasks.length === 0) {\n        return Promise.resolve();\n      }\n\n      if (!idlePromise) {\n        const deferred = Promise.withResolvers<void>();\n\n        idlePromise = deferred.promise;\n        idleResolve = deferred.resolve;\n      }\n\n      return idlePromise;\n    },\n\n    /**\n     * Returns the number of currently active promises\n     */\n    get pending(): number {\n      return activeCount;\n    },\n\n    /**\n     * Returns the current size of the queue\n     */\n    get size(): number {\n      return tasks.length;\n    },\n  };\n}\n","/**\n * Races a promise against a minimum delay, ensuring the result is not returned\n * before the minimum duration has elapsed. Useful for preventing loading flicker.\n *\n * @example\n * ```ts\n * // Show loading spinner for at least 500ms\n * const result = await race(fetchData(), 500);\n * ```\n *\n * @param promise - The promise to race\n * @param minDelay - Minimum delay in milliseconds before resolving\n * @returns Promise that resolves with the result after the minimum delay\n */\nexport async function race<T>(promise: Promise<T>, minDelay: number): Promise<T> {\n  const minDelayPromise = new Promise<void>((resolve) => setTimeout(resolve, minDelay));\n\n  const result = await promise;\n\n  await minDelayPromise;\n\n  return result;\n}\n","/**\n * Waits for a condition to become true by polling.\n * Useful for waiting for DOM elements, API states, or other conditions.\n *\n * @example\n * ```ts\n * // Wait for an element to appear\n * await waitFor(() => document.querySelector('#myElement') !== null);\n *\n * // Wait for API to be ready\n * await waitFor(\n *   async () => {\n *     const res = await fetch('/api/health');\n *     return res.ok;\n *   },\n *   { timeout: 30000, interval: 1000 }\n * );\n * ```\n *\n * @param condition - Function that returns true when condition is met\n * @param options - Configuration options\n * @param options.timeout - Maximum time to wait in ms (default: 5000)\n * @param options.interval - Polling interval in ms (default: 100)\n * @param options.signal - AbortSignal to cancel waiting\n * @returns Promise that resolves when condition becomes true\n * @throws {unknown} Rejects with the merged AbortSignal reason (timeout or abort)\n */\nexport async function waitFor(\n  condition: () => boolean | Promise<boolean>,\n  options: {\n    interval?: number;\n    signal?: AbortSignal;\n    timeout?: number;\n  } = {},\n): Promise<void> {\n  const { interval = 100, signal, timeout: timeoutMs = 5000 } = options;\n  const timeoutSignal = AbortSignal.timeout(timeoutMs);\n  const mergedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;\n\n  mergedSignal.throwIfAborted();\n\n  return new Promise<void>((resolve, reject) => {\n    let intervalId: ReturnType<typeof setTimeout> | null = null;\n\n    const cleanup = () => {\n      if (intervalId !== null) {\n        clearTimeout(intervalId);\n        intervalId = null;\n      }\n\n      mergedSignal.removeEventListener('abort', onAbort);\n    };\n\n    const onAbort = () => {\n      cleanup();\n      reject(mergedSignal.reason);\n    };\n\n    const check = async () => {\n      try {\n        if (mergedSignal.aborted) {\n          cleanup();\n          reject(mergedSignal.reason);\n\n          return;\n        }\n\n        const result = await condition();\n\n        if (result) {\n          cleanup();\n          resolve();\n\n          return;\n        }\n\n        intervalId = setTimeout(check, interval);\n      } catch (error) {\n        cleanup();\n        reject(error);\n      }\n    };\n\n    mergedSignal.addEventListener('abort', onAbort, { once: true });\n\n    // Start checking\n    check();\n  });\n}\n","// #region Expires\nexport type Expires = 'EXPIRED' | 'SOON' | 'LATER' | 'NEVER' | 'UNKNOWN';\n// #endregion Expires\n\n/**\n * Determines the expiry status of a given date.\n *\n * @param date - The date to check, as a string or Date object.\n * @param days - Number of days before expiry to be considered \"SOON\" (default: 7).\n * @returns\n *   - 'EXPIRED' if the date is in the past,\n *   - 'SOON' if the date is within the next `days`,\n *   - 'LATER' if the date is further in the future,\n *   - 'NEVER' if the year is >= 9999,\n *   - 'UNKNOWN' if the date is invalid.\n */\nexport function expires(date: string | Date, days = 7): Expires {\n  const target = typeof date === 'string' ? new Date(date) : date;\n  const targetTime = target.getTime();\n\n  if (Number.isNaN(targetTime)) return 'UNKNOWN';\n\n  if (target.getFullYear() >= 9999) return 'NEVER';\n\n  const now = Date.now();\n  const diff = targetTime - now;\n\n  if (diff <= 0) return 'EXPIRED';\n\n  if (diff <= days * 24 * 60 * 60 * 1000) return 'SOON';\n\n  return 'LATER';\n}\n","/**\n * Determines if the passed value is a valid Date Object.\n *\n * @example\n * ```ts\n * isDate(new Date()); // true\n * isDate(123); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a valid Date object, else `false`.\n */\nexport function isDate(arg: unknown): arg is Date {\n  return arg instanceof Date && !Number.isNaN(arg.getTime());\n}\n\nexport const IS_DATE_ERROR_MSG = 'Expected a Date object';\n","import { assertAll } from '../function/assert';\nimport { isDate } from '../typed/isDate';\n\n// #region IntervalTypes\ntype IntervalType = 'day' | 'week' | 'month' | 'monthStart' | 'monthEnd' | 'year' | 'yearStart' | 'yearEnd';\ntype IntervalOptions = {\n  interval?: IntervalType;\n  latest?: boolean;\n  steps?: number;\n};\n// #endregion IntervalTypes\n\n/**\n * Generates an array of dates between a start and end date, with a specified interval and step size.\n *\n * @example\n * ```ts\n * const options = { interval: 'day', steps: 1, latest: false };\n *\n * interval('2022-01-01', '2022-01-31', options); // Returns an array of dates for every day in January 2022\n * ```\n *\n * @param start - The start date (Date object or ISO string).\n * @param end - The end date (Date object or ISO string).\n * @param options - Options for an interval and steps.\n *\n * @returns An array of generated dates.\n */\nexport function interval(\n  start: Date | string,\n  end: Date | string,\n  { interval = 'day', latest = false, steps = 1 }: IntervalOptions = {},\n): Date[] {\n  const startDate = new Date(start);\n  const endDate = new Date(end);\n\n  assertAll([isDate(startDate), isDate(endDate)], 'Invalid date format. Use a valid Date object or ISO string.', {\n    args: { end, start },\n    type: TypeError,\n  });\n\n  const dateArray: Date[] = [];\n  let currentDate = new Date(incrementDate(startDate, interval, 0));\n\n  while (currentDate <= endDate) {\n    dateArray.push(currentDate);\n    currentDate = new Date(incrementDate(currentDate, interval, steps));\n  }\n\n  if (latest && dateArray.length > 0 && dateArray[dateArray.length - 1] < endDate) {\n    dateArray.push(endDate);\n  }\n\n  return dateArray;\n}\n\nfunction incrementDate(date: Date, interval: IntervalType, steps: number): Date {\n  const year = date.getFullYear();\n  const month = date.getMonth();\n  const day = date.getDate();\n\n  switch (interval) {\n    case 'day':\n      return new Date(Date.UTC(year, month, day + steps));\n    case 'month':\n      return new Date(Date.UTC(year, month + steps, day));\n    case 'monthEnd':\n      return new Date(Date.UTC(year, month + steps + 1, 0));\n    case 'monthStart':\n      return new Date(Date.UTC(year, month + steps, 1));\n    case 'week':\n      return new Date(Date.UTC(year, month, day + 7 * steps));\n    case 'year':\n      return new Date(Date.UTC(year + steps, month, day));\n    case 'yearEnd':\n      return new Date(Date.UTC(year + steps, 11, 31));\n    case 'yearStart':\n      return new Date(Date.UTC(year + steps, 0, 1));\n  }\n}\n","// #region TimeDiffTypes\nexport type TimeUnit = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';\nexport type TimeResult = { unit: TimeUnit; value: number };\n// #endregion TimeDiffTypes\n\nconst ALL_UNITS: TimeUnit[] = ['year', 'month', 'week', 'day', 'hour', 'minute', 'second'];\n\nconst MS_PER_SECOND = 1000;\nconst MS_PER_MINUTE = 60 * MS_PER_SECOND;\nconst MS_PER_HOUR = 60 * MS_PER_MINUTE;\nconst MS_PER_DAY = 24 * MS_PER_HOUR;\nconst MS_PER_WEEK = 7 * MS_PER_DAY;\nconst MS_PER_MONTH = 30 * MS_PER_DAY;\nconst MS_PER_YEAR = 365 * MS_PER_DAY;\n\nconst TIME_UNITS = [\n  { ms: MS_PER_YEAR, unit: 'year' as const },\n  { ms: MS_PER_MONTH, unit: 'month' as const },\n  { ms: MS_PER_WEEK, unit: 'week' as const },\n  { ms: MS_PER_DAY, unit: 'day' as const },\n  { ms: MS_PER_HOUR, unit: 'hour' as const },\n  { ms: MS_PER_MINUTE, unit: 'minute' as const },\n  { ms: MS_PER_SECOND, unit: 'second' as const },\n];\n\n/**\n * Calculates the remaining time until a target date.\n *\n * @example\n * ```ts\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 5)); // { value: 5, unit: 'day' }\n * timeDiff(new Date(Date.now() - 1000 * 60 * 60 * 24 * 3), 'past'); // { value: 3, unit: 'day' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 31)); // { value: 1, unit: 'month' }\n * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 365)); // { value: 1, unit: 'year' }\n * ```\n *\n * @param a - The target date (Date object or ISO string).\n * @param b - The target date (Date object or ISO string).\n * @param allowedUnits - (optional) array of units to filter the result. If provided, only these units will be considered.\n *\n * @returns An object containing the remaining time and its unit ('DAY', 'HOUR', or 'MINUTE').\n */\nexport function timeDiff(\n  a: Date | string,\n  b: Date | string = new Date(),\n  allowedUnits: TimeUnit[] = ALL_UNITS,\n): TimeResult | undefined {\n  const aDate = typeof a === 'string' ? Date.parse(a) : a.getTime();\n  const bDate = typeof b === 'string' ? Date.parse(b) : b.getTime();\n\n  if (Number.isNaN(aDate) || Number.isNaN(bDate)) {\n    return undefined;\n  }\n\n  const units = TIME_UNITS.filter((u) => allowedUnits.includes(u.unit));\n  const diff = Math.abs(aDate - bDate);\n  const smallestUnit = units[units.length - 1]?.unit ?? 'second';\n\n  if (diff <= 0) {\n    return { unit: smallestUnit, value: 0 };\n  }\n\n  // Find the largest unit that fits\n  const bestUnit = units.find((u) => diff >= u.ms);\n\n  if (bestUnit) {\n    return { unit: bestUnit.unit, value: Math.floor(diff / bestUnit.ms) };\n  }\n\n  return { unit: smallestUnit, value: 0 };\n}\n","import { assert } from './assert';\n\n/**\n * Asserts that the specified keys are present and non-null in the params object.\n *\n * @example\n * ```ts\n * const params = { id: '123', name: undefined };\n * assertParams(params, ['id']); // Does nothing\n * assertParams(params, ['id', 'name'], 'UserUpdate'); // Throws: Missing required parameter: \"name\" in \"UserUpdate\"\n * ```\n *\n * @param params - The object containing the parameters to check.\n * @param keys - An array of keys that must be present (not null or undefined) in the params object.\n * @param [name] - An optional name for the context of the assertion (e.g., function name).\n * @param [options] - Assertion options.\n * @param [options.type] - The error class to throw (default: `Error`).\n * @param [options.bypass] - If `true`, logs a warning instead of throwing an error.\n *\n * @throws {Error} If any of the required keys are missing.\n */\nexport function assertParams<T extends object, K extends keyof T>(\n  params: T,\n  keys: K[],\n  name?: string,\n  options: { bypass?: boolean; type?: ErrorConstructor } = {},\n): asserts params is T & Required<Pick<T, K>> {\n  assert(!!params, 'Missing parameters object', options);\n\n  const missing = keys.filter((key) => params[key] === undefined || params[key] === null);\n\n  if (missing.length > 0) {\n    const context = name ? ` in \"${name}\"` : '';\n    const keysStr = missing.map((key) => `\"${String(key)}\"`).join(', ');\n    const message = `Missing required parameter${missing.length > 1 ? 's' : ''}: ${keysStr}${context}`;\n\n    assert(false, message, options);\n  }\n}\n","import type { Fn } from '../types';\n\nimport { assert } from './assert';\n\ntype LastParameters<T> = T extends [...any, infer Last extends Fn] ? Parameters<Last> : never;\ntype FirstReturnType<F> = F extends [infer First extends Fn, ...any] ? ReturnType<First> : never;\n\n/**\n * Composes multiple functions into a single function. It starts from the rightmost function and proceeds to the left.\n *\n * @example\n * ```ts\n * const add = (x) => x + 2;\n * const multiply = (x) => x * 3;\n * const subtract = (x) => x - 4;\n * const composedFn = compose(subtract, multiply, add);\n * composedFn(5); // ((5 + 2) * 3) - 4 = 17\n * ```\n *\n * @param fns - List of the functions to be composed.\n *\n * @returns A new function that is the composition of the input functions.\n */\nexport function compose<T extends Fn[]>(...fns: T): (...args: LastParameters<T>) => FirstReturnType<T> {\n  assert(fns.length > 0, 'compose requires at least one function', { args: { fns } });\n\n  const lastFn = fns[fns.length - 1];\n  const restFns = fns.slice(0, -1);\n\n  return ((...args: LastParameters<T>) => restFns.reduceRight((prev, fn) => fn(prev), lastFn(...args))) as (\n    ...args: LastParameters<T>\n  ) => FirstReturnType<T>;\n}\n","/**\n * Curries a function, allowing it to be called with partial arguments.\n *\n * @example\n * ```ts\n * const add = (a: number, b: number) => a + b;\n * const curriedAdd = curry(add);\n * curriedAdd(1)(2) // 3;\n * ```\n *\n * @param fn - The function to curry.\n * @param arity - The number of arguments the function expects. Defaults to the function's length.\n *\n * @returns A curried version of the function.\n */\n\n// Take first N items from tuple T\ntype Take<N extends number, T extends readonly unknown[], Acc extends readonly unknown[] = []> = Acc['length'] extends N\n  ? Acc\n  : T extends readonly [infer H, ...infer R]\n    ? Take<N, R, readonly [...Acc, H]>\n    : Acc;\n// Curried: at each step, accept a non-empty tuple of args A,\n// ensure it's a prefix of P, then either return R (if done) or recurse.\nexport type Curried<P extends readonly unknown[], R> = P extends readonly []\n  ? () => R\n  : <A extends readonly [unknown, ...(readonly unknown[])]>(\n      ...args: A\n    ) => P extends readonly [...A, ...infer Rest] ? (Rest extends readonly [] ? R : Curried<Rest, R>) : never;\n// Overloads to reflect default arity vs. a custom arity.\nexport function curry<T extends (...args: any[]) => any>(fn: T): Curried<Parameters<T>, ReturnType<T>>;\nexport function curry<T extends (...args: any[]) => any, N extends number>(\n  fn: T,\n  arity: N,\n): Curried<Take<N, Parameters<T>>, ReturnType<T>>;\n// Runtime implementation\nexport function curry(fn: (...args: any[]) => any, arity = fn.length) {\n  const curried = (...args: any[]): any => {\n    if (args.length >= arity) {\n      return fn(...args);\n    }\n\n    return (...rest: any[]) => curried(...args, ...rest);\n  };\n\n  return curried as any;\n}\n","import type { Fn } from '../types';\n\nimport { Scheduler } from '../async/scheduler';\nimport { assert } from './assert';\n\nexport type Debounced<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {\n  cancel(): void;\n  flush(): ReturnType<T> | undefined;\n  pending(): boolean;\n};\n\n/**\n * Debounce a function (trailing). Use `flush` to invoke immediately,\n * `cancel` to clear, and `pending` to check if an invocation is scheduled.\n */\nexport function debounce<T extends Fn>(fn: T, delay = 300): Debounced<T> {\n  assert(typeof fn === 'function', 'First argument must be a function', {\n    args: { fn },\n    type: TypeError,\n  });\n  assert(typeof delay === 'number' && delay >= 0, 'Delay must be a non-negative number', {\n    args: { delay },\n    type: TypeError,\n  });\n\n  let timerController: AbortController | undefined;\n  let lastArgs: Parameters<T> | undefined;\n  let lastThis: ThisParameterType<T> | undefined;\n\n  const clearTimer = () => {\n    if (timerController !== undefined) {\n      timerController.abort();\n      timerController = undefined;\n    }\n  };\n\n  const scheduleInvoke = () => {\n    const controller = new AbortController();\n    const scheduler = new Scheduler();\n\n    timerController = controller;\n    void scheduler\n      .postTask(invoke, {\n        delay,\n        priority: 'user-visible',\n        signal: controller.signal,\n      })\n      .catch(() => {\n        // Aborts are expected when debounce is rescheduled or canceled.\n      });\n  };\n\n  const invoke = () => {\n    clearTimer();\n\n    if (!lastArgs) return undefined; // nothing to invoke\n\n    const args = lastArgs;\n    const ctx = lastThis as ThisParameterType<T>;\n\n    lastArgs = undefined;\n    lastThis = undefined;\n\n    return fn.apply(ctx as any, args) as ReturnType<T>;\n  };\n\n  const debounced = function (this: ThisParameterType<T>, ...args: Parameters<T>) {\n    lastArgs = args;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    lastThis = this;\n    clearTimer();\n    scheduleInvoke();\n  } as Debounced<T>;\n\n  debounced.cancel = () => {\n    clearTimer();\n    lastArgs = undefined;\n    lastThis = undefined;\n  };\n\n  debounced.flush = () => invoke() as ReturnType<T> | undefined;\n\n  debounced.pending = () => timerController !== undefined;\n\n  return debounced;\n}\n","import type { Fn } from '../types';\n\ntype RemoveFirstParameter<T extends Fn> = T extends (first: any, ...rest: infer R) => any ? R : never;\ntype FirstParameter<T extends Fn> = T extends (first: infer A, ...rest: any[]) => any ? A : never;\n\n/**\n * Partially applies a multi-arg function by pre-filling every argument\n * except the first — returning a unary function useful for pipeline composition.\n *\n * @example\n * ```ts\n * const double = (num: number) => num * 2;\n * const doubleAll = partial(select, double);\n * doubleAll([1, 2, 3]); // [2, 4, 6]\n *\n * // In a pipe\n * pipe(partial(select, (x: number) => x > 1 ? x * 2 : null))([1, 2, 3]); // [4, 6]\n * ```\n *\n * @param callback - Any function whose first argument is the collection.\n * @param args - The remaining arguments to pre-apply.\n * @returns A unary function `(collection) => ReturnType<F>`.\n */\nexport const partial = <F extends Fn>(callback: F, ...args: RemoveFirstParameter<F>) => {\n  return (collection: FirstParameter<F>) => callback(collection, ...args);\n};\n","import type { Fn } from '../types';\n\n// #region MemoizeOptions\ntype MemoizeOptions<T extends Fn> = {\n  maxSize?: number; // Maximum number of items in cache\n  resolver?: (...args: Parameters<T>) => string; // Custom key generator\n  ttl?: number; // Time-to-live in milliseconds\n};\n// #endregion MemoizeOptions\n\ntype CacheEntry<T extends Fn> = {\n  timestamp: number;\n  value: ReturnType<T>;\n};\n\n/**\n * Creates a function that memorizes the result of the provided function.\n * Supports expiration (TTL) and limited cache size (LRU).\n *\n * @example\n * ```ts\n * const add = (x, y) => x + y;\n * const memoizedAdd = memo(add, { ttl: 5000, maxSize: 10 });\n *\n * memoizedAdd(1, 2); // 3 (caches the result)\n * memoizedAdd(1, 2); // 3 (from cache)\n * ```\n *\n * @param fn - The function to memorize.\n * @param options - Memoization options.\n * @param [options.ttl] - (optional) time-to-live (TTL) for cache expiration (in milliseconds).\n * @param [options.maxSize] - (optional) maximum cache size (LRU eviction).\n * @param [options.resolver] - (optional) custom function to resolve the cache key.\n *\n * @returns A new function that memorizes the input function.\n */\nexport function memo<T extends Fn>(\n  fn: T,\n  { maxSize, resolver, ttl }: MemoizeOptions<T> = {},\n): (...args: Parameters<T>) => ReturnType<T> {\n  const cache = new Map<string, CacheEntry<T>>();\n\n  const keyGen = (args: Parameters<T>): string => {\n    if (resolver) return resolver(...args);\n\n    // Use a replacer to distinguish undefined from null (JSON.stringify collapses both to null)\n    return JSON.stringify(args, (_, v) => (v === undefined ? '__undefined__' : v));\n  };\n\n  return (...args: Parameters<T>): ReturnType<T> => {\n    const key = keyGen(args);\n    const now = Date.now();\n    const cached = cache.get(key);\n\n    if (cached && (!ttl || now - cached.timestamp < ttl)) {\n      cache.delete(key);\n      cache.set(key, cached); // Move to end (most recently used)\n\n      return cached.value;\n    }\n\n    const result = fn(...args);\n\n    cache.set(key, { timestamp: now, value: result });\n\n    if (result instanceof Promise) {\n      // Evict on rejection so subsequent calls retry instead of returning a settled failure\n      (result as Promise<unknown>).catch(() => cache.delete(key));\n    }\n\n    if (maxSize && cache.size > maxSize) {\n      cache.delete(cache.keys().next().value!); // Remove least recently used\n    }\n\n    return result;\n  };\n}\n","import type { Fn } from '../types';\n\n/**\n * Create a function that runs once and returns the first result.\n *\n * @example\n * ```ts\n * const onceRandom = once(() => Math.random())\n * onceRandom() // 0.3\n * onceRandom() // 0.3\n *\n * onceRandom.reset()\n *\n * onceRandom() // 0.2\n * onceRandom() // 0.2\n * ```\n *\n * @param fn - The function to wrap.\n *\n * @returns A function that can only be called once.\n */\nexport const once = <T extends Fn>(fn: T): T & { reset: () => void } => {\n  let result: ReturnType<T> | undefined;\n  let called = false;\n\n  const wrappedFn = ((...args: Parameters<T>): ReturnType<T> => {\n    if (!called) {\n      result = fn(...args);\n      called = true;\n    }\n\n    return result as ReturnType<T>;\n  }) as T & { reset: () => void };\n\n  wrappedFn.reset = () => {\n    result = undefined;\n    called = false;\n  };\n\n  return wrappedFn;\n};\n","import type { Fn } from '../types';\n\nimport { assert } from './assert';\n\ntype FirstParameters<T> = T extends [infer First extends Fn, ...any] ? Parameters<First> : never;\ntype LastReturnType<T> = T extends [...any, infer Last extends Fn] ? ReturnType<Last> : never;\n\n/**\n * Pipes multiple functions into a single function. It starts from the leftmost function and proceeds to the right.\n *\n * @example\n * ```ts\n * const add = (x) => x + 2;\n * const multiply = (x) => x * 3;\n * const subtract = (x) => x - 4;\n * const pipedFn = pipe(subtract, multiply, add);\n *\n * pipedFn(5); // ((5-4) * 3) + 2 = 5\n * ```\n *\n * @param fns - List of functions to be piped.\n *\n * @returns A new function that is the pipe of the input functions.\n */\nexport function pipe<T extends Fn[]>(...fns: T): (...args: FirstParameters<T>) => LastReturnType<T> {\n  assert(fns.length > 0, 'pipe requires at least one function', { args: { fns } });\n\n  const [firstFn, ...restFns] = fns;\n\n  return ((...args: FirstParameters<T>) => restFns.reduce((prev, fn) => fn(prev), firstFn(...args))) as (\n    ...args: FirstParameters<T>\n  ) => LastReturnType<T>;\n}\n","import type { Fn } from '../types';\n\nimport { Scheduler } from '../async/scheduler';\nimport { assert } from './assert';\n\nexport type ThrottleOptions = {\n  leading?: boolean; // invoke at the start of the window\n  trailing?: boolean; // invoke at the end with the last args\n};\n\nexport type Throttled<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {\n  cancel(): void;\n  flush(): ReturnType<T> | undefined;\n  pending(): boolean; // whether there's a pending call that flush() would execute\n};\n\n/**\n * Throttles a function. By default, only the leading edge fires.\n * Pass `{ trailing: true }` to also invoke at the end of the throttle window.\n *\n * Example:\n * const fn = () => ...\n * const t = throttle(fn, 700);\n * const withTrailing = throttle(fn, 700, { trailing: true });\n */\nexport function throttle<T extends Fn>(\n  fn: T,\n  delay = 700,\n  options: ThrottleOptions = { leading: true, trailing: false },\n): Throttled<T> {\n  assert(typeof fn === 'function', 'First argument must be a function', {\n    args: { fn },\n    type: TypeError,\n  });\n  assert(typeof delay === 'number' && delay >= 0, 'Delay must be a non-negative number', {\n    args: { delay },\n    type: TypeError,\n  });\n\n  const leading = options.leading ?? true;\n  const trailing = options.trailing ?? false;\n\n  let timerController: AbortController | undefined;\n  let lastInvokeTime = 0;\n  let lastArgs: Parameters<T> | undefined;\n  let lastThis: ThisParameterType<T> | undefined;\n  let lastResult: ReturnType<T> | undefined;\n\n  const clearTimer = () => {\n    if (timerController !== undefined) {\n      timerController.abort();\n      timerController = undefined;\n    }\n  };\n\n  const scheduleTimer = (delayMs: number) => {\n    const controller = new AbortController();\n    const scheduler = new Scheduler();\n\n    timerController = controller;\n    void scheduler\n      .postTask(timerExpired, {\n        delay: delayMs,\n        priority: 'user-visible',\n        signal: controller.signal,\n      })\n      .catch(() => {\n        // Aborts are expected when throttle is rescheduled or canceled.\n      });\n  };\n\n  const invoke = (now: number) => {\n    lastInvokeTime = now;\n    clearTimer();\n\n    if (!lastArgs) return undefined;\n\n    const args = lastArgs;\n    const ctx = lastThis as ThisParameterType<T>;\n\n    lastArgs = undefined;\n    lastThis = undefined;\n    lastResult = fn.apply(ctx as any, args);\n\n    return lastResult;\n  };\n\n  const remaining = (now: number) => delay - (now - lastInvokeTime);\n\n  const timerExpired = () => {\n    const now = Date.now();\n\n    if (lastArgs && remaining(now) <= 0) {\n      // trailing edge invoke\n      invoke(now);\n    } else if (lastArgs) {\n      // reschedule until a window elapses\n      scheduleTimer(remaining(now));\n    } else {\n      clearTimer();\n    }\n  };\n\n  const throttled = function (this: ThisParameterType<T>, ...args: Parameters<T>) {\n    const now = Date.now();\n\n    if (lastInvokeTime === 0 && !leading) {\n      // If leading is false, start the window now but don't invoke immediately\n      lastInvokeTime = now;\n    }\n\n    lastArgs = args;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    lastThis = this;\n\n    const rem = remaining(now);\n\n    if (rem <= 0) {\n      // Window elapsed: invoke now\n      invoke(now);\n    } else if (trailing && !timerController) {\n      // Schedule trailing call if not already scheduled\n      scheduleTimer(rem);\n    }\n  } as Throttled<T>;\n\n  throttled.cancel = () => {\n    clearTimer();\n    lastArgs = undefined;\n    lastThis = undefined;\n    lastInvokeTime = 0;\n  };\n\n  throttled.flush = () => {\n    if (!lastArgs) return undefined;\n\n    const now = Date.now();\n\n    return invoke(now) as ReturnType<T> | undefined;\n  };\n\n  // Pending if a trailing call is scheduled OR there are queued args.\n  throttled.pending = () => lastArgs !== undefined || timerController !== undefined;\n\n  return throttled;\n}\n","/**\n * Returns the absolute value of a number.\n * Supports both regular numbers and bigint.\n *\n * @example\n * ```ts\n * abs(-5); // 5\n * abs(3); // 3\n * abs(-100n); // 100n\n * ```\n *\n * @param value - The number or bigint to get absolute value of\n * @returns Absolute value\n */\nexport function abs(value: number): number;\nexport function abs(value: bigint): bigint;\nexport function abs(value: number | bigint): number | bigint {\n  if (typeof value === 'bigint') {\n    return value < 0n ? -value : value;\n  }\n\n  return Math.abs(value);\n}\n","/**\n * Distributes an amount proportionally according to given ratios.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * Critical for financial operations like splitting payments to avoid rounding errors.\n *\n * @example\n * ```ts\n * // Split $100 in ratio 1:2:3\n * allocate(100, [1, 2, 3]);\n * // [17, 33, 50] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * allocate(10000n, [1, 1, 1]);\n * // [3334n, 3333n, 3333n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to allocate\n * @param ratios - Array of ratios for distribution\n * @returns Array of allocated amounts (sum equals original amount)\n * @throws {Error} If ratios array is empty or contains negative values\n */\nexport function allocate(amount: number, ratios: number[]): number[];\nexport function allocate(amount: bigint, ratios: number[]): bigint[];\nexport function allocate(amount: number | bigint, ratios: number[]): (number | bigint)[] {\n  if (ratios.length === 0) {\n    throw new Error('Ratios array cannot be empty');\n  }\n\n  if (ratios.some((r) => r < 0)) {\n    throw new Error('Ratios must be non-negative');\n  }\n\n  const totalRatio = ratios.reduce((sum, ratio) => sum + ratio, 0);\n\n  if (totalRatio === 0) {\n    throw new Error('Total ratio cannot be zero');\n  }\n\n  if (typeof amount === 'bigint') {\n    const results: bigint[] = [];\n    let remainder = amount;\n\n    for (let i = 0; i < ratios.length - 1; i++) {\n      const share = (amount * BigInt(Math.floor(ratios[i] * 1000000))) / BigInt(Math.floor(totalRatio * 1000000));\n\n      results.push(share);\n      remainder -= share;\n    }\n\n    // Last allocation gets the remainder to ensure exact sum\n    results.push(remainder);\n\n    return results;\n  }\n\n  // Handle number type\n  const results = Array.from({ length: ratios.length - 1 }, (_, i) => Math.floor((amount * ratios[i]) / totalRatio));\n\n  results.push(amount - results.reduce((s, v) => s + v, 0));\n\n  return results;\n}\n","/**\n * Sum numbers in an array or numbers mapped by a callback function.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]) // 6\n * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6\n * sum(['apple', 'banana', 'cherry']) // TypeError\n * ```\n *\n * @param array - The array to sum.\n * @param callback - An optional callback function to map the values.\n *\n * @returns The sum of the numbers in the array or the sum of the mapped values.\n */\nexport function sum<T>(array: T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  return array.reduce<number>((acc, item) => {\n    const val = callback ? callback(item) : (item as unknown as number);\n\n    if (Number.isNaN(val)) {\n      throw new TypeError('Cannot sum NaN values');\n    }\n\n    return acc + val;\n  }, 0);\n}\n","import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4, 5];\n * average(arr); // 3\n * average(arr, (num) => num * 2); // 6\n * ```\n *\n * @param array - The array to average.\n * @param callback - (optional) A callback function to map each item to a number.\n * @returns The average, or `undefined` if the array is empty or contains non-numeric values.\n */\nexport function average<T>(array: T[], callback?: (item: T) => number): number | undefined {\n  if (array.length === 0) return undefined;\n\n  try {\n    const result = sum(array, callback) / array.length;\n\n    return Number.isNaN(result) ? undefined : result;\n  } catch {\n    return undefined;\n  }\n}\n","/**\n * The `clamp` function restricts a number to be within a specified range.\n *\n * @example\n * ```ts\n * clamp(5, 1, 10) // 5\n * clamp(0, 1, 10) // 1\n * clamp(15, 1, 10) // 10\n * ```\n *\n * @param n - The number to be clamped.\n * @param min - The minimum value of the range.\n * @param max - The maximum value of the range.\n *\n * @returns The clamped number.\n */\nexport function clamp(n: number, min: number, max: number): number {\n  return Math.min(Math.max(n, min), max);\n}\n","/**\n * Distributes an amount evenly among N parties.\n * Handles rounding to ensure the sum equals the original amount exactly.\n * Useful for splitting bills, costs, or payments equally.\n *\n * @example\n * ```ts\n * // Split $100 among 3 people\n * distribute(100, 3);\n * // [34, 33, 33] - sum is exactly 100\n *\n * // Split with bigint (e.g., cents)\n * distribute(10000n, 3);\n * // [3334n, 3333n, 3333n] - sum is exactly 10000n\n * ```\n *\n * @param amount - Total amount to distribute\n * @param parts - Number of parts to divide into\n * @returns Array of distributed amounts (a sum equals original amount)\n * @throws {Error} If parts are less than 1\n */\nexport function distribute(amount: number, parts: number): number[];\nexport function distribute(amount: bigint, parts: number): bigint[];\nexport function distribute(amount: number | bigint, parts: number): (number | bigint)[] {\n  if (parts < 1) {\n    throw new Error('Parts must be at least 1');\n  }\n\n  if (typeof amount === 'bigint') {\n    const baseShare = amount / BigInt(parts);\n    const remainder = amount % BigInt(parts);\n    const results: bigint[] = [];\n\n    for (let i = 0; i < parts; i++) {\n      // Distribute the remainder to first items\n      results.push(BigInt(i) < remainder ? baseShare + 1n : baseShare);\n    }\n\n    return results;\n  }\n\n  // Handle number type\n  const baseShare = Math.floor(amount / parts);\n  const remainder = amount - baseShare * parts;\n\n  return Array.from({ length: parts }, (_, i) => (i < remainder ? baseShare + 1 : baseShare));\n}\n","/**\n * Creates an array of evenly-spaced numbers from `start` to `end`.\n *\n * @example\n * ```ts\n * linspace(0, 10);        // [0, 2.5, 5, 7.5, 10]\n * linspace(0, 10, 3);     // [0, 5, 10]\n * linspace(0, 10, 1);     // [0]\n * linspace(10, 0, 5);     // [10, 7.5, 5, 2.5, 0]\n * ```\n *\n * @param start - The start of the range.\n * @param end - The end of the range.\n * @param steps - Number of evenly-spaced points to generate (default: 5).\n *\n * @returns An array of `steps` numbers from `start` to `end`.\n */\nexport function linspace(start: number, end: number, steps = 5): number[] {\n  if (steps <= 0) return [];\n\n  if (steps === 1) return [start];\n\n  const stepSize = (end - start) / (steps - 1);\n\n  return Array.from({ length: steps }, (_, i) => start + i * stepSize);\n}\n","import { fold } from '../array/fold';\nimport { compare } from '../function/compare';\n\n/**\n * Finds the maximum item in an array.\n *\n * @description\n * This function can be used to find the maximum number, string, or any other type of item in an array.\n *\n * @example\n * ```ts\n * max([1, 2, 3]); // 3\n * max([{ value: 1 }, { value: 2 }, { value: 3 }], item => item.value); // 3\n * max(['apple', 'banana', 'cherry']); // 'cherry'\n * max([new Date('2023-01-01'), new Date('2022-01-01')]); // 2023-01-01\n * ```\n *\n * @param array - The array to be searched.\n * @param [callback] - (optional) The function to invoke for each element in the array to determine its value.\n *\n * @return The item with the maximum value as determined by the callback function.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function max<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  const fn = callback ?? ((item: T) => item);\n\n  return fold(array, (a, b) => (compare(fn(a), fn(b)) > 0 ? a : b));\n}\n","/**\n * Returns the median of an array of numbers.\n *\n * @example\n * ```ts\n * median([1, 2, 3, 4, 100]); // 3\n * median([1, 2, 3, 4, 5], (n) => n * 2); // 6\n * median([]); // undefined\n * median([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); // 5.5\n * ```\n *\n * @param arr - The array of numbers.\n * @param callback - (optional) A callback function to map each item to a number.\n * @returns The median, or `undefined` if the array is empty.\n */\nexport function median<T>(arr: T[], callback?: (item: T) => number): number | undefined {\n  if (arr.length === 0) return undefined;\n\n  const values = callback ? arr.map(callback) : [...(arr as unknown as number[])];\n\n  values.sort((a, b) => a - b);\n\n  const mid = Math.floor(values.length / 2);\n\n  return values.length % 2 === 0 ? (values[mid - 1] + values[mid]) / 2 : values[mid];\n}\n","import { fold } from '../array/fold';\nimport { compare } from '../function/compare';\n\n/**\n * Finds the minimum item in an array.\n *\n * @description\n * This function can be used to find the minimum number, string, or any other type of item in an array.\n *\n * @example\n * ```ts\n * min([1, 2, 3]); // 1\n * min([{ value: 1 }, { value: 2 }, { value: 3 }], item => item.value); // 1\n * min(['apple', 'banana', 'cherry']); // 'apple'\n * min([new Date('2023-01-01'), new Date('2022-01-01')]); // 2022-01-01\n * ```\n *\n * @param array - The array to be searched.\n * @param [callback] - (optional) The function to invoke for each element in the array to determine its value.\n *\n * @return The item with the minimum value as determined by the callback function.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function min<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined {\n  const fn = callback ?? ((item: T) => item);\n\n  return fold(array, (a, b) => (compare(fn(a), fn(b)) < 0 ? a : b));\n}\n","/**\n * Calculates what percentage `value` is of `total`.\n *\n * @example\n * ```ts\n * percent(25, 100);  // 25\n * percent(1, 3);     // 33.333...\n * percent(50, 200);  // 25\n * percent(0, 100);   // 0\n * percent(5, 0);     // 0\n * ```\n *\n * @param value - The partial value.\n * @param total - The total value.\n *\n * @returns The percentage (0–100 scale). Returns 0 when `total` is 0.\n */\nexport function percent(value: number, total: number): number {\n  if (total === 0) return 0;\n\n  return (value / total) * 100;\n}\n","import { assert } from '../function/assert';\n\n/**\n * Creates an array of numbers progressing from start up to, but not including, end. A step is used to specify the difference between each number in the array.\n *\n * @example\n * ```ts\n * const start = 0;\n * const stop = 10;\n * const step = 2;\n *\n * range(start, stop, step) // [0, 2, 4, 6, 8];\n * ```\n *\n * @param start - The start of the range.\n * @param stop - The end of the range.\n * @param step - The value to increment or decrement by.\n *\n * @returns The range of numbers.\n *\n * @throws {TypeError} If start, stop, or step are not finite numbers.\n * @throws {Error} If step is 0 or if range exceeds maximum size.\n */\nexport function range(start: number, stop: number, step: number) {\n  assert(\n    Number.isFinite(start) && Number.isFinite(stop) && Number.isFinite(step),\n    'start, stop, and step must be finite numbers',\n    { args: { start, step, stop }, type: TypeError },\n  );\n  assert(step !== 0, 'Step cannot be 0', { args: { step }, type: Error });\n\n  if (start === stop) {\n    return [];\n  }\n\n  const length = Math.max(0, Math.ceil((stop - start) / step + Number.EPSILON));\n\n  assert(length <= 10_000_000, 'Range exceeds maximum allowed size of 10,000,000', {\n    args: { length, start, step, stop },\n    type: Error,\n  });\n\n  return Array.from({ length }, (_, i) => start + i * step);\n}\n","/**\n * Rounds a number to a specified number of decimal places.\n *\n * The `precision` argument is limited to be within the range of -323 to +292 to avoid NaN results.\n *\n * @example\n * ```ts\n * round(123.456) // 123\n * round(123.456, -1) // 120\n * round(123.456, 1, Math.ceil) // 123.5\n * round(123.456, 1, Math.floor) // 123.4\n * ```\n *\n * @param value - The number to round.\n * @param precision - The number of decimal places to round to.\n * @param [parser] - (optional) function to convert the number to a value.\n *\n * @returns The rounded number.\n */\nexport function round(value: number, precision = 0, parser: (value: number) => number = Math.round): number {\n  if (precision === 0) return parser(value);\n\n  const factor = 10 ** Math.max(-323, Math.min(precision, 292));\n\n  return parser(value * factor) / factor;\n}\n","import type { Money } from './types';\n\n/**\n * Options for currency formatting.\n */\nexport type CurrencyFormatOptions = {\n  locale?: string; // BCP 47 language tag (e.g., 'en-US', 'de-DE')\n  maximumFractionDigits?: number; // Maximum decimal places\n  minimumFractionDigits?: number; // Minimum decimal places\n  style?: 'symbol' | 'code' | 'name'; // Display style\n};\n\n/**\n * Formats a monetary amount as a currency string with proper locale and symbol.\n * Handles decimal places automatically based on currency.\n *\n * @example\n * ```ts\n * const money = { amount: 123456n, currency: 'USD' };\n *\n * currency(money); // '$1,234.56' (default en-US)\n * currency(money, { locale: 'de-DE' }); // '1.234,56 $'\n * currency(money, { style: 'code' }); // 'USD 1,234.56'\n * currency(money, { style: 'name' }); // '1,234.56 US dollars'\n * ```\n *\n * @param money - Money object to format\n * @param options - Formatting options\n * @returns Formatted currency string\n */\nexport function currency(money: Money, options: CurrencyFormatOptions = {}): string {\n  const { locale = 'en-US', maximumFractionDigits, minimumFractionDigits, style = 'symbol' } = options;\n\n  // Get decimal places for currency (default to 2 for most currencies)\n  const decimalPlaces = getCurrencyDecimals(money.currency);\n\n  // Convert bigint amount to decimal (divide by 10^decimalPlaces)\n  const divisor = 10 ** decimalPlaces;\n  const amount = Number(money.amount) / divisor;\n\n  const formatter = new Intl.NumberFormat(locale, {\n    currency: money.currency,\n    currencyDisplay: style,\n    maximumFractionDigits: maximumFractionDigits ?? decimalPlaces,\n    minimumFractionDigits: minimumFractionDigits ?? decimalPlaces,\n    style: 'currency',\n  });\n\n  return formatter.format(amount);\n}\n\nfunction getCurrencyDecimals(currencyCode: string): number {\n  return (\n    new Intl.NumberFormat('en', { currency: currencyCode, style: 'currency' }).resolvedOptions()\n      .maximumFractionDigits ?? 2\n  );\n}\n","import type { Money } from './types';\n\n/**\n * Exchange rate for currency conversion.\n */\nexport type ExchangeRate = {\n  from: string; // Source currency code\n  rate: number; // Exchange rate multiplier\n  to: string; // Target currency code\n};\n\n/**\n * Converts money from one currency to another using the provided exchange rate.\n * Maintains precision by using bigint arithmetic.\n *\n * @example\n * ```ts\n * const usd = { amount: 100000n, currency: 'USD' }; // $1,000.00\n * const rate = { from: 'USD', to: 'EUR', rate: 0.85 };\n *\n * exchange(usd, rate);\n * // { amount: 85000n, currency: 'EUR' } // €850.00\n * ```\n *\n * @param money - Money to convert\n * @param rate - Exchange rate information\n * @returns Converted money in target currency\n * @throws {Error} If source currency doesn't match rate.from\n */\nexport function exchange(money: Money, rate: ExchangeRate): Money {\n  if (money.currency !== rate.from) {\n    throw new Error(`Currency mismatch: expected ${rate.from}, got ${money.currency}`);\n  }\n\n  // Convert rate to avoid floating point issues\n  // Multiply by 1000000 for precision, then divide back\n  const rateBigInt = BigInt(Math.round(rate.rate * 1000000));\n  const convertedAmount = (money.amount * rateBigInt) / 1000000n;\n\n  return {\n    amount: convertedAmount,\n    currency: rate.to,\n  };\n}\n","import { Scheduler, type SchedulerLike } from '../async';\n\ntype CacheKey = readonly unknown[];\n\ntype CacheRecord<K extends CacheKey, T, M> = {\n  key: K;\n  meta: M | undefined;\n  value: T;\n};\n\ntype GcTask = {\n  controller: AbortController;\n  token: number;\n};\n\nexport type CacheOptions<K extends CacheKey = CacheKey> = {\n  hash: (key: K) => string;\n  onError?: (error: unknown) => void;\n  scheduler?: Pick<SchedulerLike, 'postTask'>;\n};\n\nexport type CacheSetOptions<M> = {\n  meta?: M;\n  ttlMs?: number;\n};\n\nexport type Stash<T, K extends CacheKey = CacheKey, M = never> = {\n  cancelGc: (key: K) => void;\n  clear: () => void;\n  delete: (key: K) => boolean;\n  entries: () => IterableIterator<[K, T]>;\n  get: (key: K) => T | undefined;\n  getEntry: (key: K) => Readonly<{ meta: M | undefined; value: T }> | undefined;\n  getOrSet: (key: K, factory: () => T, options?: CacheSetOptions<M>) => T;\n  scheduleGc: (key: K, delayMs: number) => void;\n  set: (key: K, value: T, options?: CacheSetOptions<M>) => void;\n  size: () => number;\n  touch: (key: K, ttlMs: number) => boolean;\n};\n\n/**\n * Creates a generic key-value cache with automatic garbage collection and observer support.\n *\n * @example\n * ```ts\n * const myCache = stash<string>({ hash: (key) => JSON.stringify(key) });\n * myCache.set(['user', 1], 'John Doe');\n * const value = myCache.get(['user', 1]); // 'John Doe'\n * myCache.scheduleGc(['user', 1], 5000); // Auto-delete after 5s\n * ```\n *\n * @template T - The type of values stored in the cache.\n *\n * @returns A cache instance with get, set, delete, clear, and GC methods.\n */\nexport function stash<T, K extends CacheKey = CacheKey, M = never>(options: CacheOptions<K>): Stash<T, K, M> {\n  const store = new Map<string, CacheRecord<K, T, M>>();\n  const gcTasks = new Map<string, GcTask>();\n  const scheduler = options.scheduler ?? new Scheduler();\n  const hash = options.hash;\n  let gcToken = 0;\n\n  function cancelGcByHash(keyHash: string): void {\n    gcTasks.get(keyHash)?.controller.abort();\n    gcTasks.delete(keyHash);\n  }\n\n  function deleteByHash(keyHash: string): boolean {\n    const existed = store.has(keyHash);\n\n    cancelGcByHash(keyHash);\n    store.delete(keyHash);\n\n    return existed;\n  }\n\n  function get(key: K): T | undefined {\n    return store.get(hash(key))?.value;\n  }\n\n  function getEntry(key: K): Readonly<{ meta: M | undefined; value: T }> | undefined {\n    const entry = store.get(hash(key));\n\n    if (!entry) {\n      return undefined;\n    }\n\n    return { meta: entry.meta, value: entry.value };\n  }\n\n  function set(key: K, value: T, options?: CacheSetOptions<M>): void {\n    const keyHash = hash(key);\n    const existing = store.get(keyHash);\n\n    cancelGcByHash(keyHash);\n    store.set(keyHash, {\n      key,\n      meta: options && 'meta' in options ? options.meta : existing?.meta,\n      value,\n    });\n\n    if (options?.ttlMs !== undefined) {\n      scheduleGc(key, options.ttlMs);\n    }\n  }\n\n  function getOrSet(key: K, factory: () => T, options?: CacheSetOptions<M>): T {\n    const existing = getEntry(key);\n\n    if (existing) {\n      return existing.value;\n    }\n\n    const value = factory();\n\n    set(key, value, options);\n\n    return value;\n  }\n\n  function del(key: K): boolean {\n    return deleteByHash(hash(key));\n  }\n\n  function clear(): void {\n    for (const task of gcTasks.values()) task.controller.abort();\n    store.clear();\n    gcTasks.clear();\n  }\n\n  function size(): number {\n    return store.size;\n  }\n\n  function scheduleGcByHash(keyHash: string, delayMs: number): void {\n    cancelGcByHash(keyHash);\n\n    if (delayMs === Number.POSITIVE_INFINITY) {\n      return;\n    }\n\n    if (!Number.isFinite(delayMs)) {\n      throw new TypeError('stash.scheduleGc expects a finite number or Infinity');\n    }\n\n    if (delayMs <= 0) {\n      deleteByHash(keyHash);\n\n      return;\n    }\n\n    if (!store.has(keyHash)) {\n      return;\n    }\n\n    const controller = new AbortController();\n    const token = ++gcToken;\n\n    gcTasks.set(keyHash, { controller, token });\n    void scheduler\n      .postTask(\n        () => {\n          const current = gcTasks.get(keyHash);\n\n          if (!current || current.token !== token) {\n            return;\n          }\n\n          gcTasks.delete(keyHash);\n\n          deleteByHash(keyHash);\n        },\n        {\n          delay: delayMs,\n          priority: 'background',\n          signal: controller.signal,\n        },\n      )\n      .catch((error) => {\n        if (error instanceof DOMException && error.name === 'AbortError') {\n          return;\n        }\n\n        options.onError?.(error);\n      });\n  }\n\n  function scheduleGc(key: K, delayMs: number): void {\n    scheduleGcByHash(hash(key), delayMs);\n  }\n\n  function cancelGc(key: K): void {\n    cancelGcByHash(hash(key));\n  }\n\n  function touch(key: K, ttlMs: number): boolean {\n    const keyHash = hash(key);\n\n    if (!store.has(keyHash)) {\n      return false;\n    }\n\n    scheduleGcByHash(keyHash, ttlMs);\n\n    return true;\n  }\n\n  function* entries(): IterableIterator<[K, T]> {\n    for (const record of store.values()) {\n      yield [record.key, record.value];\n    }\n  }\n\n  return {\n    cancelGc,\n    clear,\n    delete: del,\n    entries,\n    get,\n    getEntry,\n    getOrSet,\n    scheduleGc,\n    set,\n    size,\n    touch,\n  };\n}\n","import type { Obj } from '../types';\n\nimport { isEqual } from '../typed/isEqual';\nimport { isObject } from '../typed/isObject';\n\n/** Sentinel value returned by `diff` when a key exists in `prev` but not in `curr`. */\nexport const DELETED: unique symbol = Symbol('deleted');\n\nexport type DiffResult<T extends Obj> = { [K in keyof T]?: T[K] | typeof DELETED };\n\n/**\n * Computes the difference between two objects.\n *\n * Keys present in `prev` but absent in `curr` are marked with the `DELETED` sentinel.\n *\n * @example\n * ```ts\n * import { diff, DELETED } from '@vielzeug/toolkit';\n *\n * diff({ a: 1, b: 2 }, { a: 1, b: 2, c: 3 }); // { c: DELETED }\n * diff({ a: 1, b: 99 }, { a: 1, b: 2 });       // { b: 99 }\n * ```\n *\n * @param curr - The current object.\n * @param prev - The previous object.\n * @param [compareFn] - A custom function to compare values.\n * @returns An object containing new/modified/deleted properties.\n */\nexport function diff<T extends Obj>(\n  curr?: T,\n  prev?: T,\n  compareFn: (a: unknown, b: unknown) => boolean = isEqual,\n): DiffResult<T> {\n  if (!curr && !prev) return {};\n\n  const result: Record<string, unknown> = {};\n\n  for (const key of new Set([...Object.keys(curr ?? {}), ...Object.keys(prev ?? {})])) {\n    const _curr = curr?.[key];\n    const _prev = prev?.[key];\n\n    if (isObject(_curr) && isObject(_prev)) {\n      const nestedDiff = diff(_curr as Obj, _prev as Obj, compareFn);\n\n      if (Object.keys(nestedDiff).length > 0) {\n        result[key] = nestedDiff;\n      }\n    } else if (!compareFn(_curr, _prev)) {\n      const wasDeleted = prev != null && key in prev && (curr == null || !(key in curr));\n\n      result[key] = wasDeleted ? DELETED : _curr;\n    }\n  }\n\n  return result as DiffResult<T>;\n}\n","import type { Obj } from '../types';\n\nimport { isArray } from '../typed/isArray';\nimport { isObject } from '../typed/isObject';\n\n// #region MergeStrategy\ntype MergeStrategy =\n  | 'deep'\n  | 'shallow'\n  | 'lastWins'\n  | 'arrayConcat'\n  | 'arrayReplace'\n  | ((target: any, source: any) => any);\n// #endregion MergeStrategy\n\ntype DeepMerge<T, U> = T extends Obj\n  ? U extends Obj\n    ? {\n        [K in keyof T | keyof U]: K extends keyof T\n          ? K extends keyof U\n            ? DeepMerge<T[K], U[K]>\n            : T[K]\n          : K extends keyof U\n            ? U[K]\n            : never;\n      }\n    : U\n  : U;\n\ntype Merge<T extends Obj[]> = T extends [infer First, ...infer Rest]\n  ? First extends Obj\n    ? Rest extends Obj[]\n      ? DeepMerge<First, Merge<Rest>>\n      : First\n    : Obj\n  : Obj;\n\n/**\n * Merges multiple objects based on a specified merge strategy.\n *\n * @example\n * ```ts\n * const obj1 = { a: 1, b: { x: 10, y: \"hello\" }, c: [1] };\n * const obj2 = { b: { y: 20, z: true }, c: [2] };\n * const obj3 = { d: false, c: [3] };\n *\n * merge(\"deep\", obj1, obj2, obj3); // { a: 1, b: { x: 10, y: 20, z: true }, c: [1, 2, 3], d: false }\n * merge(\"shallow\", obj1, obj2, obj3); // { a: 1, b: { y: 20, z: true }, c: [3], d: false }\n * ```\n *\n * @param [strategy='deep'] - The merging strategy to use.\n * @param items - The objects to merge.\n * @returns A new merged object.\n */\nexport function merge<T extends Obj[]>(strategy: MergeStrategy = 'deep', ...items: [...T]): Merge<T> {\n  if (items.length === 0) return {} as Merge<T>;\n\n  if (strategy === 'shallow') {\n    return Object.assign({}, ...items) as Merge<T>;\n  }\n\n  return items.reduce((acc, obj) => mergeObjects(acc, obj, strategy) as unknown as Merge<T>, {} as Merge<T>);\n}\n\n/**\n * Merges objects deeply. Shorthand for `merge('deep', ...items)`.\n *\n * @example\n * ```ts\n * deepMerge({ a: { x: 1 } }, { a: { y: 2 } }); // { a: { x: 1, y: 2 } }\n * ```\n */\nexport function deepMerge<T extends Obj[]>(...items: [...T]): Merge<T> {\n  return merge('deep', ...items) as Merge<T>;\n}\n\n/**\n * Merges objects shallowly. Shorthand for `merge('shallow', ...items)`.\n *\n * @example\n * ```ts\n * shallowMerge({ a: 1, b: { x: 1 } }, { b: { y: 2 } }); // { a: 1, b: { y: 2 } }\n * ```\n */\nexport function shallowMerge<T extends Obj[]>(...items: [...T]): Merge<T> {\n  return merge('shallow', ...items) as Merge<T>;\n}\n\n/**\n * Deeply merges two objects based on the provided strategy.\n *\n * - Uses **direct property access** for performance.\n * - **Avoids redundant deep merging** where unnecessary.\n * - Optimized **array merging strategies**.\n *\n * @param target - The target object.\n * @param source - The source object.\n * @param strategy - The merge strategy.\n * @returns A new merged object.\n */\nfunction mergeObjects<T extends Obj, U extends Obj>(target: T, source: U, strategy: MergeStrategy): DeepMerge<T, U> {\n  if (!isObject(source)) return source as DeepMerge<T, U>;\n\n  const result = { ...target } as DeepMerge<T, U>;\n\n  for (const key of Object.keys(source)) {\n    const sourceValue = source[key];\n    const targetValue = result[key];\n\n    (result as any)[key] =\n      isArray(sourceValue) && isArray(targetValue)\n        ? handleArrayMerge(targetValue, sourceValue, strategy)\n        : isObject(sourceValue) && isObject(targetValue)\n          ? mergeObjects(targetValue as Obj, sourceValue as Obj, strategy)\n          : applyMergeStrategy(targetValue, sourceValue, strategy);\n  }\n\n  return result;\n}\n\n/**\n * Optimized array merge based on strategy.\n *\n * - `\"arrayConcat\"` → Concatenates arrays.\n * - `\"arrayReplace\"` → Replaces the existing array.\n * - Default: Concatenates arrays (same as `\"arrayConcat\"`).\n */\nfunction handleArrayMerge<T, U>(targetArray: T[] | undefined, sourceArray: U[], strategy: MergeStrategy): (T | U)[] {\n  if (!targetArray) return sourceArray;\n\n  if (strategy === 'arrayConcat') return targetArray.concat(sourceArray as any);\n\n  if (strategy === 'arrayReplace') return sourceArray;\n\n  return [...targetArray, ...sourceArray];\n}\n\n/**\n * Determines the appropriate value to assign based on the merge strategy.\n *\n * - `\"lastWins\"` → Overwrites with the latest value.\n * - Custom functions → Allows user-defined behavior.\n */\nfunction applyMergeStrategy<T, U>(target: T, source: U, strategy: MergeStrategy): T | U {\n  if (typeof strategy === 'function') return strategy(target, source);\n\n  return strategy === 'lastWins' || source !== undefined ? source : target;\n}\n","import { isNil } from '../typed/isNil';\nimport { isString } from '../typed/isString';\n\ntype JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };\n\n// #region ParseJSONOptions\ntype ParseJSONOptions<T> = {\n  defaultValue?: T;\n  onError?: (err: unknown) => void;\n  reviver?: (key: string, value: any) => any;\n  validator?: (value: any) => boolean;\n};\n// #endregion ParseJSONOptions\n\n/**\n * Parses a JSON string and returns the resulting object.\n *\n * @example\n * ```ts\n * const json = '{\"a\":1,\"b\":2,\"c\":3}';\n * const result = parseJSON<Record<string, number>>(json, {\n *   defaultValue: { a: 0, b: 0, c: 0 },\n *   validator: (value) => Object.values(value).every(v => typeof v === 'number'),\n *   onError: (err) => console.warn('Parsing failed:', err),\n * });\n * console.log(result); // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @template T - The expected type of the parsed JSON.\n * @param json - The JSON string to parse. If not a string, it is returned as is.\n * @param options - Configuration options for parsing.\n *\n * @returns The parsed object if successful, otherwise the default value.\n */\nexport function parseJSON<T extends JSONValue>(json: unknown, options: ParseJSONOptions<T> = {}): T | undefined {\n  const { defaultValue, onError, reviver, validator } = options;\n\n  if (!isString(json)) return isNil(json) ? defaultValue : (json as T);\n\n  try {\n    const parsed = JSON.parse(json as string, reviver);\n\n    if (validator && !validator(parsed)) {\n      throw new TypeError('Parsed JSON does not match the expected structure');\n    }\n\n    return parsed ?? defaultValue;\n  } catch (err) {\n    onError?.(err);\n\n    return defaultValue;\n  }\n}\n","import type { Obj } from '../types';\n\nimport { assert } from '../function/assert';\nimport { isNil } from '../typed/isNil';\nimport { IS_OBJECT_ERROR_MSG, isObject } from '../typed/isObject';\n\ntype PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`\n  ? Key extends keyof T\n    ? PathValue<T[Key], Rest>\n    : undefined\n  : P extends keyof T\n    ? T[P]\n    : undefined;\n\n// #region PathOptions\ntype PathOptions = {\n  throwOnMissing?: boolean;\n};\n// #endregion PathOptions\n\n/**\n * Retrieves the value at a given path of the object. If the value is undefined, the default value is returned.\n *\n * @example\n * ```ts\n * const obj = { a: { b: { c: 3 } }, d: [1, 2, 3] };\n *\n * getValue(obj, 'a.b.c'); // 3\n * getValue(obj, 'a.b.d', 'default'); // 'default'\n * getValue(obj, 'd[1]'); // 2\n * getValue(obj, 'e.f.g', 'default', { throwOnMissing: true }); // throws Error\n * ```\n *\n * @template T - The type of the object to query.\n * @template P - The type of the path string.\n * @param item - The object to query.\n * @param path - The dot-separated path of the property to get.\n * @param [defaultValue] - The value returned for undefined resolved values.\n * @param [options] - Additional options for value retrieval.\n *\n * @returns The resolved value.\n *\n * @throws If throwOnMissing is true and the path doesn't exist.\n */\nexport function get<T extends Obj, P extends string>(\n  item: T,\n  path: P,\n  defaultValue?: unknown,\n  options: PathOptions = {},\n): PathValue<T, P> | undefined {\n  assert(isObject(item), IS_OBJECT_ERROR_MSG, { args: { item }, type: TypeError });\n\n  const { throwOnMissing = false } = options;\n\n  const fragments = path.split(/[.[\\]]+/).filter(Boolean);\n  let current: any = item;\n\n  for (const fragment of fragments) {\n    if (isNil(current) || typeof current !== 'object') {\n      if (throwOnMissing) throw new Error(`Cannot read property '${fragment}' of ${current}`);\n\n      return defaultValue as PathValue<T, P>;\n    }\n\n    current = current[fragment];\n\n    if (current === undefined) {\n      if (throwOnMissing) throw new Error(`Property '${fragment}' does not exist`);\n\n      return defaultValue as PathValue<T, P>;\n    }\n  }\n\n  return current as PathValue<T, P>;\n}\n","import type { Obj } from '../types';\n\nimport { isObject } from '../typed/isObject';\n\n// #region ProxyOptions\ntype ProxyOptions<T> = {\n  deep?: boolean;\n  get?: <K extends PropertyKey>(prop: K, val: unknown, target: T) => unknown;\n  set?: <K extends PropertyKey>(prop: K, curr: unknown, prev: unknown, target: T) => unknown;\n  watch?: (keyof T)[];\n};\n// #endregion ProxyOptions\n\n/**\n * Creates a new Proxy for the given object that invokes functions when properties are accessed or modified.\n *\n * @example\n * ```ts\n * const obj = { a: 1, b: 2 };\n * const log = (prop, curr, prev, target) => console.log(`Property '${prop}' changed from ${prev} to ${curr}`);\n * const proxyObj = proxy(obj, { set: log });\n * proxyObj.a = 3; // logs 'Property 'a' changed from 1 to 3'\n * ```\n *\n * @param item - The object to observe.\n * @param options - Configuration options for the proxy.\n * @param [options.set] - A function to call when a property is set.\n * @param [options.get] - A function to call when a property is accessed.\n * @param [options.deep] - If true, the proxy will also apply to nested objects.\n * @param [options.watch] - An array of property names to watch.\n *\n * @returns A new Proxy for the given object.\n */\nexport function proxy<T extends Obj>(item: T, options: ProxyOptions<T>): T {\n  const { deep = false, get, set, watch } = options;\n  const watchSet = watch ? new Set<PropertyKey>(watch as PropertyKey[]) : null;\n\n  const handler: ProxyHandler<T> = {\n    get(target, prop, receiver) {\n      if (watchSet && !watchSet.has(prop)) {\n        return Reflect.get(target, prop, receiver);\n      }\n\n      let value = Reflect.get(target, prop, receiver);\n\n      if (get) {\n        value = get(prop, value, target) as any;\n      }\n\n      if (deep && isObject(value)) {\n        return proxy(value as unknown as T, options);\n      }\n\n      return value;\n    },\n    set(target, prop, val, receiver) {\n      if (watchSet && !watchSet.has(prop)) {\n        return Reflect.set(target, prop, val, receiver);\n      }\n\n      const prev = target[prop as keyof T];\n      const value = set ? set(prop, val, prev, target) : val;\n\n      if (deep && isObject(value)) {\n        return Reflect.set(target, prop, proxy(value as unknown as T, options), receiver);\n      }\n\n      return Reflect.set(target, prop, value, receiver);\n    },\n  };\n\n  return new Proxy(item, handler);\n}\n","import { isArray } from './isArray';\nimport { isNil } from './isNil';\nimport { isObject } from './isObject';\n\n/**\n * Checks if the given argument is empty.\n *\n * @example\n * ```ts\n * isEmpty(null); // true\n * isEmpty(undefined); // true\n * isEmpty([]); // true\n * isEmpty({}); // true\n * isEmpty(''); // true\n * isEmpty(0); // false\n * isEmpty(123); // false\n * isEmpty('abc'); // false\n * isEmpty([1, 2, 3]); // false\n * isEmpty({ a: 1, b: 2 }); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if all arguments are `null`, `undefined`, `{}`, `[]`, or empty strings. Otherwise, it returns `false`.\n */\nexport function isEmpty(arg: any): boolean {\n  if (isNil(arg) || arg === '') return true;\n\n  if (isArray(arg)) return arg.length === 0;\n\n  if (arg instanceof Map || arg instanceof Set) return arg.size === 0;\n\n  if (isObject(arg)) return Object.keys(arg).length === 0;\n\n  return false;\n}\n\nexport const IS_EMPTY_ERROR_MSG = 'Expected an empty value';\n","import { isArray } from '../typed/isArray';\nimport { isEmpty } from '../typed/isEmpty';\nimport { isNil } from '../typed/isNil';\nimport { isObject } from '../typed/isObject';\nimport { isString } from '../typed/isString';\n\n/**\n * Removes all nullable and empty values from strings, arrays, or objects.\n *\n * - For strings: Removes leading/trailing whitespace and returns undefined if empty\n * - For arrays: Recursively removes null, undefined, empty strings, and empty objects/arrays\n * - For objects: Recursively removes properties with null, undefined, empty strings, and empty objects/arrays\n *\n * @example\n * ```ts\n * prune('  hello  '); // 'hello'\n * prune('   '); // undefined\n * prune([1, null, '', 2, undefined, 3]); // [1, 2, 3]\n * prune({ a: 1, b: null, c: '', d: 2 }); // { a: 1, d: 2 }\n * prune({ a: { b: null, c: '' }, d: 1 }); // { d: 1 }\n * ```\n *\n * @param value - The value to prune (can be string, array, object, or any other type)\n * @returns The pruned value, or undefined if the result would be empty\n */\nexport function prune<T>(value: T): T | undefined {\n  if (isNil(value)) return undefined;\n\n  if (isString(value)) {\n    const trimmed = value.trim();\n\n    return (trimmed === '' ? undefined : trimmed) as T | undefined;\n  }\n\n  if (isArray(value)) {\n    const cleaned = value.map((item) => prune(item)).filter((item) => !isEmpty(item));\n\n    return (cleaned.length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  if (isObject(value)) {\n    const cleaned: Record<string, unknown> = {};\n\n    for (const [key, val] of Object.entries(value)) {\n      const cleanedValue = prune(val);\n\n      if (!isEmpty(cleanedValue)) {\n        cleaned[key] = cleanedValue;\n      }\n    }\n\n    return (Object.keys(cleaned).length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  return value;\n}\n","import { assert } from '../function/assert';\n\n/**\n * Generates a random integer between two values, inclusive.\n *\n * @example\n * ```ts\n * random(1, 10); // a random integer between 1 and 10\n * ```\n *\n * @param min - The minimum value.\n * @param max - The maximum value.\n * @returns A random integer between min and max.\n */\nexport function random(min: number, max: number): number {\n  assert(min <= max, 'Minimum value must be less than maximum value', { args: { max, min }, type: RangeError });\n\n  const randomValue = crypto.getRandomValues(new Uint32Array(1))[0] / 0xffffffff;\n\n  return Math.floor(randomValue * (max - min + 1)) + min;\n}\n","import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\nimport { random } from './random';\n\n/**\n * “Draw” a random item from an array.\n *\n * @example\n * ```ts\n * draw([1, 2, 3]) // 3\n * ```\n *\n * @param array - The array to draw from.\n *\n * @returns A random item from the array or `undefined` if the array is empty.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport const draw = <T>(array: T[]): T | undefined => {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  if (array.length === 0) return undefined;\n\n  return array[random(0, array.length - 1)];\n};\n","import { assert } from '../function/assert';\nimport { IS_ARRAY_ERROR_MSG, isArray } from '../typed/isArray';\n\n/**\n * Shuffles an array randomly.\n *\n * @example\n * ```ts\n * const arr = [1, 2, 3, 4];\n * shuffle(arr); // a shuffled version of the array\n * ```\n *\n * @param array - The array to shuffle.\n *\n * @returns A new shuffled array.\n *\n * @throws {TypeError} If the provided array is not an array.\n */\nexport function shuffle<T>(array: T[]): T[] {\n  assert(isArray(array), IS_ARRAY_ERROR_MSG, { args: { array }, type: TypeError });\n\n  const result = [...array];\n\n  for (let i = result.length - 1; i > 0; i--) {\n    const j = Math.floor((crypto.getRandomValues(new Uint32Array(1))[0] / 0xffffffff) * (i + 1));\n\n    [result[i], result[j]] = [result[j], result[i]];\n  }\n\n  return result;\n}\n","/**\n * Generates a unique identifier.\n *\n * @example\n * ```ts\n * uuid(); // a unique identifier, e.g., '22a746d0-08be-4aff-bbc2-4deddf0914e0'\n * ```\n *\n * @returns A unique identifier.\n */\nexport function uuid(): string {\n  return crypto.randomUUID();\n}\n","/**\n * Shared regex pattern for splitting words in case conversion utilities\n */\nexport const CASE_SPLIT_PATTERN = /([a-z])([A-Z\\d])|([A-Z\\d])([A-Z][a-z])|(\\d)([a-zA-Z])/g;\n\n/**\n * Normalizes a string by splitting on word boundaries and removing special characters\n *\n * @param str - The string to normalize\n * @param separator - The separator to use for splitting (default: space)\n * @returns The normalized string\n */\nexport function normalizeCase(str: string, separator = ' '): string {\n  return str\n    .trim()\n    .replace(CASE_SPLIT_PATTERN, `$1$3$5${separator}$2$4$6`)\n    .replace(/[^a-z\\d]+/gi, separator)\n    .replace(new RegExp(`^${separator}+|${separator}+$`, 'g'), '');\n}\n","import { normalizeCase } from './_caseUtils';\n\n/**\n * Converts a string to camel case.\n *\n * @example\n * ```ts\n * const text = 'hello world';\n * camelCase(text); // 'helloWorld'\n * ```\n *\n * @param str - The string to convert.\n * @returns The converted string.\n */\nexport function camelCase(str: string): string {\n  return normalizeCase(str, ' ')\n    .replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase())\n    .replace(/^./, (char) => char.toLowerCase());\n}\n","import { normalizeCase } from './_caseUtils';\n\n/**\n * Converts a string to kebab case.\n *\n * @example\n * ```ts\n * const text = 'Hello World';\n * kebabCase(text); // 'hello-world'\n * ```\n *\n * @param str - The string to convert.\n *\n * @returns The converted string.\n */\nexport function kebabCase(str: string): string {\n  return normalizeCase(str, '-').toLowerCase();\n}\n","import { normalizeCase } from './_caseUtils';\n\n/**\n * Converts a string to Pascal case.\n *\n * @example\n * ```ts\n * const text = 'Hello World';\n * pascalCase(text) // 'HelloWorld';\n * ```\n *\n * @param str - The string to convert.\n *\n * @returns The converted string.\n */\nexport function pascalCase(str: string): string {\n  return normalizeCase(str, ' ')\n    .replace(/(?:^|\\s)(\\w)/g, (_, char) => char.toUpperCase())\n    .replace(/\\s+/g, '');\n}\n","import { normalizeCase } from './_caseUtils';\n\n/**\n * Converts a string to snake case.\n *\n * @example\n * ```ts\n * const text = 'Hello World';\n * toSnakeCase(text) // 'hello_world';\n * ```\n *\n * @param str - The string to convert.\n *\n * @returns The converted string.\n */\nexport function snakeCase(str: string): string {\n  return normalizeCase(str, '_').toLowerCase();\n}\n","import { assert } from '../function/assert';\n\ntype TruncateOptions = {\n  completeWords?: boolean;\n  ellipsis?: string;\n};\n\n/**\n * Truncates a string if it is longer than the given maximum string length. The last characters of the truncated string are replaced with the ellipsis sign \"…\".\n *\n * @example\n * ```ts\n * const text = 'Hello World';\n * truncate(text, 5); // 'Hello…'\n * truncate(text, 8, { completeWords: true }); // 'Hello…'\n * truncate(text, 5, { ellipsis: '...' }); // 'Hello...'\n * ```\n *\n * @param str - The string to truncate.\n * @param limit - The maximum string length.\n * @param options - Options for truncation.\n * @param [options.completeWords] - If true, truncate to the nearest word boundary.\n * @param [options.ellipsis] - Suffix appended after truncation (default: '…').\n *\n * @returns The truncated string.\n *\n * @throws {TypeError} If str is not a string or limit is not a positive number.\n */\nexport function truncate(\n  str: string,\n  limit = 25,\n  { completeWords = false, ellipsis = '…' }: TruncateOptions = {},\n): string {\n  assert(typeof str === 'string', 'First argument must be a string', {\n    args: { str },\n    type: TypeError,\n  });\n  assert(\n    typeof limit === 'number' && limit >= 0 && Number.isFinite(limit),\n    'Limit must be a non-negative finite number',\n    { args: { limit }, type: TypeError },\n  );\n\n  if (str.length <= limit) {\n    return str;\n  }\n\n  let end = limit;\n\n  if (completeWords) {\n    const wordEnd = str.substring(0, limit).lastIndexOf(' ');\n\n    if (wordEnd > 0) end = wordEnd;\n  }\n\n  return `${str.substring(0, end).trim()}${ellipsis}`;\n}\n","/**\n * Checks if the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * isBoolean(false); // true\n * isBoolean(123); // false\n * isBoolean('hello world'); // false\n * isBoolean({}); // false\n * isBoolean([]); // false\n * isBoolean(new Date()); // false\n * isBoolean(null); // false\n * isBoolean(undefined); // false\n * isBoolean(NaN); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a boolean, else `false`.\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean';\n}\n","/**\n * Checks if a value is defined (not `undefined`).\n *\n * @example\n * ```ts\n * isDefined(123); // true\n * isDefined(undefined); // false\n * isDefined('hello world'); // true\n * isDefined({}); // true\n * isDefined([]); // true\n * isDefined(null); // true\n * ```\n *\n * @param arg - The value to check.\n *\n * @returns `true` if the value is defined, else `false`.\n */\nexport function isDefined<T>(arg: T | undefined): arg is T {\n  return arg !== undefined;\n}\n","/**\n * Checks if a number is even.\n *\n * @param {number} arg - The number to check.\n *\n * @returns {boolean} - Returns true if the number is even, otherwise false.\n */\nexport function isEven(arg: unknown): arg is number {\n  return typeof arg === 'number' && Number.isInteger(arg) && arg % 2 === 0;\n}\n","/**\n * Determines if the passed value is a function.\n *\n * @example\n * ```ts\n * isFunction(function() {}) // true\n * isFunction(() => {}) // true\n * isFunction('hello world') // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a function, else `false`.\n */\nexport function isFunction(arg: unknown): arg is (...args: any[]) => any {\n  return typeof arg === 'function';\n}\n","/**\n * Performs a partial deep comparison between object and source to determine if object contains equivalent property values.\n *\n * @example\n * ```ts\n * const object = { a: 1, b: 2, c: { d: 3 } };\n *\n * isMatch(object, { a: 1, c: { d: 3 } }); // true\n * isMatch(object, { a: 1, b: 2 }); // true\n * isMatch(object, { a: 1, c: { d: 4 } }); // false\n *\n * isMatch([1, 2, 3], [1, 2]); // true\n * isMatch([1, 2, 3], [1, 2, 3]); // true\n * isMatch([1, 2, 3], [1, 2, 4]); // false\n * ```\n *\n * @param object - The object to inspect.\n * @param source - The object of property values to match.\n *\n * @returns `true` if the object is a match, else `false`.\n */\nexport function isMatch(object: any, source: any): boolean {\n  if (object === source) return true;\n\n  if (object == null || source == null) return false;\n\n  const isObjArray = Array.isArray(object);\n  const isSrcArray = Array.isArray(source);\n\n  if (isObjArray !== isSrcArray) return false;\n\n  if (isObjArray && isSrcArray) {\n    if (source.length > object.length) return false;\n\n    return source.every((item: any, i: number) => isMatch(object[i], item));\n  }\n\n  if (typeof source === 'object') {\n    for (const key of Object.keys(source)) {\n      if (!isMatch(object?.[key], source[key])) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  return object === source;\n}\n","/**\n * @description\n * Checks if the value is a negative number.\n *\n * @example\n * ```ts\n * isNegative(-123); // true\n * isNegative(123); // false\n * isNegative(0); // false\n * isNegative(0.1); // false\n * isNegative(-0.1); // true\n * isNegative('hello world'); // false\n * isNegative({}); // false\n * isNegative([]); // false\n * isNegative(new Date()); // false\n * isNegative(null); // false\n * isNegative(undefined); // false\n * isNegative(NaN); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a negative number, else `false`.\n */\nexport function isNegative(arg: unknown): arg is number {\n  return typeof arg === 'number' && arg < 0;\n}\n","/**\n * Checks if a number is odd.\n *\n * @param {number} arg - The number to check.\n *\n * @returns {boolean} - Returns true if the number is odd, otherwise false.\n */\nexport function isOdd(arg: unknown): arg is number {\n  return typeof arg === 'number' && Number.isInteger(arg) && arg % 2 !== 0;\n}\n","/**\n * Checks if the value is a positive number.\n *\n * @example\n * ```ts\n * isPositive(123); // true\n * isPositive(-123); // false\n * isPositive(0); // false\n * isPositive(0.1); // true\n * isPositive(-0.1); // false\n * isPositive('hello world'); // false\n * isPositive({}); // false\n * isPositive([]); // false\n * isPositive(new Date()); // false\n * isPositive(null); // false\n * isPositive(undefined); // false\n * isPositive(NaN); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a positive number, else `false`.\n *\n */\nexport function isPositive(arg: unknown): arg is number {\n  return typeof arg === 'number' && arg > 0;\n}\n","/**\n * Type guard to check if a value is a primitive\n *\n * @example\n * ```ts\n * isPrimitive('Hello World'); // true\n * isPrimitive(42); // true\n * isPrimitive(true); // true\n * isPrimitive({}); // false\n * isPrimitive([]); // false\n * isPrimitive(() => {}); // false\n * ```\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a primitive, else `false`.\n */\nexport function isPrimitive(arg: unknown): arg is string | number | boolean {\n  const type = typeof arg;\n\n  return type === 'string' || type === 'boolean' || (type === 'number' && !Number.isNaN(arg));\n}\n","/**\n * Determines if the passed value is a Promise (or any thenable).\n *\n * @example\n * ```ts\n * isPromise(new Promise((resolve) => resolve(1))); // true\n * isPromise(asyncFn()); // true  (calling it returns a Promise)\n * isPromise(async () => {}); // false (the function itself is not a Promise)\n * isPromise(() => {}); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is a thenable, else `false`.\n */\nexport function isPromise(arg: unknown): arg is Promise<unknown> {\n  return typeof arg === 'object' && arg !== null && typeof (arg as { then?: unknown }).then === 'function';\n}\n","/**\n * Checks if the provided argument is a regular expression.\n *\n * @example\n * ```ts\n * isRegex(/abc/); // true\n * isRegex(new RegExp('abc')); // true\n * isRegex('abc'); // false\n * isRegex(123); // false\n * isRegex({}); // false\n * isRegex([]); // false\n * isRegex(null); // false\n * isRegex(undefined); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @return `true` if the argument is a regular expression, otherwise `false`.\n */\nexport function isRegex(arg: unknown): arg is RegExp {\n  return arg instanceof RegExp;\n}\n","/**\n * Checks if the value is zero.\n *\n * @example\n * ```ts\n * isZero(0); // true\n * isZero(123); // false\n * isZero(-123); // false\n * isZero(0.0000001); // false\n * isZero('hello world'); // false\n * isZero({}); // false\n * isZero([]); // false\n * isZero(new Date()); // false\n * isZero(null); // false\n * isZero(undefined); // false\n * isZero(NaN); // false\n * ```\n *\n * @param arg - The argument to be checked.\n *\n * @returns `true` if the value is zero, else `false`.\n *\n */\nexport function isZero(arg: unknown): arg is number {\n  return typeof arg === 'number' && arg === 0;\n}\n","export type ArgType =\n  | 'array'\n  | 'boolean'\n  | 'date'\n  | 'error'\n  | 'function'\n  | 'map'\n  | 'nan'\n  | 'null'\n  | 'number'\n  | 'object'\n  | 'promise'\n  | 'regexp'\n  | 'set'\n  | 'string'\n  | 'symbol'\n  | 'weakmap'\n  | 'weakset'\n  | 'undefined';\n\n/**\n * Returns the type of the given argument.\n *\n * @example\n * ```ts\n * typeOf(null); // 'null'\n * typeOf(undefined); // 'undefined'\n * typeOf(NaN); // 'nan'\n * typeOf(async function() {}); // 'function'\n * typeOf(123); // 'number'\n * typeOf('abc'); // 'string'\n * typeOf({}); // 'object'\n * typeOf([]); // 'array'\n * typeOf(() => {}); // 'function'\n * typeOf(new Date()); // 'date'\n * typeOf(new Error()); // 'error'\n * typeOf(new Map()); // 'map'\n * typeOf(new Set()); // 'set'\n * typeOf(new WeakMap()); // 'weakmap'\n * typeOf(new WeakSet()); // 'weakset'\n * typeOf(new RegExp('')); // 'regexp'\n * ```\n *\n * @param arg - The argument whose type is to be determined.\n *\n * @returns The type of the argument.\n */\nexport function typeOf(arg: unknown): ArgType {\n  if (arg === null) return 'null';\n\n  if (arg === undefined) return 'undefined';\n\n  if (typeof arg === 'number' && Number.isNaN(arg)) return 'nan';\n\n  const type = Object.prototype.toString.call(arg).slice(8, -1);\n\n  return (type === 'AsyncFunction' ? 'function' : type.toLowerCase()) as ArgType;\n}\n","import { isArray } from './isArray';\nimport { isBoolean } from './isBoolean';\nimport { isDate } from './isDate';\nimport { isDefined } from './isDefined';\nimport { isEmpty } from './isEmpty';\nimport { isEqual } from './isEqual';\nimport { isEven } from './isEven';\nimport { isFunction } from './isFunction';\nimport { isMatch } from './isMatch';\nimport { isNegative } from './isNegative';\nimport { isNil } from './isNil';\nimport { isNumber } from './isNumber';\nimport { isObject } from './isObject';\nimport { isOdd } from './isOdd';\nimport { isPositive } from './isPositive';\nimport { isPrimitive } from './isPrimitive';\nimport { isPromise } from './isPromise';\nimport { isRegex } from './isRegex';\nimport { isString } from './isString';\nimport { isWithin } from './isWithin';\nimport { isZero } from './isZero';\nimport { typeOf } from './typeOf';\n\n/**\n * Namespace of type-checking and comparison utilities.\n *\n * @example\n * ```ts\n * is.string('hello');          // true\n * is.array([1, 2, 3]);         // true\n * is.nil(null);                // true\n * is.nil(undefined);           // true\n * is.equal([1, 2], [1, 2]);    // true\n * is.positive(5);              // true\n * is.within(3, 1, 5);          // true\n * is.match({ a: 1, b: 2 }, { a: 1 }); // true\n * is.ge(5, 5);                 // true\n * is.gt(5, 3);                 // true\n * is.typeOf('hello');          // 'string'\n * ```\n */\nexport const is = {\n  /** `true` if value is an array */\n  array: isArray,\n  /** `true` if value is a boolean */\n  boolean: isBoolean,\n  /** `true` if value is a valid Date */\n  date: isDate,\n  /** `true` if value is not `undefined` */\n  defined: isDefined,\n  /** `true` if value is null, undefined, `''`, `[]`, or `{}` */\n  empty: isEmpty,\n  /** Deep equality check */\n  equal: isEqual,\n  /** `true` if value is an even integer */\n  even: isEven,\n  /** `true` if value is a function */\n  fn: isFunction,\n  /** `true` if a >= b (numbers only) */\n  ge: (a: number, b: number) => a >= b,\n  /** `true` if a > b (numbers only) */\n  gt: (a: number, b: number) => a > b,\n  /** `true` if a <= b (numbers only) */\n  le: (a: number, b: number) => a <= b,\n  /** `true` if a < b (numbers only) */\n  lt: (a: number, b: number) => a < b,\n  /** Partial deep-match: `true` if `object` contains all of `source`'s properties */\n  match: isMatch,\n  /** `true` if value is a negative number */\n  negative: isNegative,\n  /** `true` if value is null or undefined */\n  nil: isNil,\n  /** `true` if value is a number (excluding NaN) */\n  number: isNumber,\n  /** `true` if value is a plain object */\n  object: isObject,\n  /** `true` if value is an odd integer */\n  odd: isOdd,\n  /** `true` if value is a positive number */\n  positive: isPositive,\n  /** `true` if value is a string, number, or boolean */\n  primitive: isPrimitive,\n  /** `true` if value is a Promise */\n  promise: isPromise,\n  /** `true` if value is a RegExp */\n  regex: isRegex,\n  /** `true` if value is a string */\n  string: isString,\n  /** Returns the runtime type tag of the value */\n  typeOf,\n  /** `true` if value is within [min, max] (inclusive) */\n  within: isWithin,\n  /** `true` if value is exactly 0 */\n  zero: isZero,\n};\n"],"mappings":"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"}

package/dist/typed/index.d.ts

@@ -0,0 +1,24 @@
+export * from './is';
+export * from './isArray';
+export * from './isBoolean';
+export * from './isDate';
+export * from './isDefined';
+export * from './isEmpty';
+export * from './isEqual';
+export * from './isEven';
+export * from './isFunction';
+export * from './isMatch';
+export * from './isNegative';
+export * from './isNil';
+export * from './isNumber';
+export * from './isObject';
+export * from './isOdd';
+export * from './isPositive';
+export * from './isPrimitive';
+export * from './isPromise';
+export * from './isRegex';
+export * from './isString';
+export * from './isWithin';
+export * from './isZero';
+export * from './typeOf';
+//# sourceMappingURL=index.d.ts.map

package/dist/typed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typed/index.ts"],"names":[],"mappings":"AAAA,cAAc,MAAM,CAAC;AACrB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/typed/is.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../function/assert.cjs"),n=require("./ge.cjs"),o=require("./gt.cjs"),c=require("./isDefined.cjs"),u=require("./isEmpty.cjs"),r=require("./isEqual.cjs"),q=require("./isEven.cjs"),a=require("./isMatch.cjs"),l=require("./isNegative.cjs"),d=require("./isNil.cjs"),g=require("./isOdd.cjs"),v=require("./isPositive.cjs"),p=require("./isRegex.cjs"),m=require("./isWithin.cjs"),E=require("./isZero.cjs"),f=require("./le.cjs"),h=require("./lt.cjs"),y=require("./typeOf.cjs");function O(i,s){return t.assert(!!i,"Type must be provided",{args:{type:i},type:Error}),{defined:c.isDefined,empty:u.isEmpty,eq:e=>r.isEqual(...e),even:q.isEven,ge:e=>n.ge(...e),gt:e=>o.gt(...e),le:e=>f.le(...e),lt:e=>h.lt(...e),match:e=>a.isMatch(...e),ne:e=>!r.isEqual(...e),negative:l.isNegative,nil:d.isNil,odd:g.isOdd,positive:v.isPositive,regex:p.isRegex,within:e=>m.isWithin(...e),zero:E.isZero}[i]?.(s)??y.typeOf(s)===i}exports.is=O;
-//# sourceMappingURL=is.cjs.map
+const e=require(`./isArray.cjs`),t=require(`./isString.cjs`),n=require(`./isEqual.cjs`),r=require(`./isNil.cjs`),i=require(`./isNumber.cjs`),a=require(`./isObject.cjs`),o=require(`./isWithin.cjs`),s=require(`./isDate.cjs`),c=require(`./isEmpty.cjs`),l=require(`./isBoolean.cjs`),u=require(`./isDefined.cjs`),d=require(`./isEven.cjs`),f=require(`./isFunction.cjs`),p=require(`./isMatch.cjs`),m=require(`./isNegative.cjs`),h=require(`./isOdd.cjs`),g=require(`./isPositive.cjs`),_=require(`./isPrimitive.cjs`),v=require(`./isPromise.cjs`),y=require(`./isRegex.cjs`),b=require(`./isZero.cjs`),x=require(`./typeOf.cjs`);var S={array:e.isArray,boolean:l.isBoolean,date:s.isDate,defined:u.isDefined,empty:c.isEmpty,equal:n.isEqual,even:d.isEven,fn:f.isFunction,ge:(e,t)=>e>=t,gt:(e,t)=>e>t,le:(e,t)=>e<=t,lt:(e,t)=>e<t,match:p.isMatch,negative:m.isNegative,nil:r.isNil,number:i.isNumber,object:a.isObject,odd:h.isOdd,positive:g.isPositive,primitive:_.isPrimitive,promise:v.isPromise,regex:y.isRegex,string:t.isString,typeOf:x.typeOf,within:o.isWithin,zero:b.isZero};exports.is=S;
+//# sourceMappingURL=is.cjs.map

package/dist/typed/is.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is.cjs","sources":["../../src/typed/is.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { ge } from './ge';\nimport { gt } from './gt';\nimport { isDefined } from './isDefined';\nimport { isEmpty } from './isEmpty';\nimport { isEqual } from './isEqual';\nimport { isEven } from './isEven';\nimport { isMatch } from './isMatch';\nimport { isNegative } from './isNegative';\nimport { isNil } from './isNil';\nimport { isOdd } from './isOdd';\nimport { isPositive } from './isPositive';\nimport { isRegex } from './isRegex';\nimport { isWithin } from './isWithin';\nimport { isZero } from './isZero';\nimport { le } from './le';\nimport { lt } from './lt';\nimport { type ArgType, typeOf } from './typeOf';\n\ntype isType =\n  | ArgType\n  | 'defined'\n  | 'empty'\n  | 'eq'\n  | 'even'\n  | 'ge'\n  | 'gt'\n  | 'le'\n  | 'lt'\n  | 'match'\n  | 'ne'\n  | 'negative'\n  | 'nil'\n  | 'odd'\n  | 'positive'\n  | 'regex'\n  | 'within'\n  | 'zero';\n\n/**\n * @description\n * Checks if the value type of argument.\n *\n * @example\n * ```ts\n * is('array', []);\n * is('boolean', true);\n * is('date', new Date());\n * is('defined', 123);\n * is('empty', []);\n * is('even', 2);\n * is('function', () => {});\n * is('match', { a: 1, b: 2 }, { a: 1 });\n * is('nan', Number.NaN);\n * is('negative', -123);\n * is('nil', null);\n * is('null', null);\n * is('number', 123);\n * is('object', {});\n * is('odd', 3);\n * is('positive', 123);\n * is('string', 'hello');\n * is('symbol', Symbol('test'));\n * is('regex', /abc/);\n * is('string', 'hello world');\n * is('undefined', undefined);\n * is('within', 1, 2, 3);\n * is('zero', 0);\n * is('eq', [1, 2, 3], [1, 2, 3]);\n * is('ne', [1, 2, 3], [1, 2]);\n * is('ge', 5, 5);\n * is('gt', 5, 3);\n * is('le', 5, 5);\n * is('lt', 3, 5);\n * ```\n *\n * @param type - The type to check against.\n * @param args - The argument to be checked.\n *\n * @returns `true` if the value is of the specified type, else `false`.\n */\nexport function is(type: 'within', ...args: Parameters<typeof isWithin>): boolean;\nexport function is(type: 'eq', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'ne', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'gt', ...args: Parameters<typeof gt>): boolean;\nexport function is(type: 'ge', ...args: Parameters<typeof ge>): boolean;\nexport function is(type: 'lt', ...args: Parameters<typeof lt>): boolean;\nexport function is(type: 'le', ...args: Parameters<typeof le>): boolean;\nexport function is(type: 'match', ...args: Parameters<typeof isMatch>): boolean;\nexport function is(type: 'empty', ...args: Parameters<typeof isEmpty>): boolean;\nexport function is(type: 'array', arg: unknown): arg is Array<unknown>;\nexport function is(type: 'string', arg: unknown): arg is string;\nexport function is(type: 'number', arg: unknown): arg is number;\nexport function is(type: 'object', arg: unknown): arg is object;\nexport function is(type: 'nil', arg: unknown): arg is null | undefined;\nexport function is(type: 'primitive', arg: unknown): arg is string | number | boolean;\nexport function is(type: isType, arg: unknown): boolean;\nexport function is(type: string, arg: unknown): boolean {\n  assert(Boolean(type), 'Type must be provided', { args: { type }, type: Error });\n\n  const compare = {\n    defined: isDefined,\n    empty: isEmpty,\n    eq: (args: Parameters<typeof isEqual>) => isEqual(...args),\n    even: isEven,\n    ge: (args: Parameters<typeof ge>) => ge(...args),\n    gt: (args: Parameters<typeof gt>) => gt(...args),\n    le: (args: Parameters<typeof le>) => le(...args),\n    lt: (args: Parameters<typeof lt>) => lt(...args),\n    match: (args: Parameters<typeof isMatch>) => isMatch(...args),\n    ne: (args: Parameters<typeof isEqual>) => !isEqual(...args),\n    negative: isNegative,\n    nil: isNil,\n    odd: isOdd,\n    positive: isPositive,\n    regex: isRegex,\n    within: (args: Parameters<typeof isWithin>) => isWithin(...args),\n    zero: isZero,\n  };\n\n  return compare[type as keyof typeof compare]?.(arg) ?? typeOf(arg) === type;\n}\n"],"names":["is","type","arg","assert","isDefined","isEmpty","args","isEqual","isEven","ge","gt","le","lt","isMatch","isNegative","isNil","isOdd","isPositive","isRegex","isWithin","isZero","typeOf"],"mappings":"mjBAiGO,SAASA,EAAGC,EAAcC,EAAuB,CACtDC,OAAAA,EAAAA,OAAO,EAAQF,EAAO,wBAAyB,CAAE,KAAM,CAAE,KAAAA,CAAA,EAAQ,KAAM,MAAO,EAE9D,CACd,QAASG,EAAAA,UACT,MAAOC,EAAAA,QACP,GAAKC,GAAqCC,EAAAA,QAAQ,GAAGD,CAAI,EACzD,KAAME,EAAAA,OACN,GAAKF,GAAgCG,EAAAA,GAAG,GAAGH,CAAI,EAC/C,GAAKA,GAAgCI,EAAAA,GAAG,GAAGJ,CAAI,EAC/C,GAAKA,GAAgCK,EAAAA,GAAG,GAAGL,CAAI,EAC/C,GAAKA,GAAgCM,EAAAA,GAAG,GAAGN,CAAI,EAC/C,MAAQA,GAAqCO,EAAAA,QAAQ,GAAGP,CAAI,EAC5D,GAAKA,GAAqC,CAACC,EAAAA,QAAQ,GAAGD,CAAI,EAC1D,SAAUQ,EAAAA,WACV,IAAKC,EAAAA,MACL,IAAKC,EAAAA,MACL,SAAUC,EAAAA,WACV,MAAOC,EAAAA,QACP,OAASZ,GAAsCa,EAAAA,SAAS,GAAGb,CAAI,EAC/D,KAAMc,EAAAA,MAAA,EAGOnB,CAA4B,IAAIC,CAAG,GAAKmB,EAAAA,OAAOnB,CAAG,IAAMD,CACzE"}
+{"version":3,"file":"is.cjs","names":[],"sources":["../../src/typed/is.ts"],"sourcesContent":["import { isArray } from './isArray';\nimport { isBoolean } from './isBoolean';\nimport { isDate } from './isDate';\nimport { isDefined } from './isDefined';\nimport { isEmpty } from './isEmpty';\nimport { isEqual } from './isEqual';\nimport { isEven } from './isEven';\nimport { isFunction } from './isFunction';\nimport { isMatch } from './isMatch';\nimport { isNegative } from './isNegative';\nimport { isNil } from './isNil';\nimport { isNumber } from './isNumber';\nimport { isObject } from './isObject';\nimport { isOdd } from './isOdd';\nimport { isPositive } from './isPositive';\nimport { isPrimitive } from './isPrimitive';\nimport { isPromise } from './isPromise';\nimport { isRegex } from './isRegex';\nimport { isString } from './isString';\nimport { isWithin } from './isWithin';\nimport { isZero } from './isZero';\nimport { typeOf } from './typeOf';\n\n/**\n * Namespace of type-checking and comparison utilities.\n *\n * @example\n * ```ts\n * is.string('hello');          // true\n * is.array([1, 2, 3]);         // true\n * is.nil(null);                // true\n * is.nil(undefined);           // true\n * is.equal([1, 2], [1, 2]);    // true\n * is.positive(5);              // true\n * is.within(3, 1, 5);          // true\n * is.match({ a: 1, b: 2 }, { a: 1 }); // true\n * is.ge(5, 5);                 // true\n * is.gt(5, 3);                 // true\n * is.typeOf('hello');          // 'string'\n * ```\n */\nexport const is = {\n  /** `true` if value is an array */\n  array: isArray,\n  /** `true` if value is a boolean */\n  boolean: isBoolean,\n  /** `true` if value is a valid Date */\n  date: isDate,\n  /** `true` if value is not `undefined` */\n  defined: isDefined,\n  /** `true` if value is null, undefined, `''`, `[]`, or `{}` */\n  empty: isEmpty,\n  /** Deep equality check */\n  equal: isEqual,\n  /** `true` if value is an even integer */\n  even: isEven,\n  /** `true` if value is a function */\n  fn: isFunction,\n  /** `true` if a >= b (numbers only) */\n  ge: (a: number, b: number) => a >= b,\n  /** `true` if a > b (numbers only) */\n  gt: (a: number, b: number) => a > b,\n  /** `true` if a <= b (numbers only) */\n  le: (a: number, b: number) => a <= b,\n  /** `true` if a < b (numbers only) */\n  lt: (a: number, b: number) => a < b,\n  /** Partial deep-match: `true` if `object` contains all of `source`'s properties */\n  match: isMatch,\n  /** `true` if value is a negative number */\n  negative: isNegative,\n  /** `true` if value is null or undefined */\n  nil: isNil,\n  /** `true` if value is a number (excluding NaN) */\n  number: isNumber,\n  /** `true` if value is a plain object */\n  object: isObject,\n  /** `true` if value is an odd integer */\n  odd: isOdd,\n  /** `true` if value is a positive number */\n  positive: isPositive,\n  /** `true` if value is a string, number, or boolean */\n  primitive: isPrimitive,\n  /** `true` if value is a Promise */\n  promise: isPromise,\n  /** `true` if value is a RegExp */\n  regex: isRegex,\n  /** `true` if value is a string */\n  string: isString,\n  /** Returns the runtime type tag of the value */\n  typeOf,\n  /** `true` if value is within [min, max] (inclusive) */\n  within: isWithin,\n  /** `true` if value is exactly 0 */\n  zero: isZero,\n};\n"],"mappings":"umBAyCA,IAAa,EAAK,CAEhB,MAAO,EAAA,QAEP,QAAS,EAAA,UAET,KAAM,EAAA,OAEN,QAAS,EAAA,UAET,MAAO,EAAA,QAEP,MAAO,EAAA,QAEP,KAAM,EAAA,OAEN,GAAI,EAAA,WAEJ,IAAK,EAAW,IAAc,GAAK,EAEnC,IAAK,EAAW,IAAc,EAAI,EAElC,IAAK,EAAW,IAAc,GAAK,EAEnC,IAAK,EAAW,IAAc,EAAI,EAElC,MAAO,EAAA,QAEP,SAAU,EAAA,WAEV,IAAK,EAAA,MAEL,OAAQ,EAAA,SAER,OAAQ,EAAA,SAER,IAAK,EAAA,MAEL,SAAU,EAAA,WAEV,UAAW,EAAA,YAEX,QAAS,EAAA,UAET,MAAO,EAAA,QAEP,OAAQ,EAAA,SAER,OAAA,EAAA,OAEA,OAAQ,EAAA,SAER,KAAM,EAAA,OACP"}