@ts-fns/stdlib 0.1.0 → 0.2.1

package/dist/function-DYPifnmg.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-DYPifnmg.cjs","names":["purry","purry"],"sources":["../src/function/orThrow.ts","../src/function/always.ts","../src/function/internal/_compose.ts","../src/function/compose.ts","../src/function/composed.ts","../src/function/identity.ts","../src/function/memoizeOne.ts","../src/function/noop.ts","../src/function/internal/_pipe.ts","../src/function/pipe.ts","../src/function/piped.ts","../src/function/tap.ts","../src/function/unless.ts","../src/function/when.ts"],"sourcesContent":["/**\n * Wraps a function so that an error result is thrown instead of returned.\n *\n * @example\n * ```ts\n * const parse = orThrow((s: string) => (s ? s : new Error('empty')));\n * parse('ok'); // 'ok'\n * parse(''); // throws Error\n * ```\n */\nexport function orThrow(fn: (...args: readonly any[]) => unknown): (...args: readonly unknown[]) => unknown {\n  const argLength = fn.length;\n\n  const wrappedFn = (...args: readonly unknown[]): unknown => {\n    const result = fn(...args);\n    if (result instanceof Error) {\n      throw result;\n    }\n    return result;\n  };\n\n  Object.defineProperty(wrappedFn, 'length', {\n    value: argLength,\n  });\n\n  return wrappedFn;\n}\n","/**\n * Returns a function that always yields the same value, ignoring its arguments.\n *\n * @example\n * ```ts\n * always(42)(); // 42\n * always('hi')(1, 2, 3); // 'hi'\n * ```\n */\nexport function always<T>(value: T): (...args: unknown[]) => T {\n  return () => value;\n}\n","export function composeImplementation(input: unknown, ...pipeline: readonly ((value: any) => unknown)[]): any {\n  const len = pipeline.length;\n  let output: unknown = input;\n  for (let i = len - 1; i >= 0; i -= 1) {\n    output = pipeline[i]!(output);\n    if (Error.isError(output)) {\n      return output;\n    }\n  }\n  return output;\n}\n","import type { Err, Fn, Ok } from '../types';\n\nimport { composeImplementation } from './internal/_compose';\n\n/**\n * Composes a value through a sequence of functions from right to left.\n * Functions are listed last-to-first; the rightmost function is applied first.\n * Stops and returns the first error encountered in the pipeline.\n *\n * @example\n * ```ts\n * compose(1, n => n * 2, n => n + 1); // 4\n * compose('a', s => s + '!', s => s.toUpperCase()); // 'A!'\n * ```\n */\nexport function compose<A, B>(input: A, fn1: Fn<Ok<A>, B>): B | Err<A>;\nexport function compose<A, B, C>(input: A, fn2: Fn<Ok<B>, C>, fn1: Fn<Ok<A>, B>): C | Err<A> | Err<B>;\nexport function compose<A, B, C, D>(\n  input: A,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): D | Err<A> | Err<B> | Err<C>;\nexport function compose<A, B, C, D, E>(\n  input: A,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): E | Err<A> | Err<B> | Err<C> | Err<D>;\nexport function compose<A, B, C, D, E, F>(\n  input: A,\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | F;\nexport function compose<A, B, C, D, E, F, G>(\n  input: A,\n  fn6: Fn<Ok<F>, G>,\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | G;\nexport function compose<A, B, C, D, E, F, G, H>(\n  input: A,\n  fn7: Fn<Ok<G>, H>,\n  fn6: Fn<Ok<F>, G>,\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | H;\nexport function compose<A, B, C, D, E, F, G, H, I>(\n  input: A,\n  fn8: Fn<Ok<H>, I>,\n  fn7: Fn<Ok<G>, H>,\n  fn6: Fn<Ok<F>, G>,\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | Err<H> | I;\nexport function compose<A, B, C, D, E, F, G, H, I, J>(\n  input: A,\n  fn9: Fn<Ok<I>, J>,\n  fn8: Fn<Ok<H>, I>,\n  fn7: Fn<Ok<G>, H>,\n  fn6: Fn<Ok<F>, G>,\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | Err<H> | Err<I> | J;\nexport function compose(input: unknown, ...pipeline: readonly ((value: any) => unknown)[]): any {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  return composeImplementation(input, ...pipeline);\n}\n","import type { Err, Fn, Ok } from '../types';\n\nimport { composeImplementation } from './internal/_compose';\n\n/**\n * Returns a function that composes a value through a sequence of functions from right to left.\n * Functions are listed last-to-first; the rightmost function is applied first.\n * Stops and returns the first error encountered in the pipeline.\n *\n * @example\n * ```ts\n * composed(n => n * 2, n => n + 1)(1); // 4\n * composed(s => s + '!', s => s.toUpperCase())('a'); // 'A!'\n * ```\n */\nexport function composed<A, B>(fn1: Fn<Ok<A>, B>): (input: A) => B | Err<A>;\nexport function composed<A, B, C>(fn2: Fn<Ok<B>, C>, fn1: Fn<Ok<A>, B>): (input: A) => C | Err<A> | Err<B>;\nexport function composed<A, B, C, D>(\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): (input: A) => D | Err<A> | Err<B> | Err<C>;\nexport function composed<A, B, C, D, E>(\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): (input: A) => E | Err<A> | Err<B> | Err<C> | Err<D>;\nexport function composed<A, B, C, D, E, F>(\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | F;\nexport function composed<A, B, C, D, E, F, G>(\n  fn6: Fn<Ok<F>, G>,\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | G;\nexport function composed<A, B, C, D, E, F, G, H>(\n  fn7: Fn<Ok<G>, H>,\n  fn6: Fn<Ok<F>, G>,\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | H;\nexport function composed<A, B, C, D, E, F, G, H, I>(\n  fn8: Fn<Ok<H>, I>,\n  fn7: Fn<Ok<G>, H>,\n  fn6: Fn<Ok<F>, G>,\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | Err<H> | I;\nexport function composed<A, B, C, D, E, F, G, H, I, J>(\n  fn9: Fn<Ok<I>, J>,\n  fn8: Fn<Ok<H>, I>,\n  fn7: Fn<Ok<G>, H>,\n  fn6: Fn<Ok<F>, G>,\n  fn5: Fn<Ok<E>, F>,\n  fn4: Fn<Ok<D>, E>,\n  fn3: Fn<Ok<C>, D>,\n  fn2: Fn<Ok<B>, C>,\n  fn1: Fn<Ok<A>, B>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | Err<H> | Err<I> | J;\nexport function composed(...pipeline: readonly ((input: unknown) => unknown)[]): (input: unknown) => any {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  return (input: unknown) => composeImplementation(input, ...pipeline);\n}\n","/**\n * Returns its argument unchanged.\n *\n * @example\n * ```ts\n * identity(42); // 42\n * identity('hello'); // 'hello'\n * ```\n */\nexport function identity<T>(value: T): T {\n  return value;\n}\n","function equalsByRef(first: unknown, second: unknown): boolean {\n  if (first === second) {\n    return true;\n  }\n  if (Number.isNaN(first) && Number.isNaN(second)) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction areInputsEqual(newInputs: readonly unknown[], lastInputs: readonly unknown[]): boolean {\n  if (newInputs.length !== lastInputs.length) {\n    return false;\n  }\n\n  for (let i = 0; i < newInputs.length; i += 1) {\n    if (!equalsByRef(newInputs[i], lastInputs[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport type ArgumentCompareFn<TFunc extends (...args: unknown[]) => unknown> = (\n  newArgs: Parameters<TFunc>,\n  lastArgs: Parameters<TFunc>,\n) => boolean;\n\nexport type MemoizedFn<TFunc extends (this: unknown, ...args: unknown[]) => unknown> = {\n  clear: () => void;\n  (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>): ReturnType<TFunc>;\n};\n\ntype Cache<TFunc extends (this: unknown, ...args: unknown[]) => unknown> = {\n  lastArgs: Parameters<TFunc>;\n  lastResult: ReturnType<TFunc>;\n  lastThis: ThisParameterType<TFunc>;\n};\n\nexport function memoizeOneImplementation<TFunc extends (this: unknown, ...args: unknown[]) => unknown>(\n  fn: TFunc,\n  argumentCompareFn: ArgumentCompareFn<TFunc>,\n): MemoizedFn<TFunc> {\n  let cache: Cache<TFunc> | null = null;\n\n  function memoized(this: ThisParameterType<TFunc>, ...newArgs: Parameters<TFunc>): ReturnType<TFunc> {\n    if (cache?.lastThis === this && argumentCompareFn(newArgs, cache.lastArgs)) {\n      return cache.lastResult;\n    }\n\n    const lastResult = fn.apply(this, newArgs) as ReturnType<TFunc>;\n    cache = {\n      lastArgs: newArgs,\n      lastResult,\n      lastThis: this,\n    };\n\n    return lastResult;\n  }\n\n  memoized.clear = () => {\n    cache = null;\n  };\n\n  return memoized;\n}\n\n/**\n * Memoizes a function so that it reuses the last result when called with the same arguments.\n * Uses reference equality to compare arguments.\n *\n * @example\n * ```ts\n * const add = memoizeOne((a: number, b: number) => a + b);\n * add(1, 2); // 3 (computed)\n * add(1, 2); // 3 (cached)\n * add.clear();\n * ```\n */\nexport function memoizeOne<TFunc extends (this: unknown, ...args: unknown[]) => unknown>(fn: TFunc): MemoizedFn<TFunc> {\n  return memoizeOneImplementation(fn, areInputsEqual);\n}\n\n/**\n * Like `memoizeOne`, but accepts a custom function for comparing arguments.\n *\n * @example\n * ```ts\n * const fn = memoizeOne.with(\n *   (a: { n: number }) => a.n * 2,\n *   ([a], [b]) => a.n === b.n,\n * );\n * fn({ n: 1 }); // 2 (computed)\n * fn({ n: 1 }); // 2 (cached, compared by `n`)\n * ```\n */\nmemoizeOne.with = memoizeOneImplementation;\n","/**\n * A function that does nothing.\n *\n * @example\n * ```ts\n * noop(); // void\n * noop(1, 2, 3); // void\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function noop(...args: unknown[]): void {\n  // noop\n}\n","export function pipeImplementation(input: unknown, ...pipeline: readonly ((value: any) => unknown)[]): any {\n  const len = pipeline.length;\n  let output: unknown = input;\n  for (let i = 0; i < len; i += 1) {\n    output = pipeline[i]!(output);\n    if (Error.isError(output)) {\n      return output;\n    }\n  }\n  return output;\n}\n","import type { Err, Fn, Ok } from '../types';\n\nimport { pipeImplementation } from './internal/_pipe';\n\n/**\n * Pipes a value through a sequence of functions from left to right.\n * Stops and returns the first error encountered in the pipeline.\n *\n * @example\n * ```ts\n * pipe(1, n => n + 1, n => n * 2); // 4\n * pipe('a', s => s.toUpperCase(), s => s + '!'); // 'A!'\n * ```\n */\n// TODO: add up to 9 arguments\nexport function pipe<A, B>(value: A, fn1: Fn<Ok<A>, B>): B | Err<A>;\nexport function pipe<A, B, C>(value: A, fn1: Fn<Ok<A>, B>, fn2: Fn<Ok<B>, C>): C | Err<A> | Err<B>;\nexport function pipe<A, B, C, D>(\n  value: A,\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n): D | Err<A> | Err<B> | Err<C>;\nexport function pipe<A, B, C, D, E>(\n  value: A,\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n): E | Err<A> | Err<B> | Err<C> | Err<D>;\nexport function pipe<A, B, C, D, E, F>(\n  value: A,\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | F;\nexport function pipe<A, B, C, D, E, F, G>(\n  value: A,\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n  fn6: Fn<Ok<F>, G>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  value: A,\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n  fn6: Fn<Ok<F>, G>,\n  fn7: Fn<Ok<G>, H>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  value: A,\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n  fn6: Fn<Ok<F>, G>,\n  fn7: Fn<Ok<G>, H>,\n  fn8: Fn<Ok<H>, I>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | Err<H> | I;\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  value: A,\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n  fn6: Fn<Ok<F>, G>,\n  fn7: Fn<Ok<G>, H>,\n  fn8: Fn<Ok<H>, I>,\n  fn9: Fn<Ok<I>, J>,\n): Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | Err<H> | Err<I> | J;\nexport function pipe(input: unknown, ...pipeline: readonly ((value: any) => unknown)[]): any {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  return pipeImplementation(input, ...pipeline);\n}\n","import type { Err, Fn, Ok } from '../types';\n\nimport { pipeImplementation } from './internal/_pipe';\n\n/**\n * Returns a function that pipes a value through a sequence of functions from left to right.\n * Stops and returns the first error encountered in the pipeline.\n *\n * @example\n * ```ts\n * piped(n => n + 1, n => n * 2)(1); // 4\n * piped(s => s.toUpperCase(), s => s + '!')('a'); // 'A!'\n * ```\n */\nexport function piped<A, B>(fn1: Fn<Ok<A>, B>): (input: A) => B | Err<A>;\nexport function piped<A, B, C>(fn1: Fn<Ok<A>, B>, fn2: Fn<Ok<B>, C>): (input: A) => C | Err<A> | Err<B>;\nexport function piped<A, B, C, D>(\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n): (input: A) => D | Err<A> | Err<B> | Err<C>;\nexport function piped<A, B, C, D, E>(\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n): (input: A) => E | Err<A> | Err<B> | Err<C> | Err<D>;\nexport function piped<A, B, C, D, E, F>(\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | F;\nexport function piped<A, B, C, D, E, F, G>(\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n  fn6: Fn<Ok<F>, G>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | G;\nexport function piped<A, B, C, D, E, F, G, H>(\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n  fn6: Fn<Ok<F>, G>,\n  fn7: Fn<Ok<G>, H>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | H;\nexport function piped<A, B, C, D, E, F, G, H, I>(\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n  fn6: Fn<Ok<F>, G>,\n  fn7: Fn<Ok<G>, H>,\n  fn8: Fn<Ok<H>, I>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | Err<H> | I;\nexport function piped<A, B, C, D, E, F, G, H, I, J>(\n  fn1: Fn<Ok<A>, B>,\n  fn2: Fn<Ok<B>, C>,\n  fn3: Fn<Ok<C>, D>,\n  fn4: Fn<Ok<D>, E>,\n  fn5: Fn<Ok<E>, F>,\n  fn6: Fn<Ok<F>, G>,\n  fn7: Fn<Ok<G>, H>,\n  fn8: Fn<Ok<H>, I>,\n  fn9: Fn<Ok<I>, J>,\n): (input: A) => Err<A> | Err<B> | Err<C> | Err<D> | Err<E> | Err<F> | Err<G> | Err<H> | Err<I> | J;\nexport function piped(...pipeline: readonly ((input: unknown) => unknown)[]): (input: unknown) => any {\n  return (value: unknown): unknown => pipeImplementation(value, ...pipeline);\n}\n","/**\n * Runs a side-effect callback on a value and returns the original value unchanged.\n *\n * @example\n * ```ts\n * tap(console.log)(42); // logs 42, returns 42\n * tap(n => console.log(n * 2))([1, 2, 3]); // logs [2, 4, 6], returns [1, 2, 3]\n * ```\n */\nexport function tap<T>(callbackFn: (data: T) => void): (data: T) => T {\n  return (data: T) => {\n    callbackFn(data);\n    return data;\n  };\n}\n","import { purry } from './purry';\n\nfunction unlessImplementation<T>(data: T, predicate: (data: T) => boolean, fn: (data: T) => T): T {\n  return predicate(data) ? data : fn(data);\n}\n\n/**\n * Applies a transformation when a predicate is false; otherwise returns the value unchanged.\n *\n * @example\n * ```ts\n * unless(1, n => n > 1, n => n * 10); // 10\n * unless(n => n > 1, n => n * 10)(1); // 10\n * unless(2, n => n > 1, n => n * 10); // 2\n * ```\n */\nexport function unless<T, S extends T>(predicate: (data: T) => data is S, fn: (data: S) => T): (data: T) => T;\nexport function unless<T>(predicate: (data: T) => boolean, fn: (data: T) => T): (data: T) => T;\nexport function unless<T, S extends T>(data: T, predicate: (data: T) => data is S, fn: (data: S) => T): T;\nexport function unless<T>(data: T, predicate: (data: T) => boolean, fn: (data: T) => T): T;\nexport function unless(...args: unknown[]): unknown {\n  return purry(unlessImplementation, args);\n}\n","import { purry } from './purry';\n\nfunction whenImplementation<T>(data: T, predicate: (data: T) => boolean, fn: (data: T) => T): T {\n  return predicate(data) ? fn(data) : data;\n}\n\n/**\n * Applies a transformation when a predicate is true; otherwise returns the value unchanged.\n *\n * @example\n * ```ts\n * when(2, n => n > 1, n => n * 10); // 20\n * when(n => n > 1, n => n * 10)(2); // 20\n * when(1, n => n > 1, n => n * 10); // 1\n * ```\n */\nexport function when<T, S extends T>(predicate: (data: T) => data is S, fn: (data: S) => T): (data: T) => T;\nexport function when<T>(predicate: (data: T) => boolean, fn: (data: T) => T): (data: T) => T;\nexport function when<T, S extends T>(data: T, predicate: (data: T) => data is S, fn: (data: S) => T): T;\nexport function when<T>(data: T, predicate: (data: T) => boolean, fn: (data: T) => T): T;\nexport function when(...args: unknown[]): unknown {\n  return purry(whenImplementation, args);\n}\n"],"mappings":"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"}

package/dist/{get-yrs1Kqho.cjs → get-1kqkxPFX.cjs}

@@ -1,4 +1,4 @@
-const require_purry = require("./purry-B2_0DGLV.cjs");
+const require_purry = require("./purry-Dqp_F64t.cjs");
 const require_errors = require("./errors-O-d_Vemi.cjs");
 //#region src/object/get.ts
 function getImplementation(obj, key) {
@@ -13,6 +13,15 @@ function getOrImplementation(obj, key, defaultValue) {
 function getOr(...args) {
 	return require_purry.purry(getOrImplementation, args);
 }
+/**
+* Like `get`, but returns a default value when the property is missing or nullish.
+*
+* @example
+* ```ts
+* get.or('name', 'Unknown', { name: 'John' }); // 'John'
+* get.or('age', 0)({ name: 'John' }); // 0
+* ```
+*/
 get.or = getOr;
 function getAssertImplementation(obj, key) {
 	return obj[key];
@@ -20,6 +29,15 @@ function getAssertImplementation(obj, key) {
 function getAssert(...args) {
 	return require_purry.purry(getAssertImplementation, args);
 }
+/**
+* Like `get`, but returns the property value directly without wrapping missing values in a `NotFoundError`.
+*
+* @example
+* ```ts
+* get.assert('name', { name: 'John' }); // 'John'
+* get.assert('age')({ name: 'John' }); // undefined
+* ```
+*/
 get.assert = getAssert;
 //#endregion
 Object.defineProperty(exports, "get", {
@@ -28,11 +46,5 @@ Object.defineProperty(exports, "get", {
 		return get;
 	}
 });
-Object.defineProperty(exports, "getAssert", {
-	enumerable: true,
-	get: function() {
-		return getAssert;
-	}
-});
 
-//# sourceMappingURL=get-yrs1Kqho.cjs.map
+//# sourceMappingURL=get-1kqkxPFX.cjs.map

package/dist/get-1kqkxPFX.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-1kqkxPFX.cjs","names":["NotFoundError","purry"],"sources":["../src/object/get.ts"],"sourcesContent":["import { NotFoundError } from '../errors';\nimport { purry } from '../function/purry';\n\nfunction getImplementation<Obj extends object, Key extends keyof Obj>(\n  obj: Obj,\n  key: Key,\n): NonNullable<Obj[Key]> | NotFoundError {\n  return obj[key] ?? new NotFoundError(`Obj.get() :: Property ${String(key)} not found in object`);\n}\n\n/**\n * Gets a property from an object by key.\n * Returns a not-found error when the property is missing or nullish.\n *\n * @example\n * ```ts\n * get('name', { name: 'John' }); // 'John'\n * get('age')({ name: 'John' }); // NotFoundError\n * ```\n */\nexport function get<Obj extends object, Key extends keyof Obj>(\n  key: Key,\n): (obj: Obj) => NonNullable<Obj[Key]> | NotFoundError;\nexport function get<Obj extends object, Key extends keyof Obj>(\n  obj: Obj,\n  key: Key,\n): NonNullable<Obj[Key]> | NotFoundError;\nexport function get(...args: unknown[]): unknown {\n  return purry(getImplementation, args);\n}\n\nfunction getOrImplementation<Obj extends object, Key extends keyof Obj>(\n  obj: Obj,\n  key: Key,\n  defaultValue: NonNullable<Obj[Key]>,\n): Obj[Key] {\n  return obj[key] ?? defaultValue;\n}\n\nfunction getOr<Obj extends object, Key extends keyof Obj>(\n  obj: Obj,\n  key: Key,\n  defaultValue: NonNullable<Obj[Key]>,\n): Obj[Key];\nfunction getOr(...args: unknown[]): unknown {\n  return purry(getOrImplementation, args);\n}\n\n/**\n * Like `get`, but returns a default value when the property is missing or nullish.\n *\n * @example\n * ```ts\n * get.or('name', 'Unknown', { name: 'John' }); // 'John'\n * get.or('age', 0)({ name: 'John' }); // 0\n * ```\n */\nget.or = getOr;\n\nfunction getAssertImplementation<Obj extends object, Key extends keyof Obj>(obj: Obj, key: Key): Obj[Key] {\n  return obj[key];\n}\n\nfunction getAssert<Obj extends object, Key extends keyof Obj>(key: Key): (obj: Obj) => NonNullable<Obj[Key]>;\nfunction getAssert<Obj extends object, Key extends keyof Obj>(obj: Obj, key: Key): NonNullable<Obj[Key]>;\nfunction getAssert(...args: unknown[]): unknown {\n  return purry(getAssertImplementation, args);\n}\n\n/**\n * Like `get`, but returns the property value directly without wrapping missing values in a `NotFoundError`.\n *\n * @example\n * ```ts\n * get.assert('name', { name: 'John' }); // 'John'\n * get.assert('age')({ name: 'John' }); // undefined\n * ```\n */\nget.assert = getAssert;\n"],"mappings":";;;AAGA,SAAS,kBACP,KACA,KACuC;CACvC,OAAO,IAAI,QAAQ,IAAIA,eAAAA,cAAc,yBAAyB,OAAO,GAAG,EAAE,qBAAqB;AACjG;AAmBA,SAAgB,IAAI,GAAG,MAA0B;CAC/C,OAAOC,cAAAA,MAAM,mBAAmB,IAAI;AACtC;AAEA,SAAS,oBACP,KACA,KACA,cACU;CACV,OAAO,IAAI,QAAQ;AACrB;AAOA,SAAS,MAAM,GAAG,MAA0B;CAC1C,OAAOA,cAAAA,MAAM,qBAAqB,IAAI;AACxC;;;;;;;;;;AAWA,IAAI,KAAK;AAET,SAAS,wBAAmE,KAAU,KAAoB;CACxG,OAAO,IAAI;AACb;AAIA,SAAS,UAAU,GAAG,MAA0B;CAC9C,OAAOA,cAAAA,MAAM,yBAAyB,IAAI;AAC5C;;;;;;;;;;AAWA,IAAI,SAAS"}

package/dist/{get-CWL_cu6G.mjs → get-Dv6ejLZg.mjs}

@@ -1,4 +1,4 @@
-import { t as purry } from "./purry-BOWmqwDB.mjs";
+import { t as purry } from "./purry-DXnhXie9.mjs";
 import { i as NotFoundError } from "./errors-Dw1kitu_.mjs";
 //#region src/object/get.ts
 function getImplementation(obj, key) {
@@ -13,6 +13,15 @@ function getOrImplementation(obj, key, defaultValue) {
 function getOr(...args) {
 	return purry(getOrImplementation, args);
 }
+/**
+* Like `get`, but returns a default value when the property is missing or nullish.
+*
+* @example
+* ```ts
+* get.or('name', 'Unknown', { name: 'John' }); // 'John'
+* get.or('age', 0)({ name: 'John' }); // 0
+* ```
+*/
 get.or = getOr;
 function getAssertImplementation(obj, key) {
 	return obj[key];
@@ -20,8 +29,17 @@ function getAssertImplementation(obj, key) {
 function getAssert(...args) {
 	return purry(getAssertImplementation, args);
 }
+/**
+* Like `get`, but returns the property value directly without wrapping missing values in a `NotFoundError`.
+*
+* @example
+* ```ts
+* get.assert('name', { name: 'John' }); // 'John'
+* get.assert('age')({ name: 'John' }); // undefined
+* ```
+*/
 get.assert = getAssert;
 //#endregion
-export { getAssert as n, get as t };
+export { get as t };
 
-//# sourceMappingURL=get-CWL_cu6G.mjs.map
+//# sourceMappingURL=get-Dv6ejLZg.mjs.map

package/dist/get-Dv6ejLZg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-Dv6ejLZg.mjs","names":[],"sources":["../src/object/get.ts"],"sourcesContent":["import { NotFoundError } from '../errors';\nimport { purry } from '../function/purry';\n\nfunction getImplementation<Obj extends object, Key extends keyof Obj>(\n  obj: Obj,\n  key: Key,\n): NonNullable<Obj[Key]> | NotFoundError {\n  return obj[key] ?? new NotFoundError(`Obj.get() :: Property ${String(key)} not found in object`);\n}\n\n/**\n * Gets a property from an object by key.\n * Returns a not-found error when the property is missing or nullish.\n *\n * @example\n * ```ts\n * get('name', { name: 'John' }); // 'John'\n * get('age')({ name: 'John' }); // NotFoundError\n * ```\n */\nexport function get<Obj extends object, Key extends keyof Obj>(\n  key: Key,\n): (obj: Obj) => NonNullable<Obj[Key]> | NotFoundError;\nexport function get<Obj extends object, Key extends keyof Obj>(\n  obj: Obj,\n  key: Key,\n): NonNullable<Obj[Key]> | NotFoundError;\nexport function get(...args: unknown[]): unknown {\n  return purry(getImplementation, args);\n}\n\nfunction getOrImplementation<Obj extends object, Key extends keyof Obj>(\n  obj: Obj,\n  key: Key,\n  defaultValue: NonNullable<Obj[Key]>,\n): Obj[Key] {\n  return obj[key] ?? defaultValue;\n}\n\nfunction getOr<Obj extends object, Key extends keyof Obj>(\n  obj: Obj,\n  key: Key,\n  defaultValue: NonNullable<Obj[Key]>,\n): Obj[Key];\nfunction getOr(...args: unknown[]): unknown {\n  return purry(getOrImplementation, args);\n}\n\n/**\n * Like `get`, but returns a default value when the property is missing or nullish.\n *\n * @example\n * ```ts\n * get.or('name', 'Unknown', { name: 'John' }); // 'John'\n * get.or('age', 0)({ name: 'John' }); // 0\n * ```\n */\nget.or = getOr;\n\nfunction getAssertImplementation<Obj extends object, Key extends keyof Obj>(obj: Obj, key: Key): Obj[Key] {\n  return obj[key];\n}\n\nfunction getAssert<Obj extends object, Key extends keyof Obj>(key: Key): (obj: Obj) => NonNullable<Obj[Key]>;\nfunction getAssert<Obj extends object, Key extends keyof Obj>(obj: Obj, key: Key): NonNullable<Obj[Key]>;\nfunction getAssert(...args: unknown[]): unknown {\n  return purry(getAssertImplementation, args);\n}\n\n/**\n * Like `get`, but returns the property value directly without wrapping missing values in a `NotFoundError`.\n *\n * @example\n * ```ts\n * get.assert('name', { name: 'John' }); // 'John'\n * get.assert('age')({ name: 'John' }); // undefined\n * ```\n */\nget.assert = getAssert;\n"],"mappings":";;;AAGA,SAAS,kBACP,KACA,KACuC;CACvC,OAAO,IAAI,QAAQ,IAAI,cAAc,yBAAyB,OAAO,GAAG,EAAE,qBAAqB;AACjG;AAmBA,SAAgB,IAAI,GAAG,MAA0B;CAC/C,OAAO,MAAM,mBAAmB,IAAI;AACtC;AAEA,SAAS,oBACP,KACA,KACA,cACU;CACV,OAAO,IAAI,QAAQ;AACrB;AAOA,SAAS,MAAM,GAAG,MAA0B;CAC1C,OAAO,MAAM,qBAAqB,IAAI;AACxC;;;;;;;;;;AAWA,IAAI,KAAK;AAET,SAAS,wBAAmE,KAAU,KAAoB;CACxG,OAAO,IAAI;AACb;AAIA,SAAS,UAAU,GAAG,MAA0B;CAC9C,OAAO,MAAM,yBAAyB,IAAI;AAC5C;;;;;;;;;;AAWA,IAAI,SAAS"}

package/dist/guard/index.cjs

@@ -1,12 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_isNotNil = require("../isNotNil-DrF-ohem.cjs");
+const require_orNull = require("../orNull-CJNrTjhQ.cjs");
 //#region src/guard/isNull.ts
 /**
-* Check whether a value is strictly `null`.
-*
-* @category Guard
-* @param value - The value to check.
-* @returns `true` if `value` is `null`; otherwise `false`.
+* Checks whether a value is strictly `null`.
 *
 * @example
 * ```ts
@@ -20,11 +16,7 @@ function isNull(value) {
 //#endregion
 //#region src/guard/isUndefined.ts
 /**
-* Check whether a value is strictly `undefined`.
-*
-* @category Guard
-* @param value - The value to check.
-* @returns `true` if `value` is `undefined`; otherwise `false`.
+* Checks whether a value is strictly `undefined`.
 *
 * @example
 * ```ts
@@ -36,8 +28,9 @@ function isUndefined(value) {
 	return value === void 0;
 }
 //#endregion
-exports.isNotNil = require_isNotNil.isNotNil;
+exports.isNotNil = require_orNull.isNotNil;
 exports.isNull = isNull;
 exports.isUndefined = isUndefined;
+exports.orNull = require_orNull.orNull;
 
 //# sourceMappingURL=index.cjs.map

package/dist/guard/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/guard/isNull.ts","../../src/guard/isUndefined.ts"],"sourcesContent":["/**\n * Check whether a value is strictly `null`.\n *\n * @category Guard\n * @param value - The value to check.\n * @returns `true` if `value` is `null`; otherwise `false`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * isNull(undefined); // false\n * ```\n */\nexport function isNull<T>(value: T): value is T & null {\n  return value === null;\n}\n","/**\n * Check whether a value is strictly `undefined`.\n *\n * @category Guard\n * @param value - The value to check.\n * @returns `true` if `value` is `undefined`; otherwise `false`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * isUndefined(null); // false\n * ```\n */\nexport function isUndefined<T>(value: T): value is T & undefined {\n  return value === undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAaA,SAAgB,OAAU,OAA6B;CACrD,OAAO,UAAU;AACnB;;;;;;;;;;;;;;;;ACFA,SAAgB,YAAe,OAAkC;CAC/D,OAAO,UAAU,KAAA;AACnB"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/guard/isNull.ts","../../src/guard/isUndefined.ts"],"sourcesContent":["/**\n * Checks whether a value is strictly `null`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * isNull(undefined); // false\n * ```\n */\nexport function isNull<T>(value: T): value is T & null {\n  return value === null;\n}\n","/**\n * Checks whether a value is strictly `undefined`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * isUndefined(null); // false\n * ```\n */\nexport function isUndefined<T>(value: T): value is T & undefined {\n  return value === undefined;\n}\n"],"mappings":";;;;;;;;;;;;AASA,SAAgB,OAAU,OAA6B;CACrD,OAAO,UAAU;AACnB;;;;;;;;;;;;ACFA,SAAgB,YAAe,OAAkC;CAC/D,OAAO,UAAU,KAAA;AACnB"}

package/dist/guard/index.d.cts

@@ -1,11 +1,6 @@
 //#region src/guard/isNotNil.d.ts
 /**
- * Check whether a value is not nullish (`null` nor `undefined`), using loose inequality (`!= null`).
- * Narrows the type to {@link NonNullable}.
- *
- * @category Guard
- * @param value - The value to check.
- * @returns `true` if `value` is neither `null` nor `undefined`; otherwise `false`.
+ * Checks whether a value is neither `null` nor `undefined`.
  *
  * @example
  * ```ts
@@ -18,11 +13,7 @@ declare function isNotNil<T>(value: T): value is NonNullable<T>;
 //#endregion
 //#region src/guard/isNull.d.ts
 /**
- * Check whether a value is strictly `null`.
- *
- * @category Guard
- * @param value - The value to check.
- * @returns `true` if `value` is `null`; otherwise `false`.
+ * Checks whether a value is strictly `null`.
  *
  * @example
  * ```ts
@@ -32,13 +23,23 @@ declare function isNotNil<T>(value: T): value is NonNullable<T>;
  */
 declare function isNull<T>(value: T): value is T & null;
 //#endregion
-//#region src/guard/isUndefined.d.ts
+//#region src/guard/orNull.d.ts
 /**
- * Check whether a value is strictly `undefined`.
+ * Normalizes nullish values to `null`, leaving all other values unchanged.
+ * Equivalent to `value ?? null`.
  *
- * @category Guard
- * @param value - The value to check.
- * @returns `true` if `value` is `undefined`; otherwise `false`.
+ * @example
+ * ```ts
+ * orNull(0); // 0
+ * orNull(undefined); // null
+ * orNull(null); // null
+ * ```
+ */
+declare function orNull<T>(value: T | null | undefined): NonNullable<T> | null;
+//#endregion
+//#region src/guard/isUndefined.d.ts
+/**
+ * Checks whether a value is strictly `undefined`.
  *
  * @example
  * ```ts
@@ -48,5 +49,5 @@ declare function isNull<T>(value: T): value is T & null;
  */
 declare function isUndefined<T>(value: T): value is T & undefined;
 //#endregion
-export { isNotNil, isNull, isUndefined };
+export { isNotNil, isNull, isUndefined, orNull };
 //# sourceMappingURL=index.d.cts.map

package/dist/guard/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/guard/isNotNil.ts","../../src/guard/isNull.ts","../../src/guard/isUndefined.ts"],"mappings":";;AAeA;;;;;;;;;;;;;;iBAAgB,QAAA,IAAY,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,WAAA,CAAY,CAAA;;;;AAA5D;;;;;;;;;;;;iBCFgB,MAAA,IAAU,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC;;;;ADE/C;;;;;;;;;;;;iBEFgB,WAAA,IAAe,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/guard/isNotNil.ts","../../src/guard/isNull.ts","../../src/guard/orNull.ts","../../src/guard/isUndefined.ts"],"mappings":";;AAUA;;;;;;;;;iBAAgB,QAAA,IAAY,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,WAAA,CAAY,CAAA;;;;AAA5D;;;;;;;;iBCDgB,MAAA,IAAU,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC;;;;ADC/C;;;;;;;;;;iBECgB,MAAA,IAAU,KAAA,EAAO,CAAA,sBAAuB,WAAA,CAAY,CAAA;;;;AFDpE;;;;;;;;iBGDgB,WAAA,IAAe,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC"}

package/dist/guard/index.d.mts

@@ -1,11 +1,6 @@
 //#region src/guard/isNotNil.d.ts
 /**
- * Check whether a value is not nullish (`null` nor `undefined`), using loose inequality (`!= null`).
- * Narrows the type to {@link NonNullable}.
- *
- * @category Guard
- * @param value - The value to check.
- * @returns `true` if `value` is neither `null` nor `undefined`; otherwise `false`.
+ * Checks whether a value is neither `null` nor `undefined`.
  *
  * @example
  * ```ts
@@ -18,11 +13,7 @@ declare function isNotNil<T>(value: T): value is NonNullable<T>;
 //#endregion
 //#region src/guard/isNull.d.ts
 /**
- * Check whether a value is strictly `null`.
- *
- * @category Guard
- * @param value - The value to check.
- * @returns `true` if `value` is `null`; otherwise `false`.
+ * Checks whether a value is strictly `null`.
  *
  * @example
  * ```ts
@@ -32,13 +23,23 @@ declare function isNotNil<T>(value: T): value is NonNullable<T>;
  */
 declare function isNull<T>(value: T): value is T & null;
 //#endregion
-//#region src/guard/isUndefined.d.ts
+//#region src/guard/orNull.d.ts
 /**
- * Check whether a value is strictly `undefined`.
+ * Normalizes nullish values to `null`, leaving all other values unchanged.
+ * Equivalent to `value ?? null`.
  *
- * @category Guard
- * @param value - The value to check.
- * @returns `true` if `value` is `undefined`; otherwise `false`.
+ * @example
+ * ```ts
+ * orNull(0); // 0
+ * orNull(undefined); // null
+ * orNull(null); // null
+ * ```
+ */
+declare function orNull<T>(value: T | null | undefined): NonNullable<T> | null;
+//#endregion
+//#region src/guard/isUndefined.d.ts
+/**
+ * Checks whether a value is strictly `undefined`.
  *
  * @example
  * ```ts
@@ -48,5 +49,5 @@ declare function isNull<T>(value: T): value is T & null;
  */
 declare function isUndefined<T>(value: T): value is T & undefined;
 //#endregion
-export { isNotNil, isNull, isUndefined };
+export { isNotNil, isNull, isUndefined, orNull };
 //# sourceMappingURL=index.d.mts.map

package/dist/guard/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/guard/isNotNil.ts","../../src/guard/isNull.ts","../../src/guard/isUndefined.ts"],"mappings":";;AAeA;;;;;;;;;;;;;;iBAAgB,QAAA,IAAY,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,WAAA,CAAY,CAAA;;;;AAA5D;;;;;;;;;;;;iBCFgB,MAAA,IAAU,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC;;;;ADE/C;;;;;;;;;;;;iBEFgB,WAAA,IAAe,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/guard/isNotNil.ts","../../src/guard/isNull.ts","../../src/guard/orNull.ts","../../src/guard/isUndefined.ts"],"mappings":";;AAUA;;;;;;;;;iBAAgB,QAAA,IAAY,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,WAAA,CAAY,CAAA;;;;AAA5D;;;;;;;;iBCDgB,MAAA,IAAU,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC;;;;ADC/C;;;;;;;;;;iBECgB,MAAA,IAAU,KAAA,EAAO,CAAA,sBAAuB,WAAA,CAAY,CAAA;;;;AFDpE;;;;;;;;iBGDgB,WAAA,IAAe,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC"}

package/dist/guard/index.mjs

@@ -1,11 +1,7 @@
-import { t as isNotNil } from "../isNotNil-R5f1hC53.mjs";
+import { n as isNotNil, t as orNull } from "../orNull-EeXiCxD4.mjs";
 //#region src/guard/isNull.ts
 /**
-* Check whether a value is strictly `null`.
-*
-* @category Guard
-* @param value - The value to check.
-* @returns `true` if `value` is `null`; otherwise `false`.
+* Checks whether a value is strictly `null`.
 *
 * @example
 * ```ts
@@ -19,11 +15,7 @@ function isNull(value) {
 //#endregion
 //#region src/guard/isUndefined.ts
 /**
-* Check whether a value is strictly `undefined`.
-*
-* @category Guard
-* @param value - The value to check.
-* @returns `true` if `value` is `undefined`; otherwise `false`.
+* Checks whether a value is strictly `undefined`.
 *
 * @example
 * ```ts
@@ -35,6 +27,6 @@ function isUndefined(value) {
 	return value === void 0;
 }
 //#endregion
-export { isNotNil, isNull, isUndefined };
+export { isNotNil, isNull, isUndefined, orNull };
 
 //# sourceMappingURL=index.mjs.map

package/dist/guard/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/guard/isNull.ts","../../src/guard/isUndefined.ts"],"sourcesContent":["/**\n * Check whether a value is strictly `null`.\n *\n * @category Guard\n * @param value - The value to check.\n * @returns `true` if `value` is `null`; otherwise `false`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * isNull(undefined); // false\n * ```\n */\nexport function isNull<T>(value: T): value is T & null {\n  return value === null;\n}\n","/**\n * Check whether a value is strictly `undefined`.\n *\n * @category Guard\n * @param value - The value to check.\n * @returns `true` if `value` is `undefined`; otherwise `false`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * isUndefined(null); // false\n * ```\n */\nexport function isUndefined<T>(value: T): value is T & undefined {\n  return value === undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAaA,SAAgB,OAAU,OAA6B;CACrD,OAAO,UAAU;AACnB;;;;;;;;;;;;;;;;ACFA,SAAgB,YAAe,OAAkC;CAC/D,OAAO,UAAU,KAAA;AACnB"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/guard/isNull.ts","../../src/guard/isUndefined.ts"],"sourcesContent":["/**\n * Checks whether a value is strictly `null`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * isNull(undefined); // false\n * ```\n */\nexport function isNull<T>(value: T): value is T & null {\n  return value === null;\n}\n","/**\n * Checks whether a value is strictly `undefined`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * isUndefined(null); // false\n * ```\n */\nexport function isUndefined<T>(value: T): value is T & undefined {\n  return value === undefined;\n}\n"],"mappings":";;;;;;;;;;;AASA,SAAgB,OAAU,OAA6B;CACrD,OAAO,UAAU;AACnB;;;;;;;;;;;;ACFA,SAAgB,YAAe,OAAkC;CAC/D,OAAO,UAAU,KAAA;AACnB"}

package/dist/index-MbdqaUt1.d.cts

@@ -0,0 +1,54 @@
+import { i as Order } from "./order.constants-DpGY-EDp.cjs";
+
+//#region src/order/breakTie.d.ts
+declare function breakTieImplementation(order: Order, other: Order): Order;
+/**
+ * Resolves a tie by returning `other` when `order` is equal; otherwise returns `order`.
+ *
+ * @example
+ * ```ts
+ * breakTie(0, 1); // 1
+ * breakTie(-1, 1); // -1
+ * breakTie(1)(0); // 1
+ * ```
+ */
+declare function breakTie(other: Order): (order: Order) => Order;
+declare function breakTie(order: Order, other: Order): Order;
+//#endregion
+//#region src/order/compare.d.ts
+/**
+ * Compares two order values and returns their relative ordering.
+ *
+ * @example
+ * ```ts
+ * compare(-1, 1); // throws NotYetImplementedError
+ * ```
+ */
+declare function compare(left: Order, right: Order): Order;
+//#endregion
+//#region src/order/negate.d.ts
+/**
+ * Flips an order value: less-than becomes greater-than and vice versa; equal stays equal.
+ *
+ * @example
+ * ```ts
+ * negate(-1); // 1
+ * negate(0); // 0
+ * negate(1); // -1
+ * ```
+ */
+declare function negate(order: Order): Order;
+//#endregion
+//#region src/order/reverse.d.ts
+/**
+ * Reverses an orderer by negating its result.
+ *
+ * @example
+ * ```ts
+ * reverse((a, b) => (a < b ? -1 : a > b ? 1 : 0))(2, 1); // 1
+ * ```
+ */
+declare function reverse<T>(orderer: (left: T, right: T) => Order): (left: T, right: T) => Order;
+//#endregion
+export { breakTieImplementation as a, breakTie as i, negate as n, compare as r, reverse as t };
+//# sourceMappingURL=index-MbdqaUt1.d.cts.map

package/dist/index-MbdqaUt1.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-MbdqaUt1.d.cts","names":[],"sources":["../src/order/breakTie.ts","../src/order/compare.ts","../src/order/negate.ts","../src/order/reverse.ts"],"mappings":";;;iBAIgB,sBAAA,CAAuB,KAAA,EAAO,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;AAApE;;;;;;;;;iBAegB,QAAA,CAAS,KAAA,EAAO,KAAA,IAAS,KAAA,EAAO,KAAA,KAAU,KAAA;AAAA,iBAC1C,QAAA,CAAS,KAAA,EAAO,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;;;;AAhBtD;;;;;;iBCcgB,OAAA,CAAQ,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;;;;ADdpD;;;;;;;;iBEWgB,MAAA,CAAO,KAAA,EAAO,KAAA,GAAQ,KAAK;;;;;AFX3C;;;;;;iBGOgB,OAAA,IAAW,OAAA,GAAU,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,KAAM,KAAA"}

package/dist/index-k-paNOu4.d.mts

@@ -0,0 +1,54 @@
+import { i as Order } from "./order.constants-DpGY-EDp.mjs";
+
+//#region src/order/breakTie.d.ts
+declare function breakTieImplementation(order: Order, other: Order): Order;
+/**
+ * Resolves a tie by returning `other` when `order` is equal; otherwise returns `order`.
+ *
+ * @example
+ * ```ts
+ * breakTie(0, 1); // 1
+ * breakTie(-1, 1); // -1
+ * breakTie(1)(0); // 1
+ * ```
+ */
+declare function breakTie(other: Order): (order: Order) => Order;
+declare function breakTie(order: Order, other: Order): Order;
+//#endregion
+//#region src/order/compare.d.ts
+/**
+ * Compares two order values and returns their relative ordering.
+ *
+ * @example
+ * ```ts
+ * compare(-1, 1); // throws NotYetImplementedError
+ * ```
+ */
+declare function compare(left: Order, right: Order): Order;
+//#endregion
+//#region src/order/negate.d.ts
+/**
+ * Flips an order value: less-than becomes greater-than and vice versa; equal stays equal.
+ *
+ * @example
+ * ```ts
+ * negate(-1); // 1
+ * negate(0); // 0
+ * negate(1); // -1
+ * ```
+ */
+declare function negate(order: Order): Order;
+//#endregion
+//#region src/order/reverse.d.ts
+/**
+ * Reverses an orderer by negating its result.
+ *
+ * @example
+ * ```ts
+ * reverse((a, b) => (a < b ? -1 : a > b ? 1 : 0))(2, 1); // 1
+ * ```
+ */
+declare function reverse<T>(orderer: (left: T, right: T) => Order): (left: T, right: T) => Order;
+//#endregion
+export { breakTieImplementation as a, breakTie as i, negate as n, compare as r, reverse as t };
+//# sourceMappingURL=index-k-paNOu4.d.mts.map

package/dist/index-k-paNOu4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-k-paNOu4.d.mts","names":[],"sources":["../src/order/breakTie.ts","../src/order/compare.ts","../src/order/negate.ts","../src/order/reverse.ts"],"mappings":";;;iBAIgB,sBAAA,CAAuB,KAAA,EAAO,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;AAApE;;;;;;;;;iBAegB,QAAA,CAAS,KAAA,EAAO,KAAA,IAAS,KAAA,EAAO,KAAA,KAAU,KAAA;AAAA,iBAC1C,QAAA,CAAS,KAAA,EAAO,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;;;;AAhBtD;;;;;;iBCcgB,OAAA,CAAQ,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;;;;ADdpD;;;;;;;;iBEWgB,MAAA,CAAO,KAAA,EAAO,KAAA,GAAQ,KAAK;;;;;AFX3C;;;;;;iBGOgB,OAAA,IAAW,OAAA,GAAU,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,KAAM,KAAA,IAAS,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,KAAM,KAAA"}

package/dist/iterator/index.cjs

@@ -1,8 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_purry = require("../purry-B2_0DGLV.cjs");
-const require_isNotNil = require("../isNotNil-DrF-ohem.cjs");
+const require_purry = require("../purry-Dqp_F64t.cjs");
+const require_orNull = require("../orNull-CJNrTjhQ.cjs");
 //#region src/iterator/_globalAliases.ts
-const { from } = Iterator;
+/**
+* Creates an iterator from an iterable or iterator object.
+* @function
+*/
+const from = Iterator.from;
 //#endregion
 //#region src/iterator/drop.ts
 function dropImplementation(iter, limit) {
@@ -33,29 +37,9 @@ function filter(...args) {
 	return require_purry.purry(filterImplementation, args);
 }
 //#endregion
-//#region src/guard/orNull.ts
-/**
-* Normalize nullish values to `null`, leaving all other values unchanged.
-* Equivalent to `value ?? null`.
-*
-* @category Guard
-* @param value - A value that may be `null` or `undefined`.
-* @returns `null` when `value` is `null` or `undefined`; otherwise `value` with `null` and `undefined` removed from its type.
-*
-* @example
-* ```ts
-* orNull(0); // 0
-* orNull(undefined); // null
-* orNull(null); // null
-* ```
-*/
-function orNull(value) {
-	return value ?? null;
-}
-//#endregion
 //#region src/iterator/find.ts
 function findImplementation(data, predicate) {
-	return orNull(data.find(predicate));
+	return require_orNull.orNull(data.find(predicate));
 }
 function find(...args) {
 	return require_purry.purry(findImplementation, args);
@@ -69,6 +53,17 @@ function flatMap(...args) {
 	return require_purry.purry(flatMapImplementation, args);
 }
 //#endregion
+//#region src/iterator/forEach.ts
+function forEachImplementation(data, fn) {
+	return data.map((value, index) => {
+		fn(value, index);
+		return value;
+	});
+}
+function forEach(...args) {
+	return require_purry.purry(forEachImplementation, args);
+}
+//#endregion
 //#region src/iterator/map.ts
 function mapImplementation(data, fn) {
 	return data.map(fn);
@@ -82,8 +77,8 @@ function rangeWithOptsImplementation(start, end, option) {
 	if (start === Infinity || start === -Infinity) throw new RangeError(`range() start argument cannot be ${start}`);
 	if (Number.isNaN(start)) throw new RangeError(`range() start argument cannot be NaN`);
 	if (Number.isNaN(end)) throw new RangeError(`range() end argument cannot be NaN`);
-	if (typeof start === "bigint" && require_isNotNil.isNotNil(option.step) && typeof option.step !== "bigint") throw new RangeError(`range() option.step argument must be of the same type as start`);
-	if (require_isNotNil.isNotNil(option.step) && option.step <= 0) {
+	if (typeof start === "bigint" && require_orNull.isNotNil(option.step) && typeof option.step !== "bigint") throw new RangeError(`range() option.step argument must be of the same type as start`);
+	if (require_orNull.isNotNil(option.step) && option.step <= 0) {
 		if (option.step < 1) throw new RangeError(`Arr.range() :: ${option.step} must be a positive integer`);
 	}
 	const { inclusive = false } = option;
@@ -144,11 +139,59 @@ function take(...args) {
 	return require_purry.purry(takeImplementation, args);
 }
 //#endregion
+//#region src/iterator/unique.ts
+/**
+* Returns an iterator with duplicate values removed.
+* Keeps the first occurrence of each value.
+*
+* @example
+* ```ts
+* unique([1, 2, 2, 3].values()).toArray(); // [1, 2, 3]
+* unique([].values()).toArray(); // []
+* ```
+*/
+function unique(data) {
+	const set = /* @__PURE__ */ new Set();
+	return data.filter((value) => {
+		if (set.has(value)) return false;
+		set.add(value);
+		return true;
+	});
+}
+//#endregion
+//#region src/iterator/uniqueBy.ts
+function uniqueByImplementation(data, mapFn) {
+	const set = /* @__PURE__ */ new Set();
+	return data.filter((value) => {
+		const key = mapFn(value);
+		if (set.has(key)) return false;
+		set.add(key);
+		return true;
+	});
+}
+function uniqueBy(...args) {
+	return require_purry.purry(uniqueByImplementation, args);
+}
+//#endregion
+//#region src/iterator/uniqueWith.ts
+function uniqueWithImplementation(data, isEqual) {
+	let indexCounter = 0;
+	const withIndex = data.map((value) => [value, indexCounter++]);
+	return withIndex.filter(([value, index]) => {
+		const [, foundIndex] = withIndex.find(([otherValue, otherIndex]) => index === otherIndex || isEqual(value, otherValue)) ?? [null, -1];
+		return index === foundIndex;
+	}).map(([v, _i]) => v);
+}
+function uniqueWith(...args) {
+	return require_purry.purry(uniqueWithImplementation, args);
+}
+//#endregion
 exports.drop = drop;
 exports.every = every;
 exports.filter = filter;
 exports.find = find;
 exports.flatMap = flatMap;
+exports.forEach = forEach;
 exports.from = from;
 exports.map = map;
 exports.range = range;
@@ -156,5 +199,8 @@ exports.rangeWithOpts = rangeWithOpts;
 exports.reduce = reduce;
 exports.some = some;
 exports.take = take;
+exports.unique = unique;
+exports.uniqueBy = uniqueBy;
+exports.uniqueWith = uniqueWith;
 
 //# sourceMappingURL=index.cjs.map