@ts-fns/stdlib 0.1.0 → 0.2.0

package/dist/tuple/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/tuple/at.ts","../../src/tuple/fanOut.ts","../../src/tuple/first.ts","../../src/tuple/insert.ts","../../src/tuple/mapBoth.ts","../../src/tuple/mapEach.ts","../../src/tuple/mapFirst.ts","../../src/tuple/mapSecond.ts","../../src/tuple/second.ts","../../src/tuple/swap.ts"],"sourcesContent":["import { purry } from '../function/purry';\n\nfunction at2Implementation<T>(tuple: T[], index: number): T {\n  if (index < 0) {\n    throw new RangeError(`Tuple.at() :: ${index} must be a positive integer`);\n  }\n  if (index >= tuple.length) {\n    throw new RangeError(`Tuple.at() :: ${index} is out of bounds`);\n  }\n\n  return tuple[index]!;\n}\n\n/**\n * Get an element from a tuple by index.\n *\n * @param tuple - The tuple to get the element from.\n * @param index - The index of the element to get.\n *\n * @example\n * ```ts\n * at(0, [1, 2, 3]) // 1\n * at(1, [1, 2, 3]) // 2\n * at([1, 2, 3], 0) // 1\n * at([1, 2, 3], 1) // 2\n * ```\n *\n * @throws {RangeError}\n */\nexport function at<T>(index: 0): (tuple: [T, ...unknown[]]) => T;\nexport function at<T>(index: 1): (tuple: [unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 2): (tuple: [unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 3): (tuple: [unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 4): (tuple: [unknown, unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 5): (tuple: [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 6): (tuple: [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(tuple: [T, ...unknown[]], index: 0): T;\nexport function at<T>(tuple: [unknown, T, ...unknown[]], index: 1): T;\nexport function at<T>(tuple: [unknown, unknown, T, ...unknown[]], index: 2): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, T, ...unknown[]], index: 3): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, unknown, T, ...unknown[]], index: 4): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]], index: 5): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]], index: 6): T;\nexport function at(...args: readonly unknown[]): unknown {\n  return purry(at2Implementation, args);\n}\n","import { purry } from '../function/purry';\n\nexport function fanOutImplementation<A, C, D>(value: A, fn1: (value: A) => C, fn2: (value: A) => D): [C, D] {\n  return [fn1(value), fn2(value)];\n}\n\n/**\n * Takes a value and two functions and returns a tuple of the results of the functions.\n *\n * @public\n * @category Tuple\n * @param value - The value to apply the functions to.\n * @param fn1 - The first function to apply to the value.\n * @param fn2 - The second function to apply to the value.\n *\n * @example\n * ```ts\n * fanOut((x) => x * 2, (x) => x + 1, 2); // [4, 3]\n * ```\n */\nexport function fanOut<A, C, D>(fn1: (value: A) => C, fn2: (value: A) => D): (value: A) => [C, D];\nexport function fanOut<A, C, D>(value: A, fn1: (value: A) => C, fn2: (value: A) => D): [C, D];\nexport function fanOut(...args: readonly unknown[]): unknown {\n  return purry(fanOutImplementation, args);\n}\n","/**\n * Returns the first element of a tuple with at least one element.\n *\n * @param tuple - A non-empty tuple.\n * @returns The element at index `0`.\n *\n * @example\n * ```ts\n * first([1, 2]); // 1\n * ```\n *\n * @throws {RangeError} When the tuple has fewer than one element.\n */\nexport function first<T>(tuple: [T, ...unknown[]]): T {\n  if (tuple.length < 1) {\n    throw new RangeError('Tuple.first() :: received a tuple with less than 1 element');\n  }\n  return tuple[0];\n}\n","/* eslint-disable @typescript-eslint/unified-signatures */\nimport { purry } from '../function/purry';\n\nfunction updateImplementation<T>(tuple: T[], index: number, value: T): T[] {\n  return tuple.with(index, value);\n}\n\n/**\n * Returns a new tuple with the element at `index` replaced by `value`.\n *\n * @param index - Zero-based index of the element to replace.\n * @param value - Replacement value.\n * @param tuple - The source tuple.\n *\n * @example\n * ```ts\n * insert([1, 2, 3], 1, 99); // [1, 99, 3]\n * insert(1, 99)([1, 2, 3]); // [1, 99, 3]\n * ```\n *\n * @throws {RangeError} When `index` is negative or out of bounds (from the underlying `with` call).\n */\nexport function insert<T>(index: 0, value: T): <U extends readonly [T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(index: 1, value: T): <U extends readonly [unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(index: 2, value: T): <U extends readonly [unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 3,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 4,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 5,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 6,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 7,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 8,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n) => U;\nexport function insert<T, U extends readonly [T, ...unknown[]]>(tuple: U, index: 0, value: T): U;\nexport function insert<T, U extends readonly [unknown, T, ...unknown[]]>(tuple: U, index: 1, value: T): U;\nexport function insert<T, U extends readonly [unknown, unknown, T, ...unknown[]]>(tuple: U, index: 2, value: T): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 3,\n  value: T,\n): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 4,\n  value: T,\n): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 5,\n  value: T,\n): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 6,\n  value: T,\n): U;\nexport function insert<\n  T,\n  U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]],\n>(tuple: U, index: 7, value: T): U;\nexport function insert<\n  T,\n  U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]],\n>(tuple: U, index: 8, value: T): U;\nexport function insert(...args: readonly unknown[]): unknown {\n  return purry(updateImplementation, args);\n}\n","import { purry } from '../function/purry';\n\n/**\n * Maps both elements of a homogeneous pair with the same function.\n */\nexport function mapBothImplementation<T, U>(tuple: [T, T], fn: (value: T) => U): [U, U] {\n  return [fn(tuple[0]), fn(tuple[1])];\n}\n\n/**\n * Maps both elements of a homogeneous pair with the same function.\n *\n * @param fn - Function applied to each element\n * @param tuple - A two-element tuple of the same type\n *\n * @example\n * ```ts\n * mapBoth([1, 2], (n) => n * 2); // [2, 4]\n * mapBoth((n) => n * 2)([1, 2]); // [2, 4]\n * ```\n */\nexport function mapBoth<T, U>(fn: (value: T) => U): (tuple: [T, T]) => [U, U];\nexport function mapBoth<T, U>(tuple: [T, T], fn: (value: T) => U): [U, U];\nexport function mapBoth(...args: readonly unknown[]): unknown {\n  return purry(mapBothImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction mapEachImplementation<A, B, X, Y>(tuple: [A, B], fnA: (value: A) => X, fnB: (value: B) => Y): [X, Y] {\n  return [fnA(tuple[0]), fnB(tuple[1])];\n}\n\n/**\n * Maps the first and second elements of a pair with two functions.\n *\n * @param fnA - Function applied to the first element\n * @param fnB - Function applied to the second element\n * @param tuple - A two-element tuple\n *\n * @example\n * ```ts\n * mapEach([1, 'a'], String, (s) => s.toUpperCase()); // ['1', 'A']\n * mapEach(String, (s) => s.toUpperCase())([1, 'a']); // ['1', 'A']\n * ```\n */\nexport function mapEach<A, B, X, Y>(fnA: (value: A) => X, fnB: (value: B) => Y): (tuple: [A, B]) => [X, Y];\nexport function mapEach<A, B, X, Y>(tuple: [A, B], fnA: (value: A) => X, fnB: (value: B) => Y): [X, Y];\nexport function mapEach(...args: readonly unknown[]): unknown {\n  return purry(mapEachImplementation, args);\n}\n","import { purry } from '../function/purry';\n\n/**\n * Maps the first element of a pair; leaves the second unchanged.\n */\nexport function mapFirstImplementation<A, B, X>(tuple: [A, B], fn: (value: A) => X): [X, B] {\n  return [fn(tuple[0]), tuple[1]];\n}\n\n/**\n * Maps the first element of a pair; leaves the second unchanged.\n *\n * @param fn - Function applied to the first element\n * @param tuple - A two-element tuple\n *\n * @example\n * ```ts\n * mapFirst([1, 'a'], (n) => n + 1); // [2, 'a']\n * mapFirst((n) => n + 1)([1, 'a']); // [2, 'a']\n * ```\n */\nexport function mapFirst<A, B, X>(fn: (value: A) => X): (tuple: [A, B]) => [X, B];\nexport function mapFirst<A, B, X>(tuple: [A, B], fn: (value: A) => X): [X, B];\nexport function mapFirst(...args: readonly unknown[]): unknown {\n  return purry(mapFirstImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction mapSecondImplementation<A, B, Y>(tuple: [A, B], fn: (value: B) => Y): [A, Y] {\n  return [tuple[0], fn(tuple[1])];\n}\n\n/**\n * Maps the second element of a pair; leaves the first unchanged.\n *\n * @param fn - Function applied to the second element\n * @param tuple - A two-element tuple (data-first overload).\n *\n * @example\n * ```ts\n * mapSecond([1, 'a'], (s) => s.toUpperCase()); // [1, 'A']\n * mapSecond((s) => s.toUpperCase())([1, 'a']); // [1, 'A']\n * ```\n */\nexport function mapSecond<A, B, Y>(fn: (value: B) => Y): (tuple: [A, B]) => [A, Y];\nexport function mapSecond<A, B, Y>(tuple: [A, B], fn: (value: B) => Y): [A, Y];\nexport function mapSecond(...args: readonly unknown[]): unknown {\n  return purry(mapSecondImplementation, args);\n}\n","/**\n * Returns the second element of a tuple with at least two elements.\n *\n * @param tuple - A tuple with at least two elements.\n * @returns The element at index `1`.\n *\n * @example\n * ```ts\n * second([1, 2]); // 2\n * ```\n *\n * @throws {RangeError} When the tuple has fewer than two elements.\n */\nexport function second<T>(tuple: [unknown, T, ...unknown[]]): T {\n  if (tuple.length < 2) {\n    throw new RangeError('Tuple.second() :: received a tuple with less than 2 elements');\n  }\n  return tuple[1];\n}\n","/**\n * Swaps the two elements of a pair.\n *\n * @param data - A two-element tuple.\n * @returns The tuple with elements reversed.\n *\n * @example\n * ```ts\n * swap([1, 'a']); // ['a', 1]\n * ```\n */\nexport function swap<A, B>(data: [A, B]): [B, A] {\n  return [data[1], data[0]];\n}\n"],"mappings":";;AAEA,SAAS,kBAAqB,OAAY,OAAkB;CAC1D,IAAI,QAAQ,GACV,MAAM,IAAI,WAAW,iBAAiB,MAAM,4BAA4B;CAE1E,IAAI,SAAS,MAAM,QACjB,MAAM,IAAI,WAAW,iBAAiB,MAAM,kBAAkB;CAGhE,OAAO,MAAM;AACf;AAgCA,SAAgB,GAAG,GAAG,MAAmC;CACvD,OAAO,MAAM,mBAAmB,IAAI;AACtC;;;AC3CA,SAAgB,qBAA8B,OAAU,KAAsB,KAA8B;CAC1G,OAAO,CAAC,IAAI,KAAK,GAAG,IAAI,KAAK,CAAC;AAChC;AAkBA,SAAgB,OAAO,GAAG,MAAmC;CAC3D,OAAO,MAAM,sBAAsB,IAAI;AACzC;;;;;;;;;;;;;;;;ACXA,SAAgB,MAAS,OAA6B;CACpD,IAAI,MAAM,SAAS,GACjB,MAAM,IAAI,WAAW,4DAA4D;CAEnF,OAAO,MAAM;AACf;;;ACfA,SAAS,qBAAwB,OAAY,OAAe,OAAe;CACzE,OAAO,MAAM,KAAK,OAAO,KAAK;AAChC;AA6EA,SAAgB,OAAO,GAAG,MAAmC;CAC3D,OAAO,MAAM,sBAAsB,IAAI;AACzC;;;;;;AC/EA,SAAgB,sBAA4B,OAAe,IAA6B;CACtF,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,GAAG,MAAM,EAAE,CAAC;AACpC;AAgBA,SAAgB,QAAQ,GAAG,MAAmC;CAC5D,OAAO,MAAM,uBAAuB,IAAI;AAC1C;;;ACvBA,SAAS,sBAAkC,OAAe,KAAsB,KAA8B;CAC5G,OAAO,CAAC,IAAI,MAAM,EAAE,GAAG,IAAI,MAAM,EAAE,CAAC;AACtC;AAiBA,SAAgB,QAAQ,GAAG,MAAmC;CAC5D,OAAO,MAAM,uBAAuB,IAAI;AAC1C;;;;;;AClBA,SAAgB,uBAAgC,OAAe,IAA6B;CAC1F,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;AAChC;AAgBA,SAAgB,SAAS,GAAG,MAAmC;CAC7D,OAAO,MAAM,wBAAwB,IAAI;AAC3C;;;ACvBA,SAAS,wBAAiC,OAAe,IAA6B;CACpF,OAAO,CAAC,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC;AAChC;AAgBA,SAAgB,UAAU,GAAG,MAAmC;CAC9D,OAAO,MAAM,yBAAyB,IAAI;AAC5C;;;;;;;;;;;;;;;;ACTA,SAAgB,OAAU,OAAsC;CAC9D,IAAI,MAAM,SAAS,GACjB,MAAM,IAAI,WAAW,8DAA8D;CAErF,OAAO,MAAM;AACf;;;;;;;;;;;;;;ACPA,SAAgB,KAAW,MAAsB;CAC/C,OAAO,CAAC,KAAK,IAAI,KAAK,EAAE;AAC1B"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/tuple/at.ts","../../src/tuple/fanOut.ts","../../src/tuple/from.ts","../../src/tuple/first.ts","../../src/tuple/insert.ts","../../src/tuple/mapBoth.ts","../../src/tuple/mapEach.ts","../../src/tuple/mapFirst.ts","../../src/tuple/mapSecond.ts","../../src/tuple/second.ts","../../src/tuple/swap.ts"],"sourcesContent":["import { purry } from '../function/purry';\n\nfunction at2Implementation<T>(tuple: T[], index: number): T {\n  if (index < 0) {\n    throw new RangeError(`Tuple.at() :: ${index} must be a positive integer`);\n  }\n  if (index >= tuple.length) {\n    throw new RangeError(`Tuple.at() :: ${index} is out of bounds`);\n  }\n\n  return tuple[index]!;\n}\n\n/**\n * Gets an element from a tuple by zero-based index.\n * Throws a range error when the index is negative or out of bounds.\n *\n * @example\n * ```ts\n * at(0, [1, 2, 3]); // 1\n * at(1)([1, 2, 3]); // 2\n * at([1, 2, 3], 10); // throws RangeError\n * ```\n */\nexport function at<T>(index: 0): (tuple: [T, ...unknown[]]) => T;\nexport function at<T>(index: 1): (tuple: [unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 2): (tuple: [unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 3): (tuple: [unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 4): (tuple: [unknown, unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 5): (tuple: [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 6): (tuple: [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(tuple: [T, ...unknown[]], index: 0): T;\nexport function at<T>(tuple: [unknown, T, ...unknown[]], index: 1): T;\nexport function at<T>(tuple: [unknown, unknown, T, ...unknown[]], index: 2): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, T, ...unknown[]], index: 3): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, unknown, T, ...unknown[]], index: 4): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]], index: 5): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]], index: 6): T;\nexport function at(...args: readonly unknown[]): unknown {\n  return purry(at2Implementation, args);\n}\n","import { purry } from '../function/purry';\n\nexport function fanOutImplementation<A, C, D>(value: A, fn1: (value: A) => C, fn2: (value: A) => D): [C, D] {\n  return [fn1(value), fn2(value)];\n}\n\n/**\n * Applies two functions to the same value and returns the results as a pair.\n *\n * @example\n * ```ts\n * fanOut((x) => x * 2, (x) => x + 1, 2); // [4, 3]\n * fanOut((x) => x * 2, (x) => x + 1)(2); // [4, 3]\n * ```\n */\nexport function fanOut<A, C, D>(fn1: (value: A) => C, fn2: (value: A) => D): (value: A) => [C, D];\nexport function fanOut<A, C, D>(value: A, fn1: (value: A) => C, fn2: (value: A) => D): [C, D];\nexport function fanOut(...args: readonly unknown[]): unknown {\n  return purry(fanOutImplementation, args);\n}\n","/**\n * Builds a two-element tuple from two values.\n *\n * @example\n * ```ts\n * from(1, 'a'); // [1, 'a']\n * ```\n */\nexport function from<A, B>(arg1: A, arg2: B): [A, B] {\n  return [arg1, arg2] as const;\n}\n","/**\n * Returns the first element of a non-empty tuple.\n * Throws a range error when the tuple has fewer than one element.\n *\n * @example\n * ```ts\n * first([1, 2]); // 1\n * first([]); // throws RangeError\n * ```\n */\nexport function first<T>(tuple: [T, ...unknown[]]): T {\n  if (tuple.length < 1) {\n    throw new RangeError('Tuple.first() :: received a tuple with less than 1 element');\n  }\n  return tuple[0];\n}\n","/* eslint-disable @typescript-eslint/unified-signatures */\nimport { purry } from '../function/purry';\n\nfunction updateImplementation<T>(tuple: T[], index: number, value: T): T[] {\n  return tuple.with(index, value);\n}\n\n/**\n * Returns a new tuple with the element at `index` replaced by `value`.\n * Throws a range error when `index` is negative or out of bounds.\n *\n * @example\n * ```ts\n * insert([1, 2, 3], 1, 99); // [1, 99, 3]\n * insert(1, 99)([1, 2, 3]); // [1, 99, 3]\n * insert([1, 2, 3], 10, 99); // throws RangeError\n * ```\n */\nexport function insert<T>(index: 0, value: T): <U extends readonly [T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(index: 1, value: T): <U extends readonly [unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(index: 2, value: T): <U extends readonly [unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 3,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 4,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 5,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 6,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 7,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 8,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n) => U;\nexport function insert<T, U extends readonly [T, ...unknown[]]>(tuple: U, index: 0, value: T): U;\nexport function insert<T, U extends readonly [unknown, T, ...unknown[]]>(tuple: U, index: 1, value: T): U;\nexport function insert<T, U extends readonly [unknown, unknown, T, ...unknown[]]>(tuple: U, index: 2, value: T): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 3,\n  value: T,\n): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 4,\n  value: T,\n): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 5,\n  value: T,\n): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 6,\n  value: T,\n): U;\nexport function insert<\n  T,\n  U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]],\n>(tuple: U, index: 7, value: T): U;\nexport function insert<\n  T,\n  U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]],\n>(tuple: U, index: 8, value: T): U;\nexport function insert(...args: readonly unknown[]): unknown {\n  return purry(updateImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nexport function mapBothImplementation<T, U>(tuple: [T, T], fn: (value: T) => U): [U, U] {\n  return [fn(tuple[0]), fn(tuple[1])];\n}\n\n/**\n * Maps both elements of a homogeneous pair with the same function.\n *\n * @example\n * ```ts\n * mapBoth([1, 2], (n) => n * 2); // [2, 4]\n * mapBoth((n) => n * 2)([1, 2]); // [2, 4]\n * ```\n */\nexport function mapBoth<T, U>(fn: (value: T) => U): (tuple: [T, T]) => [U, U];\nexport function mapBoth<T, U>(tuple: [T, T], fn: (value: T) => U): [U, U];\nexport function mapBoth(...args: readonly unknown[]): unknown {\n  return purry(mapBothImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction mapEachImplementation<A, B, X, Y>(tuple: [A, B], fnA: (value: A) => X, fnB: (value: B) => Y): [X, Y] {\n  return [fnA(tuple[0]), fnB(tuple[1])];\n}\n\n/**\n * Maps the first and second elements of a pair with separate functions.\n *\n * @example\n * ```ts\n * mapEach([1, 'a'], String, (s) => s.toUpperCase()); // ['1', 'A']\n * mapEach(String, (s) => s.toUpperCase())([1, 'a']); // ['1', 'A']\n * ```\n */\nexport function mapEach<A, B, X, Y>(fnA: (value: A) => X, fnB: (value: B) => Y): (tuple: [A, B]) => [X, Y];\nexport function mapEach<A, B, X, Y>(tuple: [A, B], fnA: (value: A) => X, fnB: (value: B) => Y): [X, Y];\nexport function mapEach(...args: readonly unknown[]): unknown {\n  return purry(mapEachImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nexport function mapFirstImplementation<A, B, X>(tuple: [A, B], fn: (value: A) => X): [X, B] {\n  return [fn(tuple[0]), tuple[1]];\n}\n\n/**\n * Maps the first element of a pair; leaves the second unchanged.\n *\n * @example\n * ```ts\n * mapFirst([1, 'a'], (n) => n + 1); // [2, 'a']\n * mapFirst((n) => n + 1)([1, 'a']); // [2, 'a']\n * ```\n */\nexport function mapFirst<A, B, X>(fn: (value: A) => X): (tuple: [A, B]) => [X, B];\nexport function mapFirst<A, B, X>(tuple: [A, B], fn: (value: A) => X): [X, B];\nexport function mapFirst(...args: readonly unknown[]): unknown {\n  return purry(mapFirstImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction mapSecondImplementation<A, B, Y>(tuple: [A, B], fn: (value: B) => Y): [A, Y] {\n  return [tuple[0], fn(tuple[1])];\n}\n\n/**\n * Maps the second element of a pair; leaves the first unchanged.\n *\n * @example\n * ```ts\n * mapSecond([1, 'a'], (s) => s.toUpperCase()); // [1, 'A']\n * mapSecond((s) => s.toUpperCase())([1, 'a']); // [1, 'A']\n * ```\n */\nexport function mapSecond<A, B, Y>(fn: (value: B) => Y): (tuple: [A, B]) => [A, Y];\nexport function mapSecond<A, B, Y>(tuple: [A, B], fn: (value: B) => Y): [A, Y];\nexport function mapSecond(...args: readonly unknown[]): unknown {\n  return purry(mapSecondImplementation, args);\n}\n","/**\n * Returns the second element of a tuple with at least two elements.\n * Throws a range error when the tuple has fewer than two elements.\n *\n * @example\n * ```ts\n * second([1, 2]); // 2\n * second([1]); // throws RangeError\n * ```\n */\nexport function second<T>(tuple: [unknown, T, ...unknown[]]): T {\n  if (tuple.length < 2) {\n    throw new RangeError('Tuple.second() :: received a tuple with less than 2 elements');\n  }\n  return tuple[1];\n}\n","/**\n * Swaps the two elements of a pair.\n *\n * @example\n * ```ts\n * swap([1, 'a']); // ['a', 1]\n * ```\n */\nexport function swap<A, B>(data: [A, B]): [B, A] {\n  return [data[1], data[0]];\n}\n"],"mappings":";;AAEA,SAAS,kBAAqB,OAAY,OAAkB;CAC1D,IAAI,QAAQ,GACV,MAAM,IAAI,WAAW,iBAAiB,MAAM,4BAA4B;CAE1E,IAAI,SAAS,MAAM,QACjB,MAAM,IAAI,WAAW,iBAAiB,MAAM,kBAAkB;CAGhE,OAAO,MAAM;AACf;AA2BA,SAAgB,GAAG,GAAG,MAAmC;CACvD,OAAO,MAAM,mBAAmB,IAAI;AACtC;;;ACtCA,SAAgB,qBAA8B,OAAU,KAAsB,KAA8B;CAC1G,OAAO,CAAC,IAAI,KAAK,GAAG,IAAI,KAAK,CAAC;AAChC;AAaA,SAAgB,OAAO,GAAG,MAAmC;CAC3D,OAAO,MAAM,sBAAsB,IAAI;AACzC;;;;;;;;;;;ACXA,SAAgB,KAAW,MAAS,MAAiB;CACnD,OAAO,CAAC,MAAM,IAAI;AACpB;;;;;;;;;;;;;ACAA,SAAgB,MAAS,OAA6B;CACpD,IAAI,MAAM,SAAS,GACjB,MAAM,IAAI,WAAW,4DAA4D;CAEnF,OAAO,MAAM;AACf;;;ACZA,SAAS,qBAAwB,OAAY,OAAe,OAAe;CACzE,OAAO,MAAM,KAAK,OAAO,KAAK;AAChC;AAyEA,SAAgB,OAAO,GAAG,MAAmC;CAC3D,OAAO,MAAM,sBAAsB,IAAI;AACzC;;;AC9EA,SAAgB,sBAA4B,OAAe,IAA6B;CACtF,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,GAAG,MAAM,EAAE,CAAC;AACpC;AAaA,SAAgB,QAAQ,GAAG,MAAmC;CAC5D,OAAO,MAAM,uBAAuB,IAAI;AAC1C;;;ACjBA,SAAS,sBAAkC,OAAe,KAAsB,KAA8B;CAC5G,OAAO,CAAC,IAAI,MAAM,EAAE,GAAG,IAAI,MAAM,EAAE,CAAC;AACtC;AAaA,SAAgB,QAAQ,GAAG,MAAmC;CAC5D,OAAO,MAAM,uBAAuB,IAAI;AAC1C;;;ACjBA,SAAgB,uBAAgC,OAAe,IAA6B;CAC1F,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;AAChC;AAaA,SAAgB,SAAS,GAAG,MAAmC;CAC7D,OAAO,MAAM,wBAAwB,IAAI;AAC3C;;;ACjBA,SAAS,wBAAiC,OAAe,IAA6B;CACpF,OAAO,CAAC,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC;AAChC;AAaA,SAAgB,UAAU,GAAG,MAAmC;CAC9D,OAAO,MAAM,yBAAyB,IAAI;AAC5C;;;;;;;;;;;;;ACTA,SAAgB,OAAU,OAAsC;CAC9D,IAAI,MAAM,SAAS,GACjB,MAAM,IAAI,WAAW,8DAA8D;CAErF,OAAO,MAAM;AACf;;;;;;;;;;;ACPA,SAAgB,KAAW,MAAsB;CAC/C,OAAO,CAAC,KAAK,IAAI,KAAK,EAAE;AAC1B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-fns/stdlib",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "author": "Harris Miller <harrismillerconsulting@gmail.com>",
   "packageManager": "pnpm@10.29.3",
@@ -34,7 +34,7 @@
     "local-ci": "run-s typecheck lint test test-d",
     "test": "vitest --passWithNoTests",
     "test-d": "vitest --typecheck.only --typecheck.ignoreSourceErrors",
-    "typecheck": "tsgo --noEmit"
+    "typecheck": "tsc --noEmit"
   },
   "exports": {
     "array": {
@@ -162,16 +162,15 @@
     "type-fest": "^5.7.0"
   },
   "devDependencies": {
-    "@types/node": "^22.19.19",
-    "@typescript/native-preview": "7.0.0-dev.20260527.2",
+    "@types/node": "^22.19.21",
     "eslint": "^9.39.4",
     "eslint-config-harris": "5.1.2",
     "npm-run-all2": "^9.0.1",
     "rimraf": "^6.1.3",
-    "tsdown": "^0.22.1",
+    "tsdown": "^0.22.2",
     "typedoc": "^0.28.19",
     "typescript": "^6.0.3",
     "vitepress": "2.0.0-alpha.17",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.8"
   }
 }

package/dist/function-CB82a2GS.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"function-CB82a2GS.cjs","names":["purry","purry"],"sources":["../src/function/always.ts","../src/function/internal/_compose.ts","../src/function/compose.ts","../src/function/composed.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":["export 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\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\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","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\nexport function memoizeOne<TFunc extends (this: unknown, ...args: unknown[]) => unknown>(fn: TFunc): MemoizedFn<TFunc> {\n  return memoizeOneImplementation(fn, areInputsEqual);\n}\n\nmemoizeOne.with = memoizeOneImplementation;\n","/**\n * No operation function.\n *\n * @param args - The arguments to pass to the function.\n *\n * @example\n * ```ts\n * noop(); // 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// 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\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","export 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\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\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":";;AAAA,SAAgB,OAAU,OAAqC;CAC7D,aAAa;AACf;;;ACFA,SAAgB,sBAAsB,OAAgB,GAAG,UAAqD;CAC5G,MAAM,MAAM,SAAS;CACrB,IAAI,SAAkB;CACtB,KAAK,IAAI,IAAI,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG;EACpC,SAAS,SAAS,GAAI,MAAM;EAC5B,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO;CAEX;CACA,OAAO;AACT;;;AC2DA,SAAgB,QAAQ,OAAgB,GAAG,UAAqD;CAE9F,OAAO,sBAAsB,OAAO,GAAG,QAAQ;AACjD;;;ACVA,SAAgB,SAAS,GAAG,UAA6E;CAEvG,QAAQ,UAAmB,sBAAsB,OAAO,GAAG,QAAQ;AACrE;;;ACjEA,SAAS,YAAY,OAAgB,QAA0B;CAC7D,IAAI,UAAU,QACZ,OAAO;CAET,IAAI,OAAO,MAAM,KAAK,KAAK,OAAO,MAAM,MAAM,GAC5C,OAAO;CAGT,OAAO;AACT;AAEA,SAAS,eAAe,WAA+B,YAAyC;CAC9F,IAAI,UAAU,WAAW,WAAW,QAClC,OAAO;CAGT,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,GACzC,IAAI,CAAC,YAAY,UAAU,IAAI,WAAW,EAAE,GAC1C,OAAO;CAGX,OAAO;AACT;AAkBA,SAAgB,yBACd,IACA,mBACmB;CACnB,IAAI,QAA6B;CAEjC,SAAS,SAAyC,GAAG,SAA+C;EAClG,IAAI,OAAO,aAAa,QAAQ,kBAAkB,SAAS,MAAM,QAAQ,GACvE,OAAO,MAAM;EAGf,MAAM,aAAa,GAAG,MAAM,MAAM,OAAO;EACzC,QAAQ;GACN,UAAU;GACV;GACA,UAAU;EACZ;EAEA,OAAO;CACT;CAEA,SAAS,cAAc;EACrB,QAAQ;CACV;CAEA,OAAO;AACT;AAEA,SAAgB,WAAyE,IAA8B;CACrH,OAAO,yBAAyB,IAAI,cAAc;AACpD;AAEA,WAAW,OAAO;;;;;;;;;;;;;AC7DlB,SAAgB,KAAK,GAAG,MAAuB,CAE/C;;;ACbA,SAAgB,mBAAmB,OAAgB,GAAG,UAAqD;CACzG,MAAM,MAAM,SAAS;CACrB,IAAI,SAAkB;CACtB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,GAAG;EAC/B,SAAS,SAAS,GAAI,MAAM;EAC5B,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO;CAEX;CACA,OAAO;AACT;;;AC4DA,SAAgB,KAAK,OAAgB,GAAG,UAAqD;CAE3F,OAAO,mBAAmB,OAAO,GAAG,QAAQ;AAC9C;;;ACXA,SAAgB,MAAM,GAAG,UAA6E;CACpG,QAAQ,UAA4B,mBAAmB,OAAO,GAAG,QAAQ;AAC3E;;;AChEA,SAAgB,IAAO,YAA+C;CACpE,QAAQ,SAAY;EAClB,WAAW,IAAI;EACf,OAAO;CACT;AACF;;;ACHA,SAAS,qBAAwB,MAAS,WAAiC,IAAuB;CAChG,OAAO,UAAU,IAAI,IAAI,OAAO,GAAG,IAAI;AACzC;AAMA,SAAgB,OAAO,GAAG,MAA0B;CAClD,OAAOA,cAAAA,MAAM,sBAAsB,IAAI;AACzC;;;ACVA,SAAS,mBAAsB,MAAS,WAAiC,IAAuB;CAC9F,OAAO,UAAU,IAAI,IAAI,GAAG,IAAI,IAAI;AACtC;AAMA,SAAgB,KAAK,GAAG,MAA0B;CAChD,OAAOC,cAAAA,MAAM,oBAAoB,IAAI;AACvC"}

package/dist/function-DnI2v0p3.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"function-DnI2v0p3.mjs","names":[],"sources":["../src/function/always.ts","../src/function/internal/_compose.ts","../src/function/compose.ts","../src/function/composed.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":["export 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\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\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","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\nexport function memoizeOne<TFunc extends (this: unknown, ...args: unknown[]) => unknown>(fn: TFunc): MemoizedFn<TFunc> {\n  return memoizeOneImplementation(fn, areInputsEqual);\n}\n\nmemoizeOne.with = memoizeOneImplementation;\n","/**\n * No operation function.\n *\n * @param args - The arguments to pass to the function.\n *\n * @example\n * ```ts\n * noop(); // 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// 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\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","export 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\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\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":";;AAAA,SAAgB,OAAU,OAAqC;CAC7D,aAAa;AACf;;;ACFA,SAAgB,sBAAsB,OAAgB,GAAG,UAAqD;CAC5G,MAAM,MAAM,SAAS;CACrB,IAAI,SAAkB;CACtB,KAAK,IAAI,IAAI,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG;EACpC,SAAS,SAAS,GAAI,MAAM;EAC5B,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO;CAEX;CACA,OAAO;AACT;;;AC2DA,SAAgB,QAAQ,OAAgB,GAAG,UAAqD;CAE9F,OAAO,sBAAsB,OAAO,GAAG,QAAQ;AACjD;;;ACVA,SAAgB,SAAS,GAAG,UAA6E;CAEvG,QAAQ,UAAmB,sBAAsB,OAAO,GAAG,QAAQ;AACrE;;;ACjEA,SAAS,YAAY,OAAgB,QAA0B;CAC7D,IAAI,UAAU,QACZ,OAAO;CAET,IAAI,OAAO,MAAM,KAAK,KAAK,OAAO,MAAM,MAAM,GAC5C,OAAO;CAGT,OAAO;AACT;AAEA,SAAS,eAAe,WAA+B,YAAyC;CAC9F,IAAI,UAAU,WAAW,WAAW,QAClC,OAAO;CAGT,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,GACzC,IAAI,CAAC,YAAY,UAAU,IAAI,WAAW,EAAE,GAC1C,OAAO;CAGX,OAAO;AACT;AAkBA,SAAgB,yBACd,IACA,mBACmB;CACnB,IAAI,QAA6B;CAEjC,SAAS,SAAyC,GAAG,SAA+C;EAClG,IAAI,OAAO,aAAa,QAAQ,kBAAkB,SAAS,MAAM,QAAQ,GACvE,OAAO,MAAM;EAGf,MAAM,aAAa,GAAG,MAAM,MAAM,OAAO;EACzC,QAAQ;GACN,UAAU;GACV;GACA,UAAU;EACZ;EAEA,OAAO;CACT;CAEA,SAAS,cAAc;EACrB,QAAQ;CACV;CAEA,OAAO;AACT;AAEA,SAAgB,WAAyE,IAA8B;CACrH,OAAO,yBAAyB,IAAI,cAAc;AACpD;AAEA,WAAW,OAAO;;;;;;;;;;;;;AC7DlB,SAAgB,KAAK,GAAG,MAAuB,CAE/C;;;ACbA,SAAgB,mBAAmB,OAAgB,GAAG,UAAqD;CACzG,MAAM,MAAM,SAAS;CACrB,IAAI,SAAkB;CACtB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,GAAG;EAC/B,SAAS,SAAS,GAAI,MAAM;EAC5B,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO;CAEX;CACA,OAAO;AACT;;;AC4DA,SAAgB,KAAK,OAAgB,GAAG,UAAqD;CAE3F,OAAO,mBAAmB,OAAO,GAAG,QAAQ;AAC9C;;;ACXA,SAAgB,MAAM,GAAG,UAA6E;CACpG,QAAQ,UAA4B,mBAAmB,OAAO,GAAG,QAAQ;AAC3E;;;AChEA,SAAgB,IAAO,YAA+C;CACpE,QAAQ,SAAY;EAClB,WAAW,IAAI;EACf,OAAO;CACT;AACF;;;ACHA,SAAS,qBAAwB,MAAS,WAAiC,IAAuB;CAChG,OAAO,UAAU,IAAI,IAAI,OAAO,GAAG,IAAI;AACzC;AAMA,SAAgB,OAAO,GAAG,MAA0B;CAClD,OAAO,MAAM,sBAAsB,IAAI;AACzC;;;ACVA,SAAS,mBAAsB,MAAS,WAAiC,IAAuB;CAC9F,OAAO,UAAU,IAAI,IAAI,GAAG,IAAI,IAAI;AACtC;AAMA,SAAgB,KAAK,GAAG,MAA0B;CAChD,OAAO,MAAM,oBAAoB,IAAI;AACvC"}

package/dist/get-CWL_cu6G.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-CWL_cu6G.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 * Get a property from an object by key.\n *\n * @category Object\n * @param key - The key to get the property from.\n * @param obj - The object to get the property from.\n *\n * @example\n * ```ts\n * get('name', { name: 'John' }); // 'John'\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\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\nexport function getAssert<Obj extends object, Key extends keyof Obj>(key: Key): (obj: Obj) => NonNullable<Obj[Key]>;\nexport function getAssert<Obj extends object, Key extends keyof Obj>(obj: Obj, key: Key): NonNullable<Obj[Key]>;\nexport function getAssert(...args: unknown[]): unknown {\n  return purry(getAssertImplementation, args);\n}\n\nget.assert = getAssert;\n"],"mappings":";;;AAGA,SAAS,kBACP,KACA,KACuC;CACvC,OAAO,IAAI,QAAQ,IAAI,cAAc,yBAAyB,OAAO,GAAG,EAAE,qBAAqB;AACjG;AAqBA,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;AAEA,IAAI,KAAK;AAET,SAAS,wBAAmE,KAAU,KAAoB;CACxG,OAAO,IAAI;AACb;AAIA,SAAgB,UAAU,GAAG,MAA0B;CACrD,OAAO,MAAM,yBAAyB,IAAI;AAC5C;AAEA,IAAI,SAAS"}

package/dist/get-yrs1Kqho.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-yrs1Kqho.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 * Get a property from an object by key.\n *\n * @category Object\n * @param key - The key to get the property from.\n * @param obj - The object to get the property from.\n *\n * @example\n * ```ts\n * get('name', { name: 'John' }); // 'John'\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\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\nexport function getAssert<Obj extends object, Key extends keyof Obj>(key: Key): (obj: Obj) => NonNullable<Obj[Key]>;\nexport function getAssert<Obj extends object, Key extends keyof Obj>(obj: Obj, key: Key): NonNullable<Obj[Key]>;\nexport function getAssert(...args: unknown[]): unknown {\n  return purry(getAssertImplementation, args);\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;AAqBA,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;AAEA,IAAI,KAAK;AAET,SAAS,wBAAmE,KAAU,KAAoB;CACxG,OAAO,IAAI;AACb;AAIA,SAAgB,UAAU,GAAG,MAA0B;CACrD,OAAOA,cAAAA,MAAM,yBAAyB,IAAI;AAC5C;AAEA,IAAI,SAAS"}

package/dist/index-BJlKyBJH.d.cts

@@ -1,18 +0,0 @@
-import { i as Order } from "./order.constants-BWSCg3C7.cjs";
-
-//#region src/order/breakTie.d.ts
-declare function breakTieImplementation(order: Order, other: Order): Order;
-declare function breakTie(other: Order): (order: Order) => Order;
-declare function breakTie(order: Order, other: Order): Order;
-//#endregion
-//#region src/order/compare.d.ts
-declare function compare(left: Order, right: Order): Order;
-//#endregion
-//#region src/order/negate.d.ts
-declare function negate(order: Order): Order;
-//#endregion
-//#region src/order/reverse.d.ts
-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-BJlKyBJH.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BJlKyBJH.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;AAAA,iBAKpD,QAAA,CAAS,KAAA,EAAO,KAAA,IAAS,KAAA,EAAO,KAAA,KAAU,KAAA;AAAA,iBAC1C,QAAA,CAAS,KAAA,EAAO,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;;iBCAtC,OAAA,CAAQ,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;;iBCLpC,MAAA,CAAO,KAAA,EAAO,KAAA,GAAQ,KAAK;;;iBCF3B,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-DGrnGMDt.d.mts

@@ -1,18 +0,0 @@
-import { i as Order } from "./order.constants-BWSCg3C7.mjs";
-
-//#region src/order/breakTie.d.ts
-declare function breakTieImplementation(order: Order, other: Order): Order;
-declare function breakTie(other: Order): (order: Order) => Order;
-declare function breakTie(order: Order, other: Order): Order;
-//#endregion
-//#region src/order/compare.d.ts
-declare function compare(left: Order, right: Order): Order;
-//#endregion
-//#region src/order/negate.d.ts
-declare function negate(order: Order): Order;
-//#endregion
-//#region src/order/reverse.d.ts
-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-DGrnGMDt.d.mts.map

package/dist/index-DGrnGMDt.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DGrnGMDt.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;AAAA,iBAKpD,QAAA,CAAS,KAAA,EAAO,KAAA,IAAS,KAAA,EAAO,KAAA,KAAU,KAAA;AAAA,iBAC1C,QAAA,CAAS,KAAA,EAAO,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;;iBCAtC,OAAA,CAAQ,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,KAAA,GAAQ,KAAA;;;iBCLpC,MAAA,CAAO,KAAA,EAAO,KAAA,GAAQ,KAAK;;;iBCF3B,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/isNotNil-DrF-ohem.cjs

@@ -1,28 +0,0 @@
-//#region src/guard/isNotNil.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`.
-*
-* @example
-* ```ts
-* isNotNil(0); // true
-* isNotNil(null); // false
-* isNotNil(undefined); // false
-* ```
-*/
-function isNotNil(value) {
-	return value != null;
-}
-//#endregion
-Object.defineProperty(exports, "isNotNil", {
-	enumerable: true,
-	get: function() {
-		return isNotNil;
-	}
-});
-
-//# sourceMappingURL=isNotNil-DrF-ohem.cjs.map

package/dist/isNotNil-DrF-ohem.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isNotNil-DrF-ohem.cjs","names":[],"sources":["../src/guard/isNotNil.ts"],"sourcesContent":["/**\n * Check whether a value is not nullish (`null` nor `undefined`), using loose inequality (`!= null`).\n * Narrows the type to {@link NonNullable}.\n *\n * @category Guard\n * @param value - The value to check.\n * @returns `true` if `value` is neither `null` nor `undefined`; otherwise `false`.\n *\n * @example\n * ```ts\n * isNotNil(0); // true\n * isNotNil(null); // false\n * isNotNil(undefined); // false\n * ```\n */\nexport function isNotNil<T>(value: T): value is NonNullable<T> {\n  return value != null;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,SAAgB,SAAY,OAAmC;CAC7D,OAAO,SAAS;AAClB"}

package/dist/isNotNil-R5f1hC53.mjs

@@ -1,23 +0,0 @@
-//#region src/guard/isNotNil.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`.
-*
-* @example
-* ```ts
-* isNotNil(0); // true
-* isNotNil(null); // false
-* isNotNil(undefined); // false
-* ```
-*/
-function isNotNil(value) {
-	return value != null;
-}
-//#endregion
-export { isNotNil as t };
-
-//# sourceMappingURL=isNotNil-R5f1hC53.mjs.map

package/dist/isNotNil-R5f1hC53.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isNotNil-R5f1hC53.mjs","names":[],"sources":["../src/guard/isNotNil.ts"],"sourcesContent":["/**\n * Check whether a value is not nullish (`null` nor `undefined`), using loose inequality (`!= null`).\n * Narrows the type to {@link NonNullable}.\n *\n * @category Guard\n * @param value - The value to check.\n * @returns `true` if `value` is neither `null` nor `undefined`; otherwise `false`.\n *\n * @example\n * ```ts\n * isNotNil(0); // true\n * isNotNil(null); // false\n * isNotNil(undefined); // false\n * ```\n */\nexport function isNotNil<T>(value: T): value is NonNullable<T> {\n  return value != null;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,SAAgB,SAAY,OAAmC;CAC7D,OAAO,SAAS;AAClB"}

package/dist/orThrow-V91Jw2lF.mjs

@@ -1,15 +0,0 @@
-//#region src/function/orThrow.ts
-function orThrow(fn) {
-	const argLength = fn.length;
-	const wrappedFn = (...args) => {
-		const result = fn(...args);
-		if (result instanceof Error) throw result;
-		return result;
-	};
-	Object.defineProperty(wrappedFn, "length", { value: argLength });
-	return wrappedFn;
-}
-//#endregion
-export { orThrow as t };
-
-//# sourceMappingURL=orThrow-V91Jw2lF.mjs.map

package/dist/orThrow-V91Jw2lF.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"orThrow-V91Jw2lF.mjs","names":[],"sources":["../src/function/orThrow.ts"],"sourcesContent":["export 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"],"mappings":";AAAA,SAAgB,QAAQ,IAAoF;CAC1G,MAAM,YAAY,GAAG;CAErB,MAAM,aAAa,GAAG,SAAsC;EAC1D,MAAM,SAAS,GAAG,GAAG,IAAI;EACzB,IAAI,kBAAkB,OACpB,MAAM;EAER,OAAO;CACT;CAEA,OAAO,eAAe,WAAW,UAAU,EACzC,OAAO,UACT,CAAC;CAED,OAAO;AACT"}

package/dist/orThrow-ejzcQYAI.cjs

@@ -1,20 +0,0 @@
-//#region src/function/orThrow.ts
-function orThrow(fn) {
-	const argLength = fn.length;
-	const wrappedFn = (...args) => {
-		const result = fn(...args);
-		if (result instanceof Error) throw result;
-		return result;
-	};
-	Object.defineProperty(wrappedFn, "length", { value: argLength });
-	return wrappedFn;
-}
-//#endregion
-Object.defineProperty(exports, "orThrow", {
-	enumerable: true,
-	get: function() {
-		return orThrow;
-	}
-});
-
-//# sourceMappingURL=orThrow-ejzcQYAI.cjs.map

package/dist/orThrow-ejzcQYAI.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"orThrow-ejzcQYAI.cjs","names":[],"sources":["../src/function/orThrow.ts"],"sourcesContent":["export 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"],"mappings":";AAAA,SAAgB,QAAQ,IAAoF;CAC1G,MAAM,YAAY,GAAG;CAErB,MAAM,aAAa,GAAG,SAAsC;EAC1D,MAAM,SAAS,GAAG,GAAG,IAAI;EACzB,IAAI,kBAAkB,OACpB,MAAM;EAER,OAAO;CACT;CAEA,OAAO,eAAe,WAAW,UAAU,EACzC,OAAO,UACT,CAAC;CAED,OAAO;AACT"}

package/dist/order.constants-BWSCg3C7.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"order.constants-BWSCg3C7.d.cts","names":[],"sources":["../src/order/order.constants.ts"],"mappings":";KAAY,EAAA;AAAA,KACA,EAAA;AAAA,KACA,EAAA;AAAA,KAEA,KAAA,GAAQ,EAAA,GAAK,EAAA,GAAK,EAAA;AAAA,cAEjB,EAAA,EAAI,EAAO;AAAA,cACX,EAAA,EAAI,EAAM;AAAA,cACV,EAAA,EAAI,EAAM"}

package/dist/order.constants-BWSCg3C7.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"order.constants-BWSCg3C7.d.mts","names":[],"sources":["../src/order/order.constants.ts"],"mappings":";KAAY,EAAA;AAAA,KACA,EAAA;AAAA,KACA,EAAA;AAAA,KAEA,KAAA,GAAQ,EAAA,GAAK,EAAA,GAAK,EAAA;AAAA,cAEjB,EAAA,EAAI,EAAO;AAAA,cACX,EAAA,EAAI,EAAM;AAAA,cACV,EAAA,EAAI,EAAM"}

package/dist/purry-B2_0DGLV.cjs

@@ -1,28 +0,0 @@
-//#region src/function/purry.ts
-/**
-* Purry = **P**ipe + C**urry*
-*
-* Named as such to simulate how Elixir's pipe operator expects you to omit the first argument, the "data argument".
-* This function essentially takes any function of at lest 2 arguments and returns a function that:
-* * If it receives `n` args, it calls the function immediately
-* * If it receives `n - 1` args, it returns a function accepting the single data argument
-* * Any calls with incorrect number of arguments will throw
-*
-* Credit to Remeda for the name
-* @throws {Error}
-*/
-function purry(fn, args) {
-	const diff = fn.length - args.length;
-	if (diff === 0) return fn(...args);
-	if (diff === 1) return (data) => fn(data, ...args);
-	throw new Error(`Attempt to call Purried function "${fn.name}" failed with wrong number of arguments. Received "${args.length}". It can accept either "${fn.length}" or "${fn.length - 1}" arguments.`);
-}
-//#endregion
-Object.defineProperty(exports, "purry", {
-	enumerable: true,
-	get: function() {
-		return purry;
-	}
-});
-
-//# sourceMappingURL=purry-B2_0DGLV.cjs.map

package/dist/purry-B2_0DGLV.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"purry-B2_0DGLV.cjs","names":[],"sources":["../src/function/purry.ts"],"sourcesContent":["/**\n * Purry = **P**ipe + C**urry*\n *\n * Named as such to simulate how Elixir's pipe operator expects you to omit the first argument, the \"data argument\".\n * This function essentially takes any function of at lest 2 arguments and returns a function that:\n * * If it receives `n` args, it calls the function immediately\n * * If it receives `n - 1` args, it returns a function accepting the single data argument\n * * Any calls with incorrect number of arguments will throw\n *\n * Credit to Remeda for the name\n * @throws {Error}\n */\nexport function purry(fn: (...args: any) => unknown, args: readonly unknown[]): unknown {\n  const diff = fn.length - args.length;\n  if (diff === 0) {\n    return fn(...args);\n  }\n\n  if (diff === 1) {\n    return (data: unknown): unknown => fn(data, ...args);\n  }\n\n  throw new Error(\n    `Attempt to call Purried function \"${fn.name}\" failed with wrong number of arguments. Received \"${args.length}\". It can accept either \"${fn.length}\" or \"${fn.length - 1}\" arguments.`,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAgB,MAAM,IAA+B,MAAmC;CACtF,MAAM,OAAO,GAAG,SAAS,KAAK;CAC9B,IAAI,SAAS,GACX,OAAO,GAAG,GAAG,IAAI;CAGnB,IAAI,SAAS,GACX,QAAQ,SAA2B,GAAG,MAAM,GAAG,IAAI;CAGrD,MAAM,IAAI,MACR,qCAAqC,GAAG,KAAK,qDAAqD,KAAK,OAAO,2BAA2B,GAAG,OAAO,QAAQ,GAAG,SAAS,EAAE,aAC3K;AACF"}

package/dist/purry-BOWmqwDB.mjs

@@ -1,23 +0,0 @@
-//#region src/function/purry.ts
-/**
-* Purry = **P**ipe + C**urry*
-*
-* Named as such to simulate how Elixir's pipe operator expects you to omit the first argument, the "data argument".
-* This function essentially takes any function of at lest 2 arguments and returns a function that:
-* * If it receives `n` args, it calls the function immediately
-* * If it receives `n - 1` args, it returns a function accepting the single data argument
-* * Any calls with incorrect number of arguments will throw
-*
-* Credit to Remeda for the name
-* @throws {Error}
-*/
-function purry(fn, args) {
-	const diff = fn.length - args.length;
-	if (diff === 0) return fn(...args);
-	if (diff === 1) return (data) => fn(data, ...args);
-	throw new Error(`Attempt to call Purried function "${fn.name}" failed with wrong number of arguments. Received "${args.length}". It can accept either "${fn.length}" or "${fn.length - 1}" arguments.`);
-}
-//#endregion
-export { purry as t };
-
-//# sourceMappingURL=purry-BOWmqwDB.mjs.map

package/dist/purry-BOWmqwDB.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"purry-BOWmqwDB.mjs","names":[],"sources":["../src/function/purry.ts"],"sourcesContent":["/**\n * Purry = **P**ipe + C**urry*\n *\n * Named as such to simulate how Elixir's pipe operator expects you to omit the first argument, the \"data argument\".\n * This function essentially takes any function of at lest 2 arguments and returns a function that:\n * * If it receives `n` args, it calls the function immediately\n * * If it receives `n - 1` args, it returns a function accepting the single data argument\n * * Any calls with incorrect number of arguments will throw\n *\n * Credit to Remeda for the name\n * @throws {Error}\n */\nexport function purry(fn: (...args: any) => unknown, args: readonly unknown[]): unknown {\n  const diff = fn.length - args.length;\n  if (diff === 0) {\n    return fn(...args);\n  }\n\n  if (diff === 1) {\n    return (data: unknown): unknown => fn(data, ...args);\n  }\n\n  throw new Error(\n    `Attempt to call Purried function \"${fn.name}\" failed with wrong number of arguments. Received \"${args.length}\". It can accept either \"${fn.length}\" or \"${fn.length - 1}\" arguments.`,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAgB,MAAM,IAA+B,MAAmC;CACtF,MAAM,OAAO,GAAG,SAAS,KAAK;CAC9B,IAAI,SAAS,GACX,OAAO,GAAG,GAAG,IAAI;CAGnB,IAAI,SAAS,GACX,QAAQ,SAA2B,GAAG,MAAM,GAAG,IAAI;CAGrD,MAAM,IAAI,MACR,qCAAqC,GAAG,KAAK,qDAAqD,KAAK,OAAO,2BAA2B,GAAG,OAAO,QAAQ,GAAG,SAAS,EAAE,aAC3K;AACF"}