@vinicunca/perkakas 1.13.2 → 1.15.0

package/dist/product.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"product.cjs","names":["curry"],"sources":["../src/product.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Product<T extends IterableContainer<bigint> | IterableContainer<number>>\n  // Empty arrays would always result in a product of (a non-bigint) 1\n  = T extends readonly []\n    ? 1\n    : // Non-empty bigint arrays will always result in a bigint product.\n    T extends readonly [bigint, ...(ReadonlyArray<unknown>)]\n      ? bigint\n      : // But an empty bigint array would result in a non-bigint 1.\n      T[number] extends bigint\n        ? bigint | 1\n        : // Non-bigint arrays are always handled correctly.\n        number;\n\n/**\n * Compute the product of the numbers in the array, or return 1 for an empty\n * array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 1 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   product(data);\n * @example\n *   product([1, 2, 3]); // => 6\n *   product([1n, 2n, 3n]); // => 6n\n *   product([]); // => 1\n * @dataFirst\n * @category Number\n */\nexport function product<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): Product<T>;\n\n/**\n * Compute the product of the numbers in the array, or return 1 for an empty\n * array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 1 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @signature\n *   product()(data);\n * @example\n *   pipe([1, 2, 3], product()); // => 6\n *   pipe([1n, 2n, 3n], product()); // => 6n\n *   pipe([], product()); // => 1\n * @dataLast\n * @category Number\n */\nexport function product(): <\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(\n  data: T,\n) => Product<T>;\n\nexport function product(...args: ReadonlyArray<unknown>): unknown {\n  return curry(productImplementation, args);\n}\n\nfunction productImplementation<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): T[number] {\n  let out = typeof data[0] === 'bigint' ? 1n : 1;\n  for (const value of data) {\n    // @ts-expect-error [ts2365] -- Typescript can't infer that all elements will be a number of the same type.\n    out *= value;\n  }\n  return out;\n}\n"],"mappings":"kGAqEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EAEP,EAAoB,CACpB,IAAI,EAAM,OAAO,EAAK,IAAO,SAAW,GAAK,EAC7C,IAAK,IAAM,KAAS,EAElB,GAAO,EAET,OAAO"}

package/dist/product.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){let t=typeof e[0]==`bigint`?1n:1;for(let n of e)t*=n;return t}export{t as product};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){let t=typeof e[0]==`bigint`?1n:1;for(let n of e)t*=n;return t}export{t as product};
 //# sourceMappingURL=product.js.map

package/dist/product.js.map

@@ -1 +1 @@
-{"version":3,"file":"product.js","names":[],"sources":["../src/product.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\n\nimport { curry } from './curry';\n\ntype Product<T extends IterableContainer<bigint> | IterableContainer<number>>\n  // Empty arrays would always result in a product of (a non-bigint) 1\n  = T extends readonly []\n    ? 1\n    // Non-empty bigint arrays will always result in a bigint product.\n    : T extends readonly [bigint, ...ReadonlyArray<unknown>]\n      ? bigint\n      // But an empty bigint array would result in a non-bigint 1.\n      : T[number] extends bigint\n        ? 1 | bigint\n        // Non-bigint arrays are always handled correctly.\n        : number;\n\n/**\n * Compute the product of the numbers in the array, or return 1 for an empty\n * array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 1 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   P.product(data);\n * @example\n *   P.product([1, 2, 3]); // => 6\n *   P.product([1n, 2n, 3n]); // => 6n\n *   P.product([]); // => 1\n * @dataFirst\n * @category Number\n */\nexport function product<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): Product<T>;\n\n/**\n * Compute the product of the numbers in the array, or return 1 for an empty\n * array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 1 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @signature\n *   P.product()(data);\n * @example\n *   P.pipe([1, 2, 3], P.product()); // => 6\n *   P.pipe([1n, 2n, 3n], P.product()); // => 6n\n *   P.pipe([], P.product()); // => 1\n * @dataLast\n * @category Number\n */\nexport function product(): <\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(\n  data: T,\n) => Product<T>;\n\nexport function product(...args: ReadonlyArray<unknown>): unknown {\n  return curry(productImplementation, args);\n}\n\nfunction productImplementation<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): T[number] {\n  let out = typeof data[0] === 'bigint' ? 1n : 1;\n  for (const value of data) {\n    // @ts-expect-error [ts2365] -- Typescript can't infer that all elements will be a number of the same type.\n    out *= value;\n  }\n  return out;\n}\n"],"mappings":"wCAsEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAEP,EAAoB,CACpB,IAAI,EAAM,OAAO,EAAK,IAAO,SAAW,GAAK,EAC7C,IAAK,IAAM,KAAS,EAElB,GAAO,EAET,OAAO"}
+{"version":3,"file":"product.js","names":[],"sources":["../src/product.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Product<T extends IterableContainer<bigint> | IterableContainer<number>>\n  // Empty arrays would always result in a product of (a non-bigint) 1\n  = T extends readonly []\n    ? 1\n    : // Non-empty bigint arrays will always result in a bigint product.\n    T extends readonly [bigint, ...(ReadonlyArray<unknown>)]\n      ? bigint\n      : // But an empty bigint array would result in a non-bigint 1.\n      T[number] extends bigint\n        ? bigint | 1\n        : // Non-bigint arrays are always handled correctly.\n        number;\n\n/**\n * Compute the product of the numbers in the array, or return 1 for an empty\n * array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 1 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   product(data);\n * @example\n *   product([1, 2, 3]); // => 6\n *   product([1n, 2n, 3n]); // => 6n\n *   product([]); // => 1\n * @dataFirst\n * @category Number\n */\nexport function product<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): Product<T>;\n\n/**\n * Compute the product of the numbers in the array, or return 1 for an empty\n * array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 1 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @signature\n *   product()(data);\n * @example\n *   pipe([1, 2, 3], product()); // => 6\n *   pipe([1n, 2n, 3n], product()); // => 6n\n *   pipe([], product()); // => 1\n * @dataLast\n * @category Number\n */\nexport function product(): <\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(\n  data: T,\n) => Product<T>;\n\nexport function product(...args: ReadonlyArray<unknown>): unknown {\n  return curry(productImplementation, args);\n}\n\nfunction productImplementation<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): T[number] {\n  let out = typeof data[0] === 'bigint' ? 1n : 1;\n  for (const value of data) {\n    // @ts-expect-error [ts2365] -- Typescript can't infer that all elements will be a number of the same type.\n    out *= value;\n  }\n  return out;\n}\n"],"mappings":"mCAqEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAEP,EAAoB,CACpB,IAAI,EAAM,OAAO,EAAK,IAAO,SAAW,GAAK,EAC7C,IAAK,IAAM,KAAS,EAElB,GAAO,EAET,OAAO"}

package/dist/prop.cjs

@@ -1 +1,2 @@
-function e(e,...n){return typeof e==`string`||typeof e==`number`||typeof e==`symbol`?r=>t(r,e,...n):t(e,...n)}function t(e,...t){let n=e;for(let e of t){if(n==null)return;n=n[e]}return n}exports.prop=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,...n){return typeof e==`string`||typeof e==`number`||typeof e==`symbol`?r=>t(r,e,...n):t(e,...n)}function t(e,...t){let n=e;for(let e of t){if(n==null)return;n=n[e]}return n}exports.prop=e;
+//# sourceMappingURL=prop.cjs.map

package/dist/prop.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop.cjs","names":[],"sources":["../src/prop.ts"],"sourcesContent":["import type { KeysOfUnion } from 'type-fest';\nimport type { ArrayAt } from './internal/types/array-at';\n\n// Computes all possible keys of `T` at `Path` spread over unions, allowing\n// keys from any of the results, not just those **shared** by all of them.\ntype KeysDeep<T, Path extends ReadonlyArray<unknown>> = KeysOfUnion<\n  PropDeep<T, Path>\n>;\n\n// Recursively run `Prop` over `Path` to extract the deeply nested type.\ntype PropDeep<T, Path extends ReadonlyArray<unknown>> = Path extends readonly [\n  infer Key,\n  ...infer Rest,\n]\n  ? PropDeep<Prop<T, Key>, Rest>\n  : // Keys is a fixed tuple so we know we reach here only when we've reached\n// the output object.\n  T;\n\n// Expanding on the built-in `T[Key]` operator to support arrays and unions.\ntype Prop<T, Key>\n  // Distribute the union to support unions of keys.\n  = T extends unknown\n    ? // In a distributed union some of the union members might not be keys of a\n  // specific object within a union of objects, those cases don't contribute\n  // to the output type.\n    Key extends keyof T\n      ? T extends ReadonlyArray<unknown>\n        ? ArrayAt<T, Key>\n        : T[Key]\n      : undefined\n    : never;\n\n// Currying relies on us being able to differentiate between data-first and\n// data-last invocations at runtime, but because the function takes a variadic\n// array of keys we can't rely on it's shape or length to do that. Instead, we\n// can limit the types we accept for `data` so that looking at the first\n// parameter's type is enough to make the call. From a practical standpoint\n// this means we accept in any `object`, `null,` or `undefined`, and that we\n// don't accept `string`. All other types (`boolean` and `bigint`) don't\n// have properties, so are incompatible with our `key` parameters anyway.\ntype NonPropertyKey = object | null | undefined;\n\n/**\n * Gets the value of the given property from an object. Nested properties can\n * be accessed by providing a variadic array of keys that define the path from\n * the root to the desired property. Arrays can be accessed by using numeric\n * keys. Unions and optional properties are handled gracefully by returning\n * `undefined` early for any non-existing property on the path. Paths are\n * validated against the object type to provide stronger type safety, better\n * compile-time errors, and to enable autocompletion in IDEs.\n *\n * @param data - The object or array to access.\n * @param key - The key(s) for the property to extract.\n * @signature\n *   prop(data, ...keys);\n * @example\n *   prop({ foo: { bar: 'baz' } }, 'foo'); //=> { bar: 'baz' }\n *   prop({ foo: { bar: 'baz' } }, 'foo', 'bar'); //=> 'baz'\n *   prop([\"cat\", \"dog\"], 1); //=> 'dog'\n * @dataFirst\n * @category Object\n */\nexport function prop<T extends NonPropertyKey, Key extends KeysDeep<T, []>>(\n  data: T,\n  key: Key,\n): NoInfer<Prop<T, Key>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n>(data: T, key0: Key0, key1: Key1): NoInfer<PropDeep<T, [Key0, Key1]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n  Key9 extends KeysDeep<\n    T,\n    [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]\n  >,\n  AdditionalKeys extends ReadonlyArray<PropertyKey> = [],\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n  key9: Key9,\n  ...additionalKeys: AdditionalKeys\n): NoInfer<\n  PropDeep<\n    T,\n    [\n      Key0,\n      Key1,\n      Key2,\n      Key3,\n      Key4,\n      Key5,\n      Key6,\n      Key7,\n      Key8,\n      Key9,\n      ...AdditionalKeys,\n    ]\n  >\n>;\n\n/**\n * Gets the value of the given property from an object. Nested properties can\n * be accessed by providing a variadic array of keys that define the path from\n * the root to the desired property. Arrays can be accessed by using numeric\n * keys. Unions and optional properties are handled gracefully by returning\n * `undefined` early for any non-existing property on the path. Paths are\n * validated against the object type to provide stronger type safety, better\n * compile-time errors, and to enable autocompletion in IDEs.\n *\n * @param key - The key(s) for the property to extract.\n * @signature\n *   prop(...keys)(data);\n * @example\n *   pipe({ foo: { bar: 'baz' } }, prop('foo')); //=> { bar: 'baz' }\n *   pipe({ foo: { bar: 'baz' } }, prop('foo', 'bar')); //=> 'baz'\n *   pipe([\"cat\", \"dog\"], prop(1)); //=> 'dog'\n * @dataLast\n * @category Object\n */\nexport function prop<T extends NonPropertyKey, Key extends KeysOfUnion<T>>(\n  key: Key,\n): (data: T) => NoInfer<Prop<T, Key>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n>(key0: Key0, key1: Key1): (data: T) => NoInfer<PropDeep<T, [Key0, Key1]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n): (\n  data: T,\n) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n): (\n  data: T,\n) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n): (\n  data: T,\n) => NoInfer<\n  PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]>\n>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n  Key9 extends KeysDeep<\n    T,\n    [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]\n  >,\n  AdditionalKeys extends ReadonlyArray<PropertyKey> = [],\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n  key9: Key9,\n  ...additionalKeys: AdditionalKeys\n): (\n  data: T,\n) => NoInfer<\n  PropDeep<\n    T,\n    [\n      Key0,\n      Key1,\n      Key2,\n      Key3,\n      Key4,\n      Key5,\n      Key6,\n      Key7,\n      Key8,\n      Key9,\n      ...AdditionalKeys,\n    ]\n  >\n>;\n\nexport function prop<K extends PropertyKey>(\n  key: K,\n): <T extends Partial<Record<K, unknown>>>(data: T) => T[K];\n\nexport function prop(\n  maybeData: NonPropertyKey | PropertyKey,\n  ...args: ReadonlyArray<PropertyKey>\n): unknown {\n  return typeof maybeData === 'string'\n    || typeof maybeData === 'number'\n    || typeof maybeData === 'symbol'\n    ? (data: NonPropertyKey) => propImplementation(data, maybeData, ...args)\n    : propImplementation(maybeData, ...args);\n}\n\nfunction propImplementation(\n  data: NonPropertyKey,\n  ...keys: ReadonlyArray<PropertyKey>\n): unknown {\n  let output: unknown = data;\n  for (const key of keys) {\n    if (output === undefined || output === null) {\n      return undefined;\n    }\n    // @ts-expect-error [ts7053] -- This is fine, the types are really dynamic\n    // here and TypeScript doesn't have a chance to infer them correctly.\n    output = output[key];\n  }\n  return output;\n}\n"],"mappings":"mEAubA,SAAgB,EACd,EACA,GAAG,EACM,CACT,OAAO,OAAO,GAAc,UACvB,OAAO,GAAc,UACrB,OAAO,GAAc,SACrB,GAAyB,EAAmB,EAAM,EAAW,GAAG,EAAK,CACtE,EAAmB,EAAW,GAAG,EAAK,CAG5C,SAAS,EACP,EACA,GAAG,EACM,CACT,IAAI,EAAkB,EACtB,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,GAAmC,KACrC,OAIF,EAAS,EAAO,GAElB,OAAO"}

package/dist/prop.js.map

@@ -1 +1 @@
-{"version":3,"file":"prop.js","names":["output: unknown"],"sources":["../src/prop.ts"],"sourcesContent":["import type { KeysOfUnion } from 'type-fest';\nimport type { ArrayAt } from './internal/types/array-at';\n\n// Computes all possible keys of `T` at `Path` spread over unions, allowing\n// keys from any of the results, not just those **shared** by all of them.\ntype KeysDeep<T, Path extends ReadonlyArray<unknown>> = KeysOfUnion<\n  PropDeep<T, Path>\n>;\n\n// Recursively run `Prop` over `Path` to extract the deeply nested type.\ntype PropDeep<T, Path extends ReadonlyArray<unknown>> = Path extends readonly [\n  infer Key,\n  ...infer Rest,\n]\n  ? PropDeep<Prop<T, Key>, Rest>\n  // Keys is a fixed tuple so we know we reach here only when we've reached\n  // the output object.\n  : T;\n\n// Expanding on the built-in `T[Key]` operator to support arrays and unions.\ntype Prop<T, Key>\n  // Distribute the union to support unions of keys.\n  = T extends unknown\n    // In a distributed union some of the union members might not be keys of a\n    // specific object within a union of objects, those cases don't contribute\n    // to the output type.\n    ? Key extends keyof T\n      ? T extends ReadonlyArray<unknown>\n        ? ArrayAt<T, Key>\n        : T[Key]\n      : undefined\n    : never;\n\n// Currying relies on us being able to differentiate between data-first and\n// data-last invocations at runtime, but because the function takes a variadic\n// array of keys we can't rely on it's shape or length to do that. Instead, we\n// can limit the types we accept for `data` so that looking at the first\n// parameter's type is enough to make the call. From a practical standpoint\n// this means we accept in any `object`, `null,` or `undefined`, and that we\n// don't accept `string`. All other types (`boolean` and `bigint`) don't\n// have properties, so are incompatible with our `key` parameters anyway.\ntype NonPropertyKey = object | null | undefined;\n\n/**\n * Gets the value of the given property from an object. Nested properties can\n * be accessed by providing a variadic array of keys that define the path from\n * the root to the desired property. Arrays can be accessed by using numeric\n * keys. Unions and optional properties are handled gracefully by returning\n * `undefined` early for any non-existing property on the path. Paths are\n * validated against the object type to provide stronger type safety, better\n * compile-time errors, and to enable autocompletion in IDEs.\n *\n * @param data - The object or array to access.\n * @param key - The key(s) for the property to extract.\n * @signature\n *   P.prop(data, ...keys);\n * @example\n *   P.prop({ foo: { bar: 'baz' } }, 'foo'); //=> { bar: 'baz' }\n *   P.prop({ foo: { bar: 'baz' } }, 'foo', 'bar'); //=> 'baz'\n *   P.prop([\"cat\", \"dog\"], 1); //=> 'dog'\n * @dataFirst\n * @category Object\n */\nexport function prop<T extends NonPropertyKey, Key extends KeysDeep<T, []>>(\n  data: T,\n  key: Key,\n): NoInfer<Prop<T, Key>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n>(data: T, key0: Key0, key1: Key1): NoInfer<PropDeep<T, [Key0, Key1]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n  Key9 extends KeysDeep<\n    T,\n    [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]\n  >,\n  AdditionalKeys extends ReadonlyArray<PropertyKey> = [],\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n  key9: Key9,\n  ...additionalKeys: AdditionalKeys\n): NoInfer<\n  PropDeep<\n    T,\n    [\n      Key0,\n      Key1,\n      Key2,\n      Key3,\n      Key4,\n      Key5,\n      Key6,\n      Key7,\n      Key8,\n      Key9,\n      ...AdditionalKeys,\n    ]\n  >\n>;\n\n/**\n * Gets the value of the given property from an object. Nested properties can\n * be accessed by providing a variadic array of keys that define the path from\n * the root to the desired property. Arrays can be accessed by using numeric\n * keys. Unions and optional properties are handled gracefully by returning\n * `undefined` early for any non-existing property on the path. Paths are\n * validated against the object type to provide stronger type safety, better\n * compile-time errors, and to enable autocompletion in IDEs.\n *\n * @param key - The key(s) for the property to extract.\n * @signature\n *   P.prop(...keys)(data);\n * @example\n *   P.pipe({ foo: { bar: 'baz' } }, P.prop('foo')); //=> { bar: 'baz' }\n *   P.pipe({ foo: { bar: 'baz' } }, P.prop('foo', 'bar')); //=> 'baz'\n *   P.pipe([\"cat\", \"dog\"], P.prop(1)); //=> 'dog'\n * @dataLast\n * @category Object\n */\nexport function prop<T extends NonPropertyKey, Key extends KeysOfUnion<T>>(\n  key: Key,\n): (data: T) => NoInfer<Prop<T, Key>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n>(key0: Key0, key1: Key1): (data: T) => NoInfer<PropDeep<T, [Key0, Key1]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n): (\n  data: T,\n) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n): (\n  data: T,\n) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n): (\n  data: T,\n) => NoInfer<\n  PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]>\n>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n  Key9 extends KeysDeep<\n    T,\n    [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]\n  >,\n  AdditionalKeys extends ReadonlyArray<PropertyKey> = [],\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n  key9: Key9,\n  ...additionalKeys: AdditionalKeys\n): (\n  data: T,\n) => NoInfer<\n  PropDeep<\n    T,\n    [\n      Key0,\n      Key1,\n      Key2,\n      Key3,\n      Key4,\n      Key5,\n      Key6,\n      Key7,\n      Key8,\n      Key9,\n      ...AdditionalKeys,\n    ]\n  >\n>;\n\nexport function prop<K extends PropertyKey>(\n  key: K,\n): <T extends Partial<Record<K, unknown>>>(data: T) => T[K];\n\nexport function prop(\n  maybeData: NonPropertyKey | PropertyKey,\n  ...args: ReadonlyArray<PropertyKey>\n): unknown {\n  return typeof maybeData === 'string'\n    || typeof maybeData === 'number'\n    || typeof maybeData === 'symbol'\n    ? (data: NonPropertyKey) => propImplementation(data, maybeData, ...args)\n    : propImplementation(maybeData, ...args);\n}\n\nfunction propImplementation(\n  data: NonPropertyKey,\n  ...keys: ReadonlyArray<PropertyKey>\n): unknown {\n  let output: unknown = data;\n  for (const key of keys) {\n    if (output === undefined || output === null) {\n      return undefined;\n    }\n    // @ts-expect-error [ts7053] -- This is fine, the types are really dynamic\n    // here and TypeScript doesn't have a chance to infer them correctly.\n    output = output[key];\n  }\n  return output;\n}\n"],"mappings":"AAubA,SAAgB,EACd,EACA,GAAG,EACM,CACT,OAAO,OAAO,GAAc,UACvB,OAAO,GAAc,UACrB,OAAO,GAAc,SACrB,GAAyB,EAAmB,EAAM,EAAW,GAAG,EAAK,CACtE,EAAmB,EAAW,GAAG,EAAK,CAG5C,SAAS,EACP,EACA,GAAG,EACM,CACT,IAAIA,EAAkB,EACtB,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,GAAmC,KACrC,OAIF,EAAS,EAAO,GAElB,OAAO"}
+{"version":3,"file":"prop.js","names":[],"sources":["../src/prop.ts"],"sourcesContent":["import type { KeysOfUnion } from 'type-fest';\nimport type { ArrayAt } from './internal/types/array-at';\n\n// Computes all possible keys of `T` at `Path` spread over unions, allowing\n// keys from any of the results, not just those **shared** by all of them.\ntype KeysDeep<T, Path extends ReadonlyArray<unknown>> = KeysOfUnion<\n  PropDeep<T, Path>\n>;\n\n// Recursively run `Prop` over `Path` to extract the deeply nested type.\ntype PropDeep<T, Path extends ReadonlyArray<unknown>> = Path extends readonly [\n  infer Key,\n  ...infer Rest,\n]\n  ? PropDeep<Prop<T, Key>, Rest>\n  : // Keys is a fixed tuple so we know we reach here only when we've reached\n// the output object.\n  T;\n\n// Expanding on the built-in `T[Key]` operator to support arrays and unions.\ntype Prop<T, Key>\n  // Distribute the union to support unions of keys.\n  = T extends unknown\n    ? // In a distributed union some of the union members might not be keys of a\n  // specific object within a union of objects, those cases don't contribute\n  // to the output type.\n    Key extends keyof T\n      ? T extends ReadonlyArray<unknown>\n        ? ArrayAt<T, Key>\n        : T[Key]\n      : undefined\n    : never;\n\n// Currying relies on us being able to differentiate between data-first and\n// data-last invocations at runtime, but because the function takes a variadic\n// array of keys we can't rely on it's shape or length to do that. Instead, we\n// can limit the types we accept for `data` so that looking at the first\n// parameter's type is enough to make the call. From a practical standpoint\n// this means we accept in any `object`, `null,` or `undefined`, and that we\n// don't accept `string`. All other types (`boolean` and `bigint`) don't\n// have properties, so are incompatible with our `key` parameters anyway.\ntype NonPropertyKey = object | null | undefined;\n\n/**\n * Gets the value of the given property from an object. Nested properties can\n * be accessed by providing a variadic array of keys that define the path from\n * the root to the desired property. Arrays can be accessed by using numeric\n * keys. Unions and optional properties are handled gracefully by returning\n * `undefined` early for any non-existing property on the path. Paths are\n * validated against the object type to provide stronger type safety, better\n * compile-time errors, and to enable autocompletion in IDEs.\n *\n * @param data - The object or array to access.\n * @param key - The key(s) for the property to extract.\n * @signature\n *   prop(data, ...keys);\n * @example\n *   prop({ foo: { bar: 'baz' } }, 'foo'); //=> { bar: 'baz' }\n *   prop({ foo: { bar: 'baz' } }, 'foo', 'bar'); //=> 'baz'\n *   prop([\"cat\", \"dog\"], 1); //=> 'dog'\n * @dataFirst\n * @category Object\n */\nexport function prop<T extends NonPropertyKey, Key extends KeysDeep<T, []>>(\n  data: T,\n  key: Key,\n): NoInfer<Prop<T, Key>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n>(data: T, key0: Key0, key1: Key1): NoInfer<PropDeep<T, [Key0, Key1]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n): NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n  Key9 extends KeysDeep<\n    T,\n    [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]\n  >,\n  AdditionalKeys extends ReadonlyArray<PropertyKey> = [],\n>(\n  data: T,\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n  key9: Key9,\n  ...additionalKeys: AdditionalKeys\n): NoInfer<\n  PropDeep<\n    T,\n    [\n      Key0,\n      Key1,\n      Key2,\n      Key3,\n      Key4,\n      Key5,\n      Key6,\n      Key7,\n      Key8,\n      Key9,\n      ...AdditionalKeys,\n    ]\n  >\n>;\n\n/**\n * Gets the value of the given property from an object. Nested properties can\n * be accessed by providing a variadic array of keys that define the path from\n * the root to the desired property. Arrays can be accessed by using numeric\n * keys. Unions and optional properties are handled gracefully by returning\n * `undefined` early for any non-existing property on the path. Paths are\n * validated against the object type to provide stronger type safety, better\n * compile-time errors, and to enable autocompletion in IDEs.\n *\n * @param key - The key(s) for the property to extract.\n * @signature\n *   prop(...keys)(data);\n * @example\n *   pipe({ foo: { bar: 'baz' } }, prop('foo')); //=> { bar: 'baz' }\n *   pipe({ foo: { bar: 'baz' } }, prop('foo', 'bar')); //=> 'baz'\n *   pipe([\"cat\", \"dog\"], prop(1)); //=> 'dog'\n * @dataLast\n * @category Object\n */\nexport function prop<T extends NonPropertyKey, Key extends KeysOfUnion<T>>(\n  key: Key,\n): (data: T) => NoInfer<Prop<T, Key>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n>(key0: Key0, key1: Key1): (data: T) => NoInfer<PropDeep<T, [Key0, Key1]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n): (data: T) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n): (\n  data: T,\n) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n): (\n  data: T,\n) => NoInfer<PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n): (\n  data: T,\n) => NoInfer<\n  PropDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]>\n>;\nexport function prop<\n  T extends NonPropertyKey,\n  Key0 extends KeysDeep<T, []>,\n  Key1 extends KeysDeep<T, [Key0]>,\n  Key2 extends KeysDeep<T, [Key0, Key1]>,\n  Key3 extends KeysDeep<T, [Key0, Key1, Key2]>,\n  Key4 extends KeysDeep<T, [Key0, Key1, Key2, Key3]>,\n  Key5 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4]>,\n  Key6 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5]>,\n  Key7 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6]>,\n  Key8 extends KeysDeep<T, [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7]>,\n  Key9 extends KeysDeep<\n    T,\n    [Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8]\n  >,\n  AdditionalKeys extends ReadonlyArray<PropertyKey> = [],\n>(\n  key0: Key0,\n  key1: Key1,\n  key2: Key2,\n  key3: Key3,\n  key4: Key4,\n  key5: Key5,\n  key6: Key6,\n  key7: Key7,\n  key8: Key8,\n  key9: Key9,\n  ...additionalKeys: AdditionalKeys\n): (\n  data: T,\n) => NoInfer<\n  PropDeep<\n    T,\n    [\n      Key0,\n      Key1,\n      Key2,\n      Key3,\n      Key4,\n      Key5,\n      Key6,\n      Key7,\n      Key8,\n      Key9,\n      ...AdditionalKeys,\n    ]\n  >\n>;\n\nexport function prop<K extends PropertyKey>(\n  key: K,\n): <T extends Partial<Record<K, unknown>>>(data: T) => T[K];\n\nexport function prop(\n  maybeData: NonPropertyKey | PropertyKey,\n  ...args: ReadonlyArray<PropertyKey>\n): unknown {\n  return typeof maybeData === 'string'\n    || typeof maybeData === 'number'\n    || typeof maybeData === 'symbol'\n    ? (data: NonPropertyKey) => propImplementation(data, maybeData, ...args)\n    : propImplementation(maybeData, ...args);\n}\n\nfunction propImplementation(\n  data: NonPropertyKey,\n  ...keys: ReadonlyArray<PropertyKey>\n): unknown {\n  let output: unknown = data;\n  for (const key of keys) {\n    if (output === undefined || output === null) {\n      return undefined;\n    }\n    // @ts-expect-error [ts7053] -- This is fine, the types are really dynamic\n    // here and TypeScript doesn't have a chance to infer them correctly.\n    output = output[key];\n  }\n  return output;\n}\n"],"mappings":"AAubA,SAAgB,EACd,EACA,GAAG,EACM,CACT,OAAO,OAAO,GAAc,UACvB,OAAO,GAAc,UACrB,OAAO,GAAc,SACrB,GAAyB,EAAmB,EAAM,EAAW,GAAG,EAAK,CACtE,EAAmB,EAAW,GAAG,EAAK,CAG5C,SAAS,EACP,EACA,GAAG,EACM,CACT,IAAI,EAAkB,EACtB,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,GAAmC,KACrC,OAIF,EAAS,EAAO,GAElB,OAAO"}

package/dist/pull-object.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t,n){let r={};for(let[i,a]of e.entries()){let o=t(a,i,e);r[o]=n(a,i,e)}return r}exports.pullObject=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n){let r={};for(let[i,a]of e.entries()){let o=t(a,i,e);r[o]=n(a,i,e)}return r}exports.pullObject=t;
+//# sourceMappingURL=pull-object.cjs.map

package/dist/pull-object.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull-object.cjs","names":["curry"],"sources":["../src/pull-object.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Creates an object that maps the result of `valueExtractor` with a key\n * resulting from running `keyExtractor` on each item in `data`. Duplicate keys\n * are overwritten, guaranteeing that the extractor functions are run on each\n * item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - The items used to pull/extract the keys and values from.\n * @param keyExtractor - Computes the key for item.\n * @param valueExtractor - Computes the value for the item.\n * @signature\n *   pullObject(data, keyExtractor, valueExtractor);\n * @example\n *   pullObject(\n *     [\n *       { name: \"john\", email: \"john@perkakas.com\" },\n *       { name: \"jane\", email: \"jane@perkakas.com\" }\n *     ],\n *     prop(\"name\"),\n *     prop(\"email\"),\n *   ); // => { john: \"john@perkakas.com\", jane: \"jane@perkakas.com\" }\n * @dataFirst\n * @category Object\n */\nexport function pullObject<\n  T extends IterableContainer,\n  K extends PropertyKey,\n  V,\n>(\n  data: T,\n  keyExtractor: (item: T[number], index: number, data: T) => K,\n  valueExtractor: (item: T[number], index: number, data: T) => V,\n): BoundedPartial<Record<K, V>>;\n\n/**\n * Creates an object that maps the result of `valueExtractor` with a key\n * resulting from running `keyExtractor` on each item in `data`. Duplicate keys\n * are overwritten, guaranteeing that the extractor functions are run on each\n * item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param keyExtractor - Computes the key for item.\n * @param valueExtractor - Computes the value for the item.\n * @signature\n *   pullObject(keyExtractor, valueExtractor)(data);\n * @example\n *   pipe(\n *     [\n *       { name: \"john\", email: \"john@perkakas.com\" },\n *       { name: \"jane\", email: \"jane@perkakas.com\" }\n *     ],\n *     pullObject(prop(\"name\"), prop(\"email\")),\n *   ); // => { john: \"john@perkakas.com\", jane: \"jane@perkakas.com\" }\n * @dataLast\n * @category Object\n */\nexport function pullObject<\n  T extends IterableContainer,\n  K extends PropertyKey,\n  V,\n>(\n  keyExtractor: (item: T[number], index: number, data: T) => K,\n  valueExtractor: (item: T[number], index: number, data: T) => V,\n): (data: T) => BoundedPartial<Record<K, V>>;\n\nexport function pullObject(...args: ReadonlyArray<unknown>): unknown {\n  return curry(pullObjectImplementation, args);\n}\n\nfunction pullObjectImplementation<\n  T extends IterableContainer,\n  K extends PropertyKey,\n  V,\n>(\n  data: T,\n  keyExtractor: (item: T[number], index: number, data: T) => K,\n  valueExtractor: (item: T[number], index: number, data: T) => V,\n): Partial<Record<K, V>> {\n  const result: Partial<Record<K, V>> = {};\n\n  for (const [index, item] of data.entries()) {\n    const key = keyExtractor(item, index, data);\n    const value = valueExtractor(item, index, data);\n    result[key] = value;\n  }\n\n  return result;\n}\n"],"mappings":"kGAiFA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,MAAM,EAA0B,EAAK,CAG9C,SAAS,EAKP,EACA,EACA,EACuB,CACvB,IAAM,EAAgC,EAAE,CAExC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,IAAM,EAAM,EAAa,EAAM,EAAO,EAAK,CAE3C,EAAO,GADO,EAAe,EAAM,EAAO,EAAK,CAIjD,OAAO"}

package/dist/pull-object.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t,n){let r={};for(let[i,a]of e.entries()){let o=t(a,i,e);r[o]=n(a,i,e)}return r}export{t as pullObject};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t,n){let r={};for(let[i,a]of e.entries()){let o=t(a,i,e);r[o]=n(a,i,e)}return r}export{t as pullObject};
 //# sourceMappingURL=pull-object.js.map

package/dist/pull-object.js.map

@@ -1 +1 @@
-{"version":3,"file":"pull-object.js","names":["result: Partial<Record<K, V>>"],"sources":["../src/pull-object.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Creates an object that maps the result of `valueExtractor` with a key\n * resulting from running `keyExtractor` on each item in `data`. Duplicate keys\n * are overwritten, guaranteeing that the extractor functions are run on each\n * item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - The items used to pull/extract the keys and values from.\n * @param keyExtractor - Computes the key for item.\n * @param valueExtractor - Computes the value for the item.\n * @signature\n *   P.pullObject(data, keyExtractor, valueExtractor);\n * @example\n *   P.pullObject(\n *     [\n *       { name: \"john\", email: \"john@bebedag.com\" },\n *       { name: \"jane\", email: \"jane@bebedag.com\" }\n *     ],\n *     P.prop(\"name\"),\n *     P.prop(\"email\"),\n *   ); // => { john: \"john@bebedag.com\", jane: \"jane@bebedag.com\" }\n * @dataFirst\n * @category Object\n */\nexport function pullObject<\n  T extends IterableContainer,\n  K extends PropertyKey,\n  V,\n>(\n  data: T,\n  keyExtractor: (item: T[number], index: number, data: T) => K,\n  valueExtractor: (item: T[number], index: number, data: T) => V,\n): BoundedPartial<Record<K, V>>;\n\n/**\n * Creates an object that maps the result of `valueExtractor` with a key\n * resulting from running `keyExtractor` on each item in `data`. Duplicate keys\n * are overwritten, guaranteeing that the extractor functions are run on each\n * item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param keyExtractor - Computes the key for item.\n * @param valueExtractor - Computes the value for the item.\n * @signature\n *   P.pullObject(keyExtractor, valueExtractor)(data);\n * @example\n *   P.pipe(\n *     [\n *       { name: \"john\", email: \"john@bebedag.com\" },\n *       { name: \"jane\", email: \"jane@bebedag.com\" }\n *     ],\n *     P.pullObject(P.prop(\"email\"), P.prop(\"name\")),\n *   ); // => { john: \"john@bebedag.com\", jane: \"jane@bebedag.com\" }\n * @dataLast\n * @category Object\n */\nexport function pullObject<\n  T extends IterableContainer,\n  K extends PropertyKey,\n  V,\n>(\n  keyExtractor: (item: T[number], index: number, data: T) => K,\n  valueExtractor: (item: T[number], index: number, data: T) => V,\n): (data: T) => BoundedPartial<Record<K, V>>;\n\nexport function pullObject(...args: ReadonlyArray<unknown>): unknown {\n  return curry(pullObjectImplementation, args);\n}\n\nfunction pullObjectImplementation<\n  T extends IterableContainer,\n  K extends PropertyKey,\n  V,\n>(\n  data: T,\n  keyExtractor: (item: T[number], index: number, data: T) => K,\n  valueExtractor: (item: T[number], index: number, data: T) => V,\n): Partial<Record<K, V>> {\n  const result: Partial<Record<K, V>> = {};\n\n  for (const [index, item] of data.entries()) {\n    const key = keyExtractor(item, index, data);\n    const value = valueExtractor(item, index, data);\n    result[key] = value;\n  }\n\n  return result;\n}\n"],"mappings":"wCAoFA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EAKP,EACA,EACA,EACuB,CACvB,IAAMA,EAAgC,EAAE,CAExC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,IAAM,EAAM,EAAa,EAAM,EAAO,EAAK,CAE3C,EAAO,GADO,EAAe,EAAM,EAAO,EAAK,CAIjD,OAAO"}
+{"version":3,"file":"pull-object.js","names":[],"sources":["../src/pull-object.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Creates an object that maps the result of `valueExtractor` with a key\n * resulting from running `keyExtractor` on each item in `data`. Duplicate keys\n * are overwritten, guaranteeing that the extractor functions are run on each\n * item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - The items used to pull/extract the keys and values from.\n * @param keyExtractor - Computes the key for item.\n * @param valueExtractor - Computes the value for the item.\n * @signature\n *   pullObject(data, keyExtractor, valueExtractor);\n * @example\n *   pullObject(\n *     [\n *       { name: \"john\", email: \"john@perkakas.com\" },\n *       { name: \"jane\", email: \"jane@perkakas.com\" }\n *     ],\n *     prop(\"name\"),\n *     prop(\"email\"),\n *   ); // => { john: \"john@perkakas.com\", jane: \"jane@perkakas.com\" }\n * @dataFirst\n * @category Object\n */\nexport function pullObject<\n  T extends IterableContainer,\n  K extends PropertyKey,\n  V,\n>(\n  data: T,\n  keyExtractor: (item: T[number], index: number, data: T) => K,\n  valueExtractor: (item: T[number], index: number, data: T) => V,\n): BoundedPartial<Record<K, V>>;\n\n/**\n * Creates an object that maps the result of `valueExtractor` with a key\n * resulting from running `keyExtractor` on each item in `data`. Duplicate keys\n * are overwritten, guaranteeing that the extractor functions are run on each\n * item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param keyExtractor - Computes the key for item.\n * @param valueExtractor - Computes the value for the item.\n * @signature\n *   pullObject(keyExtractor, valueExtractor)(data);\n * @example\n *   pipe(\n *     [\n *       { name: \"john\", email: \"john@perkakas.com\" },\n *       { name: \"jane\", email: \"jane@perkakas.com\" }\n *     ],\n *     pullObject(prop(\"name\"), prop(\"email\")),\n *   ); // => { john: \"john@perkakas.com\", jane: \"jane@perkakas.com\" }\n * @dataLast\n * @category Object\n */\nexport function pullObject<\n  T extends IterableContainer,\n  K extends PropertyKey,\n  V,\n>(\n  keyExtractor: (item: T[number], index: number, data: T) => K,\n  valueExtractor: (item: T[number], index: number, data: T) => V,\n): (data: T) => BoundedPartial<Record<K, V>>;\n\nexport function pullObject(...args: ReadonlyArray<unknown>): unknown {\n  return curry(pullObjectImplementation, args);\n}\n\nfunction pullObjectImplementation<\n  T extends IterableContainer,\n  K extends PropertyKey,\n  V,\n>(\n  data: T,\n  keyExtractor: (item: T[number], index: number, data: T) => K,\n  valueExtractor: (item: T[number], index: number, data: T) => V,\n): Partial<Record<K, V>> {\n  const result: Partial<Record<K, V>> = {};\n\n  for (const [index, item] of data.entries()) {\n    const key = keyExtractor(item, index, data);\n    const value = valueExtractor(item, index, data);\n    result[key] = value;\n  }\n\n  return result;\n}\n"],"mappings":"mCAiFA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EAKP,EACA,EACA,EACuB,CACvB,IAAM,EAAgC,EAAE,CAExC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,IAAM,EAAM,EAAa,EAAM,EAAO,EAAK,CAE3C,EAAO,GADO,EAAe,EAAM,EAAO,EAAK,CAIjD,OAAO"}

package/dist/random-big-int.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,r){if(r<e)throw RangeError(`randomBigInt: The range [${e.toString()},${r.toString()}] is empty.`);let i=r-e,{length:a}=i.toString(2),o=Math.ceil(a/8),s=BigInt(8-a%8);for(;;){let r=t(n(o))>>s;if(r<=i)return r+e}}function t(e){let t=0n;for(let n of e)t=(t<<8n)+BigInt(n);return t}function n(e){let t=new Uint8Array(e);if(typeof crypto>`u`)for(let n=0;n<e;n+=1)t[n]=Math.floor(Math.random()*256);else crypto.getRandomValues(t);return t}exports.randomBigInt=e;
+//# sourceMappingURL=random-big-int.cjs.map

package/dist/random-big-int.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-big-int.cjs","names":[],"sources":["../src/random-big-int.ts"],"sourcesContent":["/**\n * Generate a random `bigint` between `from` and `to` (inclusive).\n *\n * ! Important: In most environments this function uses\n * [`crypto.getRandomValues()`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues)\n * under-the-hood which **is** cryptographically strong. When the WebCrypto API\n * isn't available (Node 18) we fallback to an implementation that uses\n * [`Math.random()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random)\n * which is **NOT** cryptographically secure.\n *\n * @param from - The minimum value.\n * @param to - The maximum value.\n * @returns The random integer.\n * @signature\n *   randomBigInt(from, to)\n * @example\n *   randomBigInt(1n, 10n) // => 5n\n * @dataFirst\n * @category Number\n */\nexport function randomBigInt(from: bigint, to: bigint): bigint {\n  if (to < from) {\n    throw new RangeError(\n      `randomBigInt: The range [${from.toString()},${to.toString()}] is empty.`,\n    );\n  }\n\n  const range = to - from;\n\n  // Get the max number of bits needed to encode the result. We will generate\n  // this number of random bits. A radix of 2 would give us the binary\n  // representation of the number.\n  const { length: maxBits } = range.toString(2 /* radix */);\n\n  // We can only generate random data in bytes, not bits, so we need to generate\n  // enough bytes to cover the required number of bits.\n  const maxBytes = Math.ceil(maxBits / 8);\n\n  // The number of bits we need to ignore in the random bitmap we generate.\n  const excessBits = BigInt(8 - (maxBits % 8));\n\n  while (true) {\n    // We use `crypto` for our RNG, it should be supported in all modern\n    // environments we support.\n    const randomBytes = random(maxBytes);\n\n    const raw = asBigInt(randomBytes);\n\n    // Shift the number back to our range, this effectively sets the excess bits\n    // to 0.\n    const result = raw >> excessBits;\n\n    // The generated number might overflow when `range < 2 ** maxBits - 1`, so\n    // it can't be returned. To ensure that all possible results have the same\n    // probability, we ignore the value entirely and try again (instead of\n    // trying to adapt it to the output range somehow).\n    if (result <= range) {\n      return result + from;\n    }\n  }\n}\n\nfunction asBigInt(bytes: Iterable<number>): bigint {\n  let result = 0n;\n  for (const byte of bytes) {\n    // We build the bigint by shifting the current value by a byte, and putting\n    // the next byte in that \"slot\".\n    result = (result << 8n) + BigInt(byte);\n  }\n  return result;\n}\n\nfunction random(numBytes: number): Uint8Array {\n  const output = new Uint8Array(numBytes);\n\n  if (typeof crypto === 'undefined') {\n    // Polyfill for environments without `crypto` support. The only env which\n    // requires this and we support is Node 18; once we drop support for it we\n    // can drop the polyfill.\n    for (let index = 0; index < numBytes; index += 1) {\n      output[index] = Math.floor(Math.random() * 256);\n    }\n  } else {\n    crypto.getRandomValues(output);\n  }\n\n  return output;\n}\n"],"mappings":"mEAoBA,SAAgB,EAAa,EAAc,EAAoB,CAC7D,GAAI,EAAK,EACP,MAAU,WACR,4BAA4B,EAAK,UAAU,CAAC,GAAG,EAAG,UAAU,CAAC,aAC9D,CAGH,IAAM,EAAQ,EAAK,EAKb,CAAE,OAAQ,GAAY,EAAM,SAAS,EAAc,CAInD,EAAW,KAAK,KAAK,EAAU,EAAE,CAGjC,EAAa,OAAO,EAAK,EAAU,EAAG,CAE5C,OAAa,CASX,IAAM,EAJM,EAFQ,EAAO,EAAS,CAEH,EAIX,EAMtB,GAAI,GAAU,EACZ,OAAO,EAAS,GAKtB,SAAS,EAAS,EAAiC,CACjD,IAAI,EAAS,GACb,IAAK,IAAM,KAAQ,EAGjB,GAAU,GAAU,IAAM,OAAO,EAAK,CAExC,OAAO,EAGT,SAAS,EAAO,EAA8B,CAC5C,IAAM,EAAS,IAAI,WAAW,EAAS,CAEvC,GAAI,OAAO,OAAW,IAIpB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAU,GAAS,EAC7C,EAAO,GAAS,KAAK,MAAM,KAAK,QAAQ,CAAG,IAAI,MAGjD,OAAO,gBAAgB,EAAO,CAGhC,OAAO"}

package/dist/random-big-int.js

@@ -0,0 +1,2 @@
+function e(e,r){if(r<e)throw RangeError(`randomBigInt: The range [${e.toString()},${r.toString()}] is empty.`);let i=r-e,{length:a}=i.toString(2),o=Math.ceil(a/8),s=BigInt(8-a%8);for(;;){let r=t(n(o))>>s;if(r<=i)return r+e}}function t(e){let t=0n;for(let n of e)t=(t<<8n)+BigInt(n);return t}function n(e){let t=new Uint8Array(e);if(typeof crypto>`u`)for(let n=0;n<e;n+=1)t[n]=Math.floor(Math.random()*256);else crypto.getRandomValues(t);return t}export{e as randomBigInt};
+//# sourceMappingURL=random-big-int.js.map

package/dist/random-big-int.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-big-int.js","names":[],"sources":["../src/random-big-int.ts"],"sourcesContent":["/**\n * Generate a random `bigint` between `from` and `to` (inclusive).\n *\n * ! Important: In most environments this function uses\n * [`crypto.getRandomValues()`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues)\n * under-the-hood which **is** cryptographically strong. When the WebCrypto API\n * isn't available (Node 18) we fallback to an implementation that uses\n * [`Math.random()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random)\n * which is **NOT** cryptographically secure.\n *\n * @param from - The minimum value.\n * @param to - The maximum value.\n * @returns The random integer.\n * @signature\n *   randomBigInt(from, to)\n * @example\n *   randomBigInt(1n, 10n) // => 5n\n * @dataFirst\n * @category Number\n */\nexport function randomBigInt(from: bigint, to: bigint): bigint {\n  if (to < from) {\n    throw new RangeError(\n      `randomBigInt: The range [${from.toString()},${to.toString()}] is empty.`,\n    );\n  }\n\n  const range = to - from;\n\n  // Get the max number of bits needed to encode the result. We will generate\n  // this number of random bits. A radix of 2 would give us the binary\n  // representation of the number.\n  const { length: maxBits } = range.toString(2 /* radix */);\n\n  // We can only generate random data in bytes, not bits, so we need to generate\n  // enough bytes to cover the required number of bits.\n  const maxBytes = Math.ceil(maxBits / 8);\n\n  // The number of bits we need to ignore in the random bitmap we generate.\n  const excessBits = BigInt(8 - (maxBits % 8));\n\n  while (true) {\n    // We use `crypto` for our RNG, it should be supported in all modern\n    // environments we support.\n    const randomBytes = random(maxBytes);\n\n    const raw = asBigInt(randomBytes);\n\n    // Shift the number back to our range, this effectively sets the excess bits\n    // to 0.\n    const result = raw >> excessBits;\n\n    // The generated number might overflow when `range < 2 ** maxBits - 1`, so\n    // it can't be returned. To ensure that all possible results have the same\n    // probability, we ignore the value entirely and try again (instead of\n    // trying to adapt it to the output range somehow).\n    if (result <= range) {\n      return result + from;\n    }\n  }\n}\n\nfunction asBigInt(bytes: Iterable<number>): bigint {\n  let result = 0n;\n  for (const byte of bytes) {\n    // We build the bigint by shifting the current value by a byte, and putting\n    // the next byte in that \"slot\".\n    result = (result << 8n) + BigInt(byte);\n  }\n  return result;\n}\n\nfunction random(numBytes: number): Uint8Array {\n  const output = new Uint8Array(numBytes);\n\n  if (typeof crypto === 'undefined') {\n    // Polyfill for environments without `crypto` support. The only env which\n    // requires this and we support is Node 18; once we drop support for it we\n    // can drop the polyfill.\n    for (let index = 0; index < numBytes; index += 1) {\n      output[index] = Math.floor(Math.random() * 256);\n    }\n  } else {\n    crypto.getRandomValues(output);\n  }\n\n  return output;\n}\n"],"mappings":"AAoBA,SAAgB,EAAa,EAAc,EAAoB,CAC7D,GAAI,EAAK,EACP,MAAU,WACR,4BAA4B,EAAK,UAAU,CAAC,GAAG,EAAG,UAAU,CAAC,aAC9D,CAGH,IAAM,EAAQ,EAAK,EAKb,CAAE,OAAQ,GAAY,EAAM,SAAS,EAAc,CAInD,EAAW,KAAK,KAAK,EAAU,EAAE,CAGjC,EAAa,OAAO,EAAK,EAAU,EAAG,CAE5C,OAAa,CASX,IAAM,EAJM,EAFQ,EAAO,EAAS,CAEH,EAIX,EAMtB,GAAI,GAAU,EACZ,OAAO,EAAS,GAKtB,SAAS,EAAS,EAAiC,CACjD,IAAI,EAAS,GACb,IAAK,IAAM,KAAQ,EAGjB,GAAU,GAAU,IAAM,OAAO,EAAK,CAExC,OAAO,EAGT,SAAS,EAAO,EAA8B,CAC5C,IAAM,EAAS,IAAI,WAAW,EAAS,CAEvC,GAAI,OAAO,OAAW,IAIpB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAU,GAAS,EAC7C,EAAO,GAAS,KAAK,MAAM,KAAK,QAAQ,CAAG,IAAI,MAGjD,OAAO,gBAAgB,EAAO,CAGhC,OAAO"}

package/dist/random-integer.cjs

@@ -1 +1,2 @@
-function e(e,t){let n=Math.ceil(e),r=Math.floor(t);if(r<n)throw RangeError(`randomInt: The range [${e},${t}] contains no integer`);return Math.floor(Math.random()*(r-n+1)+n)}exports.randomInteger=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,t){let n=Math.ceil(e),r=Math.floor(t);if(r<n)throw RangeError(`randomInteger: The range [${e.toString()},${t.toString()}] contains no integer`);return Math.floor(Math.random()*(r-n+1)+n)}exports.randomInteger=e;
+//# sourceMappingURL=random-integer.cjs.map

package/dist/random-integer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-integer.cjs","names":[],"sources":["../src/random-integer.ts"],"sourcesContent":["import type {\n  GreaterThan,\n  GreaterThanOrEqual,\n  IsEqual,\n  IsNever,\n  NonNegativeInteger,\n  Or,\n} from 'type-fest';\nimport type { IntRangeInclusive } from './internal/types/int-range-inclusive';\n\n// This limitation is defined by type-fest\ntype MaxLiteral = 1000;\n\ntype RandomInteger<From extends number, To extends number>\n  = Or<\n    IsNever<NonNegativeInteger<From>>,\n    IsNever<NonNegativeInteger<To>>\n  > extends true\n    ? number\n    : IsEqual<From, To> extends true\n      ? From\n      : GreaterThan<From, To> extends true\n        ? never\n        : GreaterThanOrEqual<To, MaxLiteral> extends true\n          ? number\n          : IntRangeInclusive<From, To>;\n\n/**\n * Generate a random integer between `from` and `to` (inclusive).\n *\n * !Important: This function uses [`Math.random()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) under-the-hood, which has two major limitations:\n * 1. It generates 2^52 possible values, so the bigger the range, the less\n * uniform the distribution of values would be, and at ranges larger than that\n * some values would never come up.\n * 2. It is not cryptographically secure and should not be used for security\n * scenarios.\n *\n * @param from - The minimum value.\n * @param to - The maximum value.\n * @returns The random integer.\n * @signature\n *   randomInteger(from, to)\n * @example\n *   randomInteger(1, 10) // => 5\n *   randomInteger(1.5, 2.6) // => 2\n * @dataFirst\n * @category Number\n */\nexport function randomInteger<From extends number, To extends number>(\n  from: From,\n  to: To,\n): RandomInteger<From, To> {\n  const fromCeiled = Math.ceil(from);\n  const toFloored = Math.floor(to);\n\n  if (toFloored < fromCeiled) {\n    throw new RangeError(\n      `randomInteger: The range [${from.toString()},${to.toString()}] contains no integer`,\n    );\n  }\n\n  return Math.floor(\n    Math.random() * (toFloored - fromCeiled + 1) + fromCeiled,\n  ) as RandomInteger<From, To>;\n}\n"],"mappings":"mEAgDA,SAAgB,EACd,EACA,EACyB,CACzB,IAAM,EAAa,KAAK,KAAK,EAAK,CAC5B,EAAY,KAAK,MAAM,EAAG,CAEhC,GAAI,EAAY,EACd,MAAU,WACR,6BAA6B,EAAK,UAAU,CAAC,GAAG,EAAG,UAAU,CAAC,uBAC/D,CAGH,OAAO,KAAK,MACV,KAAK,QAAQ,EAAI,EAAY,EAAa,GAAK,EAChD"}

package/dist/random-integer.js

@@ -1,2 +1,2 @@
-function e(e,t){let n=Math.ceil(e),r=Math.floor(t);if(r<n)throw RangeError(`randomInt: The range [${e},${t}] contains no integer`);return Math.floor(Math.random()*(r-n+1)+n)}export{e as randomInteger};
+function e(e,t){let n=Math.ceil(e),r=Math.floor(t);if(r<n)throw RangeError(`randomInteger: The range [${e.toString()},${t.toString()}] contains no integer`);return Math.floor(Math.random()*(r-n+1)+n)}export{e as randomInteger};
 //# sourceMappingURL=random-integer.js.map

package/dist/random-integer.js.map

@@ -1 +1 @@
-{"version":3,"file":"random-integer.js","names":[],"sources":["../src/random-integer.ts"],"sourcesContent":["import type {\n  GreaterThan,\n  GreaterThanOrEqual,\n  IsEqual,\n  IsNever,\n  NonNegativeInteger,\n  Or,\n} from 'type-fest';\nimport type { IntRangeInclusive } from './internal/types/int-range-inclusive';\n\ntype RandomInteger<From extends number, To extends number>\n  = Or<\n    IsNever<NonNegativeInteger<From>>,\n    IsNever<NonNegativeInteger<To>>\n  > extends true\n    ? number\n    : IsEqual<From, To> extends true\n      ? From\n      : GreaterThan<From, To> extends true\n        ? never\n        : GreaterThanOrEqual<To, 1000> extends true\n          ? number\n          : IntRangeInclusive<From, To>;\n\n/**\n * Generate a random integer between `from` and `to` (inclusive).\n *\n * @param from - The minimum value.\n * @param to - The maximum value.\n * @returns The random integer.\n * @signature\n *   P.randomInt(from, to)\n * @example\n *   P.randomInt(1, 10) // => 5\n *   P.randomInt(1.5, 2.6) // => 2\n * @dataFirst\n * @category Number\n */\nexport function randomInteger<From extends number, To extends number>(\n  from: From,\n  to: To,\n): RandomInteger<From, To> {\n  const fromCeiled = Math.ceil(from);\n  const toFloored = Math.floor(to);\n\n  if (toFloored < fromCeiled) {\n    throw new RangeError(\n      `randomInt: The range [${from},${to}] contains no integer`,\n    );\n  }\n\n  return Math.floor(\n    Math.random() * (toFloored - fromCeiled + 1) + fromCeiled,\n  ) as RandomInteger<From, To>;\n}\n"],"mappings":"AAsCA,SAAgB,EACd,EACA,EACyB,CACzB,IAAM,EAAa,KAAK,KAAK,EAAK,CAC5B,EAAY,KAAK,MAAM,EAAG,CAEhC,GAAI,EAAY,EACd,MAAU,WACR,yBAAyB,EAAK,GAAG,EAAG,uBACrC,CAGH,OAAO,KAAK,MACV,KAAK,QAAQ,EAAI,EAAY,EAAa,GAAK,EAChD"}
+{"version":3,"file":"random-integer.js","names":[],"sources":["../src/random-integer.ts"],"sourcesContent":["import type {\n  GreaterThan,\n  GreaterThanOrEqual,\n  IsEqual,\n  IsNever,\n  NonNegativeInteger,\n  Or,\n} from 'type-fest';\nimport type { IntRangeInclusive } from './internal/types/int-range-inclusive';\n\n// This limitation is defined by type-fest\ntype MaxLiteral = 1000;\n\ntype RandomInteger<From extends number, To extends number>\n  = Or<\n    IsNever<NonNegativeInteger<From>>,\n    IsNever<NonNegativeInteger<To>>\n  > extends true\n    ? number\n    : IsEqual<From, To> extends true\n      ? From\n      : GreaterThan<From, To> extends true\n        ? never\n        : GreaterThanOrEqual<To, MaxLiteral> extends true\n          ? number\n          : IntRangeInclusive<From, To>;\n\n/**\n * Generate a random integer between `from` and `to` (inclusive).\n *\n * !Important: This function uses [`Math.random()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) under-the-hood, which has two major limitations:\n * 1. It generates 2^52 possible values, so the bigger the range, the less\n * uniform the distribution of values would be, and at ranges larger than that\n * some values would never come up.\n * 2. It is not cryptographically secure and should not be used for security\n * scenarios.\n *\n * @param from - The minimum value.\n * @param to - The maximum value.\n * @returns The random integer.\n * @signature\n *   randomInteger(from, to)\n * @example\n *   randomInteger(1, 10) // => 5\n *   randomInteger(1.5, 2.6) // => 2\n * @dataFirst\n * @category Number\n */\nexport function randomInteger<From extends number, To extends number>(\n  from: From,\n  to: To,\n): RandomInteger<From, To> {\n  const fromCeiled = Math.ceil(from);\n  const toFloored = Math.floor(to);\n\n  if (toFloored < fromCeiled) {\n    throw new RangeError(\n      `randomInteger: The range [${from.toString()},${to.toString()}] contains no integer`,\n    );\n  }\n\n  return Math.floor(\n    Math.random() * (toFloored - fromCeiled + 1) + fromCeiled,\n  ) as RandomInteger<From, To>;\n}\n"],"mappings":"AAgDA,SAAgB,EACd,EACA,EACyB,CACzB,IAAM,EAAa,KAAK,KAAK,EAAK,CAC5B,EAAY,KAAK,MAAM,EAAG,CAEhC,GAAI,EAAY,EACd,MAAU,WACR,6BAA6B,EAAK,UAAU,CAAC,GAAG,EAAG,UAAU,CAAC,uBAC/D,CAGH,OAAO,KAAK,MACV,KAAK,QAAQ,EAAI,EAAY,EAAa,GAAK,EAChD"}

package/dist/random-string.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`;function n(...t){return e.t(r,t)}function r(e){let t=[];for(let n=0;n<e;n++){let e=`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`[Math.floor(Math.random()*62)];t.push(e)}return t.join(``)}exports.randomString=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){let t=[];for(let n=0;n<e;n++){let e=`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`[Math.floor(Math.random()*62)];t.push(e)}return t.join(``)}exports.randomString=t;
+//# sourceMappingURL=random-string.cjs.map

package/dist/random-string.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-string.cjs","names":["curry"],"sources":["../src/random-string.ts"],"sourcesContent":["import { curry } from './curry';\n\nconst ALPHABET\n  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n/**\n * A [pseudo-random](https://en.wikipedia.org/wiki/Pseudorandom_number_generator) [alpha-numeric](https://en.wikipedia.org/wiki/Alphanumericals)\n * [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String).\n *\n * It is not [cryptographically secure](https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator)!\n *\n * @param length - The length of the random string.\n * @returns The random string.\n * @signature\n *   randomString(length)\n * @example\n *   randomString(5) // => aB92J\n * @dataFirst\n * @category String\n */\nexport function randomString(length: number): string;\n\n/**\n * A [pseudo-random](https://en.wikipedia.org/wiki/Pseudorandom_number_generator) [alpha-numeric](https://en.wikipedia.org/wiki/Alphanumericals)\n * [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String).\n *\n * It is not [cryptographically secure](https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator)!\n *\n * @returns The random string.\n * @signature\n *   randomString()(length)\n * @example\n *   pipe(5, randomString()) // => aB92J\n * @dataLast\n * @category String\n */\nexport function randomString(): (length: number) => string;\n\nexport function randomString(...args: ReadonlyArray<unknown>): unknown {\n  return curry(randomStringImplementation, args);\n}\n\nfunction randomStringImplementation(length: number): string {\n  const out: Array<string> = [];\n  for (let iteration = 0; iteration < length; iteration++) {\n    const randomChar = ALPHABET[Math.floor(Math.random() * ALPHABET.length)]!;\n    out.push(randomChar);\n  }\n  return out.join('');\n}\n"],"mappings":"kGAsCA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAOA,EAAAA,MAAM,EAA4B,EAAK,CAGhD,SAAS,EAA2B,EAAwB,CAC1D,IAAM,EAAqB,EAAE,CAC7B,IAAK,IAAI,EAAY,EAAG,EAAY,EAAQ,IAAa,CACvD,IAAM,EAAa,iEAAS,KAAK,MAAM,KAAK,QAAQ,CAAG,GAAgB,EACvE,EAAI,KAAK,EAAW,CAEtB,OAAO,EAAI,KAAK,GAAG"}

package/dist/random-string.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){let t=[];for(let n=0;n<e;n++){let e=`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`[Math.floor(Math.random()*62)];t.push(e)}return t.join(``)}export{t as randomString};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){let t=[];for(let n=0;n<e;n++){let e=`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`[Math.floor(Math.random()*62)];t.push(e)}return t.join(``)}export{t as randomString};
 //# sourceMappingURL=random-string.js.map

package/dist/random-string.js.map

@@ -1 +1 @@
-{"version":3,"file":"random-string.js","names":["out: Array<string>"],"sources":["../src/random-string.ts"],"sourcesContent":["import { curry } from './curry';\n\nconst ALPHABET\n  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n/**\n * Random a non-cryptographic random string from characters a-zA-Z0-9.\n *\n * @param length - The length of the random string.\n * @returns The random string.\n * @signature\n *   P.randomString(length)\n * @example\n *   P.randomString(5) // => aB92J\n * @dataFirst\n * @category String\n */\nexport function randomString(length: number): string;\n\n/**\n * Random a non-cryptographic random string from characters a-zA-Z0-9.\n *\n * @returns The random string.\n * @signature\n *   P.randomString()(length)\n * @example\n *   P.pipe(5, P.randomString()) // => aB92J\n * @dataLast\n * @category String\n */\nexport function randomString(): (length: number) => string;\n\nexport function randomString(...args: ReadonlyArray<unknown>): unknown {\n  return curry(randomStringImplementation, args);\n}\n\nfunction randomStringImplementation(length: number): string {\n  const out: Array<string> = [];\n  for (let iteration = 0; iteration < length; iteration++) {\n    const randomChar = ALPHABET[Math.floor(Math.random() * ALPHABET.length)]!;\n    out.push(randomChar);\n  }\n  return out.join('');\n}\n"],"mappings":"wCAgCA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAM,EAA4B,EAAK,CAGhD,SAAS,EAA2B,EAAwB,CAC1D,IAAMA,EAAqB,EAAE,CAC7B,IAAK,IAAI,EAAY,EAAG,EAAY,EAAQ,IAAa,CACvD,IAAM,EAAa,iEAAS,KAAK,MAAM,KAAK,QAAQ,CAAG,GAAgB,EACvE,EAAI,KAAK,EAAW,CAEtB,OAAO,EAAI,KAAK,GAAG"}
+{"version":3,"file":"random-string.js","names":[],"sources":["../src/random-string.ts"],"sourcesContent":["import { curry } from './curry';\n\nconst ALPHABET\n  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n/**\n * A [pseudo-random](https://en.wikipedia.org/wiki/Pseudorandom_number_generator) [alpha-numeric](https://en.wikipedia.org/wiki/Alphanumericals)\n * [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String).\n *\n * It is not [cryptographically secure](https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator)!\n *\n * @param length - The length of the random string.\n * @returns The random string.\n * @signature\n *   randomString(length)\n * @example\n *   randomString(5) // => aB92J\n * @dataFirst\n * @category String\n */\nexport function randomString(length: number): string;\n\n/**\n * A [pseudo-random](https://en.wikipedia.org/wiki/Pseudorandom_number_generator) [alpha-numeric](https://en.wikipedia.org/wiki/Alphanumericals)\n * [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String).\n *\n * It is not [cryptographically secure](https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator)!\n *\n * @returns The random string.\n * @signature\n *   randomString()(length)\n * @example\n *   pipe(5, randomString()) // => aB92J\n * @dataLast\n * @category String\n */\nexport function randomString(): (length: number) => string;\n\nexport function randomString(...args: ReadonlyArray<unknown>): unknown {\n  return curry(randomStringImplementation, args);\n}\n\nfunction randomStringImplementation(length: number): string {\n  const out: Array<string> = [];\n  for (let iteration = 0; iteration < length; iteration++) {\n    const randomChar = ALPHABET[Math.floor(Math.random() * ALPHABET.length)]!;\n    out.push(randomChar);\n  }\n  return out.join('');\n}\n"],"mappings":"mCAsCA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAM,EAA4B,EAAK,CAGhD,SAAS,EAA2B,EAAwB,CAC1D,IAAM,EAAqB,EAAE,CAC7B,IAAK,IAAI,EAAY,EAAG,EAAY,EAAQ,IAAa,CACvD,IAAM,EAAa,iEAAS,KAAK,MAAM,KAAK,QAAQ,CAAG,GAAgB,EACvE,EAAI,KAAK,EAAW,CAEtB,OAAO,EAAI,KAAK,GAAG"}

package/dist/range.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n=[];for(let r=e;r<t;r++)n.push(r);return n}exports.range=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n=typeof t==`object`?t.step:1;if(n===0)throw RangeError(`range: step cannot be zero (0)!`);let i=r(((typeof t==`object`?t.end:t)-e)/n);return i<=0?[]:Array.from({length:i},(t,r)=>r===0?e:e+r*n)}function r(e){if(e===0)return 0;let t=Math.round(e);return Math.abs(e-t)/Math.abs(e)<1e-12?t:Math.ceil(e)}exports.range=t;
+//# sourceMappingURL=range.cjs.map

package/dist/range.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.cjs","names":["curry"],"sources":["../src/range.ts"],"sourcesContent":["import { curry } from './curry';\n\nconst DEFAULT_STEP = 1;\n\n// Relative tolerance for snapping a near-integer division result to the nearest\n// integer, preventing Math.ceil from inflating the length by one due to\n// floating-point error in the numerator or denominator.\nconst SNAP_TOLERANCE = 1e-12;\n\ninterface RangeOptions {\n  readonly end: number;\n  readonly step: number;\n}\n\n// TODO [>2]: Change the signature so that range takes a required \"end\" parameter and an optional Options object with `start` and `step` defaulting to `0` and `1` respectively to better align with how `range` works in other libraries and languages.\n/**\n * Returns a sequence of numbers from `start` (inclusive) to `end` (exclusive),\n * adding `step` (default is `1`) to each number in the sequence.\n *\n * @param start - The first number in the sequence.\n * @param endOrOptions - The end number **or** an object which is used to\n * **also** define a step size.\n * @param endOrOptions.end - The non-inclusive end of the range.\n * @param endOrOptions.step - The gap between consecutive numbers.\n * @signature\n *   range(start, end)\n *   range(start, { end, step })\n * @example\n *    range(1, 5); //=> [1, 2, 3, 4]\n *    range(1, { end: 5, step: 2 }); //=> [1, 3]\n * @dataFirst\n * @category Array\n */\nexport function range(\n  start: number,\n  endOrOptions: number | RangeOptions,\n): Array<number>;\n\n/**\n * Returns a sequence of numbers from `start` (inclusive) to `end` (exclusive),\n * adding `step` (default is `1`) to each number in the sequence.\n *\n * @param endOrOptions - The end number **or** an object which is used to\n * **also** define a step size.\n * @param endOrOptions.end - The non-inclusive end of the range.\n * @param endOrOptions.step - The gap between consecutive numbers.\n * @signature\n *   range(end)(start)\n *   range({ end, step })(start)\n * @example\n *    pipe(1, range(5)); //=> [1, 2, 3, 4]\n *    pipe(1, range({ end: 5, step: 2 })); //=> [1, 3]\n * @dataLast\n * @category Array\n */\nexport function range(\n  endOrOptions: number | RangeOptions,\n): (start: number) => Array<number>;\n\nexport function range(...args: ReadonlyArray<unknown>): unknown {\n  return curry(rangeImplementation, args);\n}\n\nfunction rangeImplementation(\n  start: number,\n  endOrOptions: number | RangeOptions,\n): Array<number> {\n  const step\n    = typeof endOrOptions === 'object' ? endOrOptions.step : DEFAULT_STEP;\n  if (step === 0) {\n    throw new RangeError('range: step cannot be zero (0)!');\n  }\n\n  const end\n    = typeof endOrOptions === 'object' ? endOrOptions.end : endOrOptions;\n  const length = ceilingWithSnap((end - start) / step);\n  if (length <= 0) {\n    return [];\n  }\n\n  return Array.from({ length }, (_, i) => (i === 0 ? start : start + i * step));\n}\n\n// JS's floating-point math can create numbers that are slightly larger than\n// the true mathematical result (e.g. `0.1 + 0.2 > 0.3`). This error would\n// propagate into more complex calculations, and specifically can cause\n// the built-in `Math.ceil` to round up a number that is effectively an\n// integer (e.g. `Math.ceil(0.1 + 0.2 - 0.3) === 1`). To work around this we\n// need an error margin where ceiling would ignore very small floating point\n// artifacts so that it effectively \"rounds\" down instead of up.\nfunction ceilingWithSnap(raw: number): number {\n  if (raw === 0) {\n    return 0;\n  }\n\n  const rounded = Math.round(raw);\n  return Math.abs(raw - rounded) / Math.abs(raw) < SNAP_TOLERANCE\n    ? rounded\n    : Math.ceil(raw);\n}\n"],"mappings":"kGA2DA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACe,CACf,IAAM,EACF,OAAO,GAAiB,SAAW,EAAa,KAAO,EAC3D,GAAI,IAAS,EACX,MAAU,WAAW,kCAAkC,CAKzD,IAAM,EAAS,IADX,OAAO,GAAiB,SAAW,EAAa,IAAM,GACpB,GAAS,EAAK,CAKpD,OAJI,GAAU,EACL,EAAE,CAGJ,MAAM,KAAK,CAAE,SAAQ,EAAG,EAAG,IAAO,IAAM,EAAI,EAAQ,EAAQ,EAAI,EAAM,CAU/E,SAAS,EAAgB,EAAqB,CAC5C,GAAI,IAAQ,EACV,MAAO,GAGT,IAAM,EAAU,KAAK,MAAM,EAAI,CAC/B,OAAO,KAAK,IAAI,EAAM,EAAQ,CAAG,KAAK,IAAI,EAAI,CAAG,MAC7C,EACA,KAAK,KAAK,EAAI"}

package/dist/range.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n=[];for(let r=e;r<t;r++)n.push(r);return n}export{t as range};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){let n=typeof t==`object`?t.step:1;if(n===0)throw RangeError(`range: step cannot be zero (0)!`);let i=r(((typeof t==`object`?t.end:t)-e)/n);return i<=0?[]:Array.from({length:i},(t,r)=>r===0?e:e+r*n)}function r(e){if(e===0)return 0;let t=Math.round(e);return Math.abs(e-t)/Math.abs(e)<1e-12?t:Math.ceil(e)}export{t as range};
 //# sourceMappingURL=range.js.map

package/dist/range.js.map

@@ -1 +1 @@
-{"version":3,"file":"range.js","names":["ret: Array<number>"],"sources":["../src/range.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).\n *\n * @param start - The start number.\n * @param end - The end number.\n * @signature range(start, end)\n * @example\n *    P.range(1, 5) // => [1, 2, 3, 4]\n * @dataFirst\n * @category Array\n */\nexport function range(start: number, end: number): Array<number>;\n\n/**\n * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).\n *\n * @param end - The end number.\n * @signature range(end)(start)\n * @example\n *    P.range(5)(1) // => [1, 2, 3, 4]\n * @dataFirst\n * @category Array\n */\nexport function range(end: number): (start: number) => Array<number>;\n\nexport function range(...args: ReadonlyArray<unknown>): unknown {\n  return curry(rangeImplementation, args);\n}\n\nfunction rangeImplementation(start: number, end: number): Array<number> {\n  const ret: Array<number> = [];\n  for (let i = start; i < end; i++) {\n    ret.push(i);\n  }\n  return ret;\n}\n"],"mappings":"wCA2BA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAAoB,EAAe,EAA4B,CACtE,IAAMA,EAAqB,EAAE,CAC7B,IAAK,IAAI,EAAI,EAAO,EAAI,EAAK,IAC3B,EAAI,KAAK,EAAE,CAEb,OAAO"}
+{"version":3,"file":"range.js","names":[],"sources":["../src/range.ts"],"sourcesContent":["import { curry } from './curry';\n\nconst DEFAULT_STEP = 1;\n\n// Relative tolerance for snapping a near-integer division result to the nearest\n// integer, preventing Math.ceil from inflating the length by one due to\n// floating-point error in the numerator or denominator.\nconst SNAP_TOLERANCE = 1e-12;\n\ninterface RangeOptions {\n  readonly end: number;\n  readonly step: number;\n}\n\n// TODO [>2]: Change the signature so that range takes a required \"end\" parameter and an optional Options object with `start` and `step` defaulting to `0` and `1` respectively to better align with how `range` works in other libraries and languages.\n/**\n * Returns a sequence of numbers from `start` (inclusive) to `end` (exclusive),\n * adding `step` (default is `1`) to each number in the sequence.\n *\n * @param start - The first number in the sequence.\n * @param endOrOptions - The end number **or** an object which is used to\n * **also** define a step size.\n * @param endOrOptions.end - The non-inclusive end of the range.\n * @param endOrOptions.step - The gap between consecutive numbers.\n * @signature\n *   range(start, end)\n *   range(start, { end, step })\n * @example\n *    range(1, 5); //=> [1, 2, 3, 4]\n *    range(1, { end: 5, step: 2 }); //=> [1, 3]\n * @dataFirst\n * @category Array\n */\nexport function range(\n  start: number,\n  endOrOptions: number | RangeOptions,\n): Array<number>;\n\n/**\n * Returns a sequence of numbers from `start` (inclusive) to `end` (exclusive),\n * adding `step` (default is `1`) to each number in the sequence.\n *\n * @param endOrOptions - The end number **or** an object which is used to\n * **also** define a step size.\n * @param endOrOptions.end - The non-inclusive end of the range.\n * @param endOrOptions.step - The gap between consecutive numbers.\n * @signature\n *   range(end)(start)\n *   range({ end, step })(start)\n * @example\n *    pipe(1, range(5)); //=> [1, 2, 3, 4]\n *    pipe(1, range({ end: 5, step: 2 })); //=> [1, 3]\n * @dataLast\n * @category Array\n */\nexport function range(\n  endOrOptions: number | RangeOptions,\n): (start: number) => Array<number>;\n\nexport function range(...args: ReadonlyArray<unknown>): unknown {\n  return curry(rangeImplementation, args);\n}\n\nfunction rangeImplementation(\n  start: number,\n  endOrOptions: number | RangeOptions,\n): Array<number> {\n  const step\n    = typeof endOrOptions === 'object' ? endOrOptions.step : DEFAULT_STEP;\n  if (step === 0) {\n    throw new RangeError('range: step cannot be zero (0)!');\n  }\n\n  const end\n    = typeof endOrOptions === 'object' ? endOrOptions.end : endOrOptions;\n  const length = ceilingWithSnap((end - start) / step);\n  if (length <= 0) {\n    return [];\n  }\n\n  return Array.from({ length }, (_, i) => (i === 0 ? start : start + i * step));\n}\n\n// JS's floating-point math can create numbers that are slightly larger than\n// the true mathematical result (e.g. `0.1 + 0.2 > 0.3`). This error would\n// propagate into more complex calculations, and specifically can cause\n// the built-in `Math.ceil` to round up a number that is effectively an\n// integer (e.g. `Math.ceil(0.1 + 0.2 - 0.3) === 1`). To work around this we\n// need an error margin where ceiling would ignore very small floating point\n// artifacts so that it effectively \"rounds\" down instead of up.\nfunction ceilingWithSnap(raw: number): number {\n  if (raw === 0) {\n    return 0;\n  }\n\n  const rounded = Math.round(raw);\n  return Math.abs(raw - rounded) / Math.abs(raw) < SNAP_TOLERANCE\n    ? rounded\n    : Math.ceil(raw);\n}\n"],"mappings":"mCA2DA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACe,CACf,IAAM,EACF,OAAO,GAAiB,SAAW,EAAa,KAAO,EAC3D,GAAI,IAAS,EACX,MAAU,WAAW,kCAAkC,CAKzD,IAAM,EAAS,IADX,OAAO,GAAiB,SAAW,EAAa,IAAM,GACpB,GAAS,EAAK,CAKpD,OAJI,GAAU,EACL,EAAE,CAGJ,MAAM,KAAK,CAAE,SAAQ,EAAG,EAAG,IAAO,IAAM,EAAI,EAAQ,EAAQ,EAAI,EAAM,CAU/E,SAAS,EAAgB,EAAqB,CAC5C,GAAI,IAAQ,EACV,MAAO,GAGT,IAAM,EAAU,KAAK,MAAM,EAAI,CAC/B,OAAO,KAAK,IAAI,EAAM,EAAQ,CAAG,KAAK,IAAI,EAAI,CAAG,MAC7C,EACA,KAAK,KAAK,EAAI"}

package/dist/rank-by.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-order-rules-ClqHrs8_.cjs`);function t(...t){return e.n(n,t)}function n(e,t,n){let r=0;for(let i of e)t(n,i)>0&&(r+=1);return r}exports.rankBy=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry-order-rules-DsJSy3gX.cjs`);function t(...t){return e.n(n,t)}function n(e,t,n){let r=0;for(let i of e)t(n,i)>0&&(r+=1);return r}exports.rankBy=t;
+//# sourceMappingURL=rank-by.cjs.map

package/dist/rank-by.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rank-by.cjs","names":["curryOrderRulesWithArgument"],"sources":["../src/rank-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\n\n/**\n * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.\n *\n * @param data - The input array.\n * @param item - The item whose rank is to be determined.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The rank of the item in the sorted array in the range [0..data.length].\n * @signature\n *   rankBy(data, item, ...rules)\n * @example\n *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;\n *   rankBy(DATA, 0, prop('a')) // => 0\n *   rankBy(DATA, 1, prop('a')) // => 1\n *   rankBy(DATA, 2, prop('a')) // => 1\n *   rankBy(DATA, 3, prop('a')) // => 2\n * @dataFirst\n * @category Array\n */\nexport function rankBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): number;\n\n/**\n * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.\n *\n * @param item - The item whose rank is to be determined.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The rank of the item in the sorted array in the range [0..data.length].\n * @signature\n *   rankBy(item, ...rules)(data)\n * @example\n *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;\n *   pipe(DATA, rankBy(0, prop('a'))) // => 0\n *   pipe(DATA, rankBy(1, prop('a'))) // => 1\n *   pipe(DATA, rankBy(2, prop('a'))) // => 1\n *   pipe(DATA, rankBy(3, prop('a'))) // => 2\n * @dataLast\n * @category Array\n */\nexport function rankBy<T>(\n  item: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: ReadonlyArray<T>) => number;\n\nexport function rankBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(rankByImplementation, args);\n}\n\nfunction rankByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  targetItem: T,\n): number {\n  let rank = 0;\n  for (const item of data) {\n    if (compareFn(targetItem, item) > 0) {\n      // The rank of the item is equivalent to the number of items that would\n      // come before it if the array was sorted. We assume that the\n      rank += 1;\n    }\n  }\n  return rank;\n}\n"],"mappings":"uHAsDA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,EAA4B,EAAsB,EAAK,CAGhE,SAAS,EACP,EACA,EACA,EACQ,CACR,IAAI,EAAO,EACX,IAAK,IAAM,KAAQ,EACb,EAAU,EAAY,EAAK,CAAG,IAGhC,GAAQ,GAGZ,OAAO"}

package/dist/rank-by.js

@@ -1,2 +1,2 @@
-import{n as e}from"./curry-order-rules-DwrF-_P1.js";function t(...t){return e(n,t)}function n(e,t,n){let r=0;for(let i of e)t(n,i)>0&&(r+=1);return r}export{t as rankBy};
+import{n as e}from"./curry-order-rules-BLyCSMdZ.js";function t(...t){return e(n,t)}function n(e,t,n){let r=0;for(let i of e)t(n,i)>0&&(r+=1);return r}export{t as rankBy};
 //# sourceMappingURL=rank-by.js.map

package/dist/rank-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"rank-by.js","names":[],"sources":["../src/rank-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\n\n/**\n * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.\n *\n * @param data - The input array.\n * @param item - The item whose rank is to be determined.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The rank of the item in the sorted array in the range [0..data.length].\n * @signature\n *   P.rankBy(data, item, ...rules)\n * @example\n *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;\n *   P.rankBy(DATA, 0, P.prop('a')) // => 0\n *   P.rankBy(DATA, 1, P.prop('a')) // => 1\n *   P.rankBy(DATA, 2, P.prop('a')) // => 1\n *   P.rankBy(DATA, 3, P.prop('a')) // => 2\n * @dataFirst\n * @category Array\n */\nexport function rankBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): number;\n\n/**\n * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.\n *\n * @param item - The item whose rank is to be determined.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The rank of the item in the sorted array in the range [0..data.length].\n * @signature\n *   P.rankBy(item, ...rules)(data)\n * @example\n *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;\n *   P.pipe(DATA, P.rankBy(0, P.prop('a'))) // => 0\n *   P.pipe(DATA, P.rankBy(1, P.prop('a'))) // => 1\n *   P.pipe(DATA, P.rankBy(2, P.prop('a'))) // => 1\n *   P.pipe(DATA, P.rankBy(3, P.prop('a'))) // => 2\n * @dataLast\n * @category Array\n */\nexport function rankBy<T>(\n  item: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: ReadonlyArray<T>) => number;\n\nexport function rankBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(rankByImplementation, args);\n}\n\nfunction rankByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  targetItem: T,\n): number {\n  let rank = 0;\n  for (const item of data) {\n    if (compareFn(targetItem, item) > 0) {\n      // The rank of the item is equivalent to the number of items that would\n      // come before it if the array was sorted. We assume that the\n      rank += 1;\n    }\n  }\n  return rank;\n}\n"],"mappings":"oDAsDA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAA4B,EAAsB,EAAK,CAGhE,SAAS,EACP,EACA,EACA,EACQ,CACR,IAAI,EAAO,EACX,IAAK,IAAM,KAAQ,EACb,EAAU,EAAY,EAAK,CAAG,IAGhC,GAAQ,GAGZ,OAAO"}
+{"version":3,"file":"rank-by.js","names":[],"sources":["../src/rank-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\n\n/**\n * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.\n *\n * @param data - The input array.\n * @param item - The item whose rank is to be determined.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The rank of the item in the sorted array in the range [0..data.length].\n * @signature\n *   rankBy(data, item, ...rules)\n * @example\n *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;\n *   rankBy(DATA, 0, prop('a')) // => 0\n *   rankBy(DATA, 1, prop('a')) // => 1\n *   rankBy(DATA, 2, prop('a')) // => 1\n *   rankBy(DATA, 3, prop('a')) // => 2\n * @dataFirst\n * @category Array\n */\nexport function rankBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): number;\n\n/**\n * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.\n *\n * @param item - The item whose rank is to be determined.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The rank of the item in the sorted array in the range [0..data.length].\n * @signature\n *   rankBy(item, ...rules)(data)\n * @example\n *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;\n *   pipe(DATA, rankBy(0, prop('a'))) // => 0\n *   pipe(DATA, rankBy(1, prop('a'))) // => 1\n *   pipe(DATA, rankBy(2, prop('a'))) // => 1\n *   pipe(DATA, rankBy(3, prop('a'))) // => 2\n * @dataLast\n * @category Array\n */\nexport function rankBy<T>(\n  item: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: ReadonlyArray<T>) => number;\n\nexport function rankBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(rankByImplementation, args);\n}\n\nfunction rankByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  targetItem: T,\n): number {\n  let rank = 0;\n  for (const item of data) {\n    if (compareFn(targetItem, item) > 0) {\n      // The rank of the item is equivalent to the number of items that would\n      // come before it if the array was sorted. We assume that the\n      rank += 1;\n    }\n  }\n  return rank;\n}\n"],"mappings":"oDAsDA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAA4B,EAAsB,EAAK,CAGhE,SAAS,EACP,EACA,EACA,EACQ,CACR,IAAI,EAAO,EACX,IAAK,IAAM,KAAQ,EACb,EAAU,EAAY,EAAK,CAAG,IAGhC,GAAQ,GAGZ,OAAO"}

package/dist/reduce.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t,n){return e.reduce(t,n)}exports.reduce=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n){return e.reduce(t,n)}exports.reduce=t;
+//# sourceMappingURL=reduce.cjs.map

package/dist/reduce.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce.cjs","names":["curry"],"sources":["../src/reduce.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Executes a user-supplied \"reducer\" callback function on each element of the\n * array, in order, passing in the return value from the calculation on the\n * preceding element. The final result of running the reducer across all\n * elements of the array is a single value. Equivalent to\n * `Array.prototype.reduce`.\n *\n * @param data - The items to reduce.\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value becomes the value of the accumulator parameter on the next\n * invocation of callbackFn. For the last invocation, the return value becomes\n * the return value of reduce().\n * @param initialValue - A value to which accumulator is initialized the first\n * time the callback is called. CallbackFn starts executing with the first value\n * in the array as currentValue.\n * @returns The value that results from running the \"reducer\" callback function\n * to completion over the entire array.\n * @signature\n *    reduce(data, callbackfn, initialValue)\n * @example\n *    reduce([1, 2, 3, 4, 5], (acc, x) => acc + x, 100) // => 115\n * @dataFirst\n * @category Array\n */\nexport function reduce<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): U;\n\n/**\n * Executes a user-supplied \"reducer\" callback function on each element of the\n * array, in order, passing in the return value from the calculation on the\n * preceding element. The final result of running the reducer across all\n * elements of the array is a single value. Equivalent to\n * `Array.prototype.reduce`.\n *\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value becomes the value of the accumulator parameter on the next\n * invocation of callbackFn. For the last invocation, the return value becomes\n * the return value of reduce().\n * @param initialValue - A value to which accumulator is initialized the first\n * time the callback is called. CallbackFn starts executing with the first value\n * in the array as currentValue.\n * @returns The value that results from running the \"reducer\" callback function\n * to completion over the entire array.\n * @signature\n *    reduce(fn, initialValue)(array)\n * @example\n *    pipe([1, 2, 3, 4, 5], reduce((acc, x) => acc + x, 100)) // => 115\n * @dataLast\n * @category Array\n */\nexport function reduce<T, U>(\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): (data: ReadonlyArray<T>) => U;\n\nexport function reduce(...args: ReadonlyArray<unknown>): unknown {\n  return curry(reduceImplementation, args);\n}\n\nfunction reduceImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (\n  previousValue: U,\n  currentValue: T,\n  currentIndex: number,\n  data: ReadonlyArray<T>,\n) => U, initialValue: U): U {\n  return data.reduce(callbackfn, initialValue);\n}\n"],"mappings":"kGAsEA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EAA2B,EAAwB,EAKpD,EAAoB,CAC1B,OAAO,EAAK,OAAO,EAAY,EAAa"}

package/dist/reduce.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t,n){return e.reduce(t,n)}export{t as reduce};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t,n){return e.reduce(t,n)}export{t as reduce};
 //# sourceMappingURL=reduce.js.map

package/dist/reduce.js.map

@@ -1 +1 @@
-{"version":3,"file":"reduce.js","names":[],"sources":["../src/reduce.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Executes a user-supplied \"reducer\" callback function on each element of the\n * array, in order, passing in the return value from the calculation on the\n * preceding element. The final result of running the reducer across all\n * elements of the array is a single value. Equivalent to\n * `Array.prototype.reduce`.\n *\n * @param data - The items to reduce.\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value becomes the value of the accumulator parameter on the next\n * invocation of callbackFn. For the last invocation, the return value becomes\n * the return value of reduce().\n * @param initialValue - A value to which accumulator is initialized the first\n * time the callback is called. CallbackFn starts executing with the first value\n * in the array as currentValue.\n * @returns The value that results from running the \"reducer\" callback function\n * to completion over the entire array.\n * @signature\n *    P.reduce(data, callbackfn, initialValue)\n * @example\n *    P.reduce([1, 2, 3, 4, 5], (acc, x) => acc + x, 100) // => 115\n * @dataFirst\n * @category Array\n */\nexport function reduce<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): U;\n\n/**\n * Executes a user-supplied \"reducer\" callback function on each element of the\n * array, in order, passing in the return value from the calculation on the\n * preceding element. The final result of running the reducer across all\n * elements of the array is a single value. Equivalent to\n * `Array.prototype.reduce`.\n *\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value becomes the value of the accumulator parameter on the next\n * invocation of callbackFn. For the last invocation, the return value becomes\n * the return value of reduce().\n * @param initialValue - A value to which accumulator is initialized the first\n * time the callback is called. CallbackFn starts executing with the first value\n * in the array as currentValue.\n * @returns The value that results from running the \"reducer\" callback function\n * to completion over the entire array.\n * @signature\n *    P.reduce(fn, initialValue)(array)\n * @example\n *    P.pipe([1, 2, 3, 4, 5], P.reduce((acc, x) => acc + x, 100)) // => 115\n * @dataLast\n * @category Array\n */\nexport function reduce<T, U>(\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): (data: ReadonlyArray<T>) => U;\n\nexport function reduce(...args: ReadonlyArray<unknown>): unknown {\n  return curry(reduceImplementation, args);\n}\n\nfunction reduceImplementation<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): U {\n  return data.reduce(callbackfn, initialValue);\n}\n"],"mappings":"wCAsEA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EAMA,EACG,CACH,OAAO,EAAK,OAAO,EAAY,EAAa"}
+{"version":3,"file":"reduce.js","names":[],"sources":["../src/reduce.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Executes a user-supplied \"reducer\" callback function on each element of the\n * array, in order, passing in the return value from the calculation on the\n * preceding element. The final result of running the reducer across all\n * elements of the array is a single value. Equivalent to\n * `Array.prototype.reduce`.\n *\n * @param data - The items to reduce.\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value becomes the value of the accumulator parameter on the next\n * invocation of callbackFn. For the last invocation, the return value becomes\n * the return value of reduce().\n * @param initialValue - A value to which accumulator is initialized the first\n * time the callback is called. CallbackFn starts executing with the first value\n * in the array as currentValue.\n * @returns The value that results from running the \"reducer\" callback function\n * to completion over the entire array.\n * @signature\n *    reduce(data, callbackfn, initialValue)\n * @example\n *    reduce([1, 2, 3, 4, 5], (acc, x) => acc + x, 100) // => 115\n * @dataFirst\n * @category Array\n */\nexport function reduce<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): U;\n\n/**\n * Executes a user-supplied \"reducer\" callback function on each element of the\n * array, in order, passing in the return value from the calculation on the\n * preceding element. The final result of running the reducer across all\n * elements of the array is a single value. Equivalent to\n * `Array.prototype.reduce`.\n *\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value becomes the value of the accumulator parameter on the next\n * invocation of callbackFn. For the last invocation, the return value becomes\n * the return value of reduce().\n * @param initialValue - A value to which accumulator is initialized the first\n * time the callback is called. CallbackFn starts executing with the first value\n * in the array as currentValue.\n * @returns The value that results from running the \"reducer\" callback function\n * to completion over the entire array.\n * @signature\n *    reduce(fn, initialValue)(array)\n * @example\n *    pipe([1, 2, 3, 4, 5], reduce((acc, x) => acc + x, 100)) // => 115\n * @dataLast\n * @category Array\n */\nexport function reduce<T, U>(\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): (data: ReadonlyArray<T>) => U;\n\nexport function reduce(...args: ReadonlyArray<unknown>): unknown {\n  return curry(reduceImplementation, args);\n}\n\nfunction reduceImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (\n  previousValue: U,\n  currentValue: T,\n  currentIndex: number,\n  data: ReadonlyArray<T>,\n) => U, initialValue: U): U {\n  return data.reduce(callbackfn, initialValue);\n}\n"],"mappings":"mCAsEA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAA2B,EAAwB,EAKpD,EAAoB,CAC1B,OAAO,EAAK,OAAO,EAAY,EAAa"}

package/dist/reverse.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){return[...e].reverse()}exports.reverse=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){return[...e].reverse()}exports.reverse=t;
+//# sourceMappingURL=reverse.cjs.map

package/dist/reverse.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.cjs","names":["curry"],"sources":["../src/reverse.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Reverse<\n  T extends ReadonlyArray<unknown>,\n  R extends ReadonlyArray<unknown> = [],\n> = ReturnType<\n  T extends IsNoTuple<T>\n    ? () => [...T, ...R]\n    : T extends readonly [infer F, ...infer L]\n      ? () => Reverse<L, [F, ...R]>\n      : () => R\n>;\n\ntype IsNoTuple<T> = T extends readonly [unknown, ...Array<unknown>] ? never : T;\n\n/**\n * Reverses array.\n *\n * @param array - The array.\n * @signature\n *    reverse(arr);\n * @example\n *    reverse([1, 2, 3]) // [3, 2, 1]\n * @dataFirst\n * @category Array\n */\nexport function reverse<T extends ReadonlyArray<unknown>>(array: T): Reverse<T>;\n\n/**\n * Reverses array.\n *\n * @signature\n *    reverse()(array);\n * @example\n *    reverse()([1, 2, 3]) // [3, 2, 1]\n * @dataLast\n * @category Array\n */\nexport function reverse<T extends ReadonlyArray<unknown>>(): (\n  array: T,\n) => Reverse<T>;\n\nexport function reverse(...args: ReadonlyArray<unknown>): unknown {\n  return curry(reverseImplementation, args);\n}\n\nfunction reverseImplementation<T>(array: ReadonlyArray<T>): Array<T> {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toReversed` here.\n\n  return [...array].reverse();\n}\n"],"mappings":"kGA0CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAmC,CAGnE,MAAO,CAAC,GAAG,EAAM,CAAC,SAAS"}

package/dist/reverse.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){return[...e].reverse()}export{t as reverse};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){return[...e].reverse()}export{t as reverse};
 //# sourceMappingURL=reverse.js.map

package/dist/reverse.js.map

@@ -1 +1 @@
-{"version":3,"file":"reverse.js","names":[],"sources":["../src/reverse.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Reverse<\n  T extends ReadonlyArray<unknown>,\n  R extends ReadonlyArray<unknown> = [],\n> = ReturnType<\n  T extends IsNoTuple<T>\n    ? () => [...T, ...R]\n    : T extends readonly [infer F, ...infer L]\n      ? () => Reverse<L, [F, ...R]>\n      : () => R\n>;\n\ntype IsNoTuple<T> = T extends readonly [unknown, ...Array<unknown>] ? never : T;\n\n/**\n * Reverses array.\n *\n * @param array - The array.\n * @signature\n *    P.reverse(arr);\n * @example\n *    P.reverse([1, 2, 3]) // [3, 2, 1]\n * @dataFirst\n * @category Array\n */\nexport function reverse<T extends ReadonlyArray<unknown>>(array: T): Reverse<T>;\n\n/**\n * Reverses array.\n *\n * @signature\n *    P.reverse()(array);\n * @example\n *    P.reverse()([1, 2, 3]) // [3, 2, 1]\n * @dataLast\n * @category Array\n */\nexport function reverse<T extends ReadonlyArray<unknown>>(): (\n  array: T,\n) => Reverse<T>;\n\nexport function reverse(...args: ReadonlyArray<unknown>): unknown {\n  return curry(reverseImplementation, args);\n}\n\nfunction reverseImplementation<T>(array: ReadonlyArray<T>): Array<T> {\n  // TODO: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toReversed` here.\n  return [...array].reverse();\n}\n"],"mappings":"wCA0CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAmC,CAEnE,MAAO,CAAC,GAAG,EAAM,CAAC,SAAS"}
+{"version":3,"file":"reverse.js","names":[],"sources":["../src/reverse.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Reverse<\n  T extends ReadonlyArray<unknown>,\n  R extends ReadonlyArray<unknown> = [],\n> = ReturnType<\n  T extends IsNoTuple<T>\n    ? () => [...T, ...R]\n    : T extends readonly [infer F, ...infer L]\n      ? () => Reverse<L, [F, ...R]>\n      : () => R\n>;\n\ntype IsNoTuple<T> = T extends readonly [unknown, ...Array<unknown>] ? never : T;\n\n/**\n * Reverses array.\n *\n * @param array - The array.\n * @signature\n *    reverse(arr);\n * @example\n *    reverse([1, 2, 3]) // [3, 2, 1]\n * @dataFirst\n * @category Array\n */\nexport function reverse<T extends ReadonlyArray<unknown>>(array: T): Reverse<T>;\n\n/**\n * Reverses array.\n *\n * @signature\n *    reverse()(array);\n * @example\n *    reverse()([1, 2, 3]) // [3, 2, 1]\n * @dataLast\n * @category Array\n */\nexport function reverse<T extends ReadonlyArray<unknown>>(): (\n  array: T,\n) => Reverse<T>;\n\nexport function reverse(...args: ReadonlyArray<unknown>): unknown {\n  return curry(reverseImplementation, args);\n}\n\nfunction reverseImplementation<T>(array: ReadonlyArray<T>): Array<T> {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toReversed` here.\n\n  return [...array].reverse();\n}\n"],"mappings":"mCA0CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAmC,CAGnE,MAAO,CAAC,GAAG,EAAM,CAAC,SAAS"}

package/dist/round.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./with-precision-dQAYLrgr.cjs`);function n(...n){return e.t(t.t(Math.round),n)}exports.round=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./with-precision-DVi9325n.cjs`);function n(...n){return e.curry(t.t(Math.round),n)}exports.round=n;
+//# sourceMappingURL=round.cjs.map

package/dist/round.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.cjs","names":["curry","withPrecision"],"sources":["../src/round.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds a given number to a specific precision.\n * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.round` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round.\n * @param precision - The precision to round to. Must be an integer between -15 and 15.\n * @signature\n *    round(value, precision);\n * @example\n *    round(123.9876, 3) // => 123.988\n *    round(483.22243, 1) // => 483.2\n *    round(8541, -1) // => 8540\n *    round(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function round(value: number, precision: number): number;\n\n/**\n * Rounds a given number to a specific precision.\n * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.round` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round to. Must be an integer between -15 and 15.\n * @signature\n *    round(precision)(value);\n * @example\n *    round(3)(123.9876) // => 123.988\n *    round(1)(483.22243) // => 483.2\n *    round(-1)(8541) // => 8540\n *    round(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function round(precision: number): (value: number) => number;\n\nexport function round(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.round), args);\n}\n"],"mappings":"6IAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAMC,EAAAA,EAAc,KAAK,MAAM,CAAE,EAAK"}

package/dist/round.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./with-precision-CQ90Walk.js";function n(...n){return e(t(Math.round),n)}export{n as round};
+import{curry as e}from"./curry.js";import{t}from"./with-precision-CgRuf7Wl.js";function n(...n){return e(t(Math.round),n)}export{n as round};
 //# sourceMappingURL=round.js.map

package/dist/round.js.map

@@ -1 +1 @@
-{"version":3,"file":"round.js","names":[],"sources":["../src/round.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds a given number to a specific precision.\n * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.round` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round.\n * @param precision - The precision to round to. Must be an integer between -15 and 15.\n * @signature\n *    P.round(value, precision);\n * @example\n *    P.round(123.9876, 3) // => 123.988\n *    P.round(483.22243, 1) // => 483.2\n *    P.round(8541, -1) // => 8540\n *    P.round(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function round(value: number, precision: number): number;\n\n/**\n * Rounds a given number to a specific precision.\n * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.round` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round to. Must be an integer between -15 and 15.\n * @signature\n *    P.round(precision)(value);\n * @example\n *    P.round(3)(123.9876) // => 123.988\n *    P.round(1)(483.22243) // => 483.2\n *    P.round(-1)(8541) // => 8540\n *    P.round(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function round(precision: number): (value: number) => number;\n\nexport function round(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.round), args);\n}\n"],"mappings":"oFAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAc,KAAK,MAAM,CAAE,EAAK"}
+{"version":3,"file":"round.js","names":[],"sources":["../src/round.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds a given number to a specific precision.\n * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.round` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round.\n * @param precision - The precision to round to. Must be an integer between -15 and 15.\n * @signature\n *    round(value, precision);\n * @example\n *    round(123.9876, 3) // => 123.988\n *    round(483.22243, 1) // => 483.2\n *    round(8541, -1) // => 8540\n *    round(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function round(value: number, precision: number): number;\n\n/**\n * Rounds a given number to a specific precision.\n * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.round` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round to. Must be an integer between -15 and 15.\n * @signature\n *    round(precision)(value);\n * @example\n *    round(3)(123.9876) // => 123.988\n *    round(1)(483.22243) // => 483.2\n *    round(-1)(8541) // => 8540\n *    round(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function round(precision: number): (value: number) => number;\n\nexport function round(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.round), args);\n}\n"],"mappings":"+EAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAc,KAAK,MAAM,CAAE,EAAK"}

package/dist/sample.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){if(t<=0)return[];if(t>=e.length)return[...e];let n=Math.min(t,e.length-t),r=new Set;for(;r.size<n;){let t=Math.floor(Math.random()*e.length);r.add(t)}return t===n?[...r].sort((e,t)=>e-t).map(t=>e[t]):e.filter((e,t)=>!r.has(t))}exports.sample=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(t<=0)return[];if(t>=e.length)return[...e];let n=Math.min(t,e.length-t),r=new Set;for(;r.size<n;){let t=Math.floor(Math.random()*e.length);r.add(t)}return t===n?[...r].sort((e,t)=>e-t).map(t=>e[t]):e.filter((e,t)=>!r.has(t))}exports.sample=t;
+//# sourceMappingURL=sample.cjs.map

package/dist/sample.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample.cjs","names":["curry"],"sources":["../src/sample.ts"],"sourcesContent":["import type {\n  FixedLengthArray,\n  IsEqual,\n  IsNever,\n  NonNegativeInteger,\n  Or,\n  Writable,\n} from 'type-fest';\nimport type { CoercedArray } from './internal/types/coerced-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NTuple } from './internal/types/n-tuple';\nimport type { PartialArray } from './internal/types/partial-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\ntype Sampled<T extends IterableContainer, N extends number>\n  = Or<IsEqual<N, 0>, IsEqual<T['length'], 0>> extends true\n    ? // Short-circuit on trivial inputs.\n      []\n    : IsNever<NonNegativeInteger<N>> extends true\n      ? SampledPrimitive<T>\n      : IsLongerThan<T, N> extends true\n        ? SampledLiteral<T, N>\n        : // If our tuple can never fulfil the sample size the only valid sample\n      // is the whole input tuple. Because it's a shallow clone we also\n      // strip any readonly-ness.\n        Writable<T>;\n\n/**\n * When N is not a non-negative integer **literal** we can't use it in our\n * reconstructing logic so we fallback to a simpler definition of the output of\n * sample, which is any sub-tuple shape of T, of **any length**.\n */\ntype SampledPrimitive<T extends IterableContainer> = [\n  ...FixedSubTuples<TupleParts<T>['required']>,\n  // TODO: This might be accurate, but We currently have no tests that check optional elements!\n  ...PartialArray<FixedSubTuples<TupleParts<T>['optional']>>,\n  ...CoercedArray<TupleParts<T>['item']>,\n  ...FixedSubTuples<TupleParts<T>['suffix']>,\n];\n\n/**\n * Knowing N is a non-negative literal integer we can construct all sub-tuples\n * of T that are exactly N elements long.\n */\ntype SampledLiteral<T extends IterableContainer, N extends number>\n  = | Extract<\n    FixedSubTuples<\n      [\n        ...TupleParts<T>['required'],\n        // TODO: This deliberately ignores optional elements which we don't have tests for either. In order to handle optional elements we can treat the \"optional\" tuple-part as more required elements.\n        // We add N elements of the `item` type to the tuple so that we\n        // consider any combination possible of elements of the prefix items,\n        // any amount of rest items, and suffix items.\n        ...(IsNever<TupleParts<T>['item']> extends true\n          ? []\n          : NTuple<TupleParts<T>['item'], N>),\n        ...TupleParts<T>['suffix'],\n      ]\n    >,\n    // This is just [unknown, unknown, ..., unknown] with N elements.\n    FixedLengthArray<unknown, N>\n  >\n  // In addition to all sub-tuples of length N, we also need to consider all\n  // tuples where the input is shorter than N. This will contribute exactly\n  // one sub-tuple at each length from the minimum length of T and up to N-1.\n  | SubSampled<\n    TupleParts<T>['required'],\n    // TODO: This deliberately ignores optional elements which we don't have tests for either. In order to handle optional elements we can treat the \"optional\" tuple-part as more required elements.\n    TupleParts<T>['item'],\n    TupleParts<T>['suffix'],\n    N\n  >;\n\n// We want to create a union of all sub-tuples where we incrementally add an\n// additional element of the type of the rest element in the middle between the\n// prefix and suffix until we \"fill\" the tuple to size N.\ntype SubSampled<\n  Prefix extends ReadonlyArray<unknown>,\n  Item,\n  Suffix extends ReadonlyArray<unknown>,\n  N extends number,\n>\n  = IsLongerThan<[...Prefix, ...Suffix], N> extends true\n    ? // We need to prevent overflows in case Prefix and Suffix are already long\n  // enough\n    never\n    : [...Prefix, ...Suffix]['length'] extends N\n        ? never\n        : [...Prefix, ...Suffix] | SubSampled<[...Prefix, Item], Item, Suffix, N>;\n\ntype IsLongerThan<T extends ReadonlyArray<unknown>, N extends number>\n  // Checking for `undefined` is a neat trick to avoid needing to compare\n  // integer literals because if N overflows the tuple then the type for that\n  // element will be `undefined`. This only works for fixed tuples!\n  = IsEqual<T[N], undefined> extends true ? false : true;\n\n// Assuming T is a fixed tuple we build all it's possible sub-tuples.\ntype FixedSubTuples<T> = T extends readonly [infer Head, ...infer Rest]\n  ? // For each element we either take it or skip it, and recurse over the rest.\n      FixedSubTuples<Rest> | [Head, ...FixedSubTuples<Rest>]\n  : [];\n\n/**\n * Returns a random subset of size `sampleSize` from `array`.\n *\n * Maintains and infers most of the typing information that could be passed\n * along to the output. This means that when using tuples, the output will be\n * a tuple too, and when using literals, those literals would be preserved.\n *\n * The items in the result are kept in the same order as they are in the input.\n * If you need to get a shuffled response you can pipe the shuffle function\n * after this one.\n *\n * @param data - The array.\n * @param sampleSize - The number of elements to take.\n * @signature\n *    sample(array, sampleSize)\n * @example\n *    sample([\"hello\", \"world\"], 1); // => [\"hello\"] // typed string[]\n *    sample([\"hello\", \"world\"] as const, 1); // => [\"world\"] // typed [\"hello\" | \"world\"]\n * @dataFirst\n * @category Array\n */\nexport function sample<const T extends IterableContainer, N extends number>(\n  data: T,\n  sampleSize: N,\n): Sampled<T, N>;\n\n/**\n * Returns a random subset of size `sampleSize` from `array`.\n *\n * Maintains and infers most of the typing information that could be passed\n * along to the output. This means that when using tuples, the output will be\n * a tuple too, and when using literals, those literals would be preserved.\n *\n * The items in the result are kept in the same order as they are in the input.\n * If you need to get a shuffled response you can pipe the shuffle function\n * after this one.\n *\n * @param sampleSize - The number of elements to take.\n * @signature\n *    sample(sampleSize)(array)\n * @example\n *    sample(1)([\"hello\", \"world\"]); // => [\"hello\"] // typed string[]\n *    sample(1)([\"hello\", \"world\"] as const); // => [\"world\"] // typed [\"hello\" | \"world\"]\n * @dataLast\n * @category Array\n */\nexport function sample<const T extends IterableContainer, N extends number>(\n  sampleSize: N,\n): (data: T) => Sampled<T, N>;\n\nexport function sample(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sampleImplementation, args);\n}\n\nfunction sampleImplementation<T>(data: ReadonlyArray<T>, sampleSize: number): Array<T> {\n  if (sampleSize <= 0) {\n    // Trivial\n    return [];\n  }\n\n  if (sampleSize >= data.length) {\n    // Trivial\n    return [...data];\n  }\n\n  // We have 2 modes of sampling, depending on the size of the sample requested.\n  // 1. If sampleSize is _small_, we generate indices that we then use to\n  // *EXTRACT* individual elements from the array.\n  // 2. If sampleSize is _large_, we instead generate indices to *EXCLUDE* from\n  // a full scan of the input array (via filtering).\n  //\n  // This allows us 2 optimizations that are the core of how this function\n  // works:\n  // 1. It is hard to generate a large number of unique indices, as the more\n  // indices we generate the more likely we are to generate one that is already\n  // in the set, which would require more iterations of the generation loop.\n  // Capping our effective sampleSize at n/2 would put an upper limit to the\n  // average number of iterations required (as a function of n).\n  // 2. If sample size is small enough, we never need to actually iterate over\n  // the full input array at all; instead we simply project the values we need\n  // via random access into the array. This means that for sampleSize (K) less\n  // than n/2, we run at O(klogk). For large sampleSize we need to iterate over\n  // the full input array, but we don't need to sort the indices because we can\n  // use the Set's 'has' method, so we effectively run at O(n).\n  const actualSampleSize = Math.min(sampleSize, data.length - sampleSize);\n\n  const sampleIndices = new Set<number>();\n  while (sampleIndices.size < actualSampleSize) {\n    const randomIndex = Math.floor(Math.random() * data.length);\n    sampleIndices.add(randomIndex);\n  }\n\n  if (sampleSize === actualSampleSize) {\n    return [...sampleIndices]\n      .sort((a, b) => a - b)\n      .map((index) => data[index]!);\n  }\n\n  return data.filter((_, index) => !sampleIndices.has(index));\n}\n"],"mappings":"kGAyJA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EAAwB,EAAwB,EAA8B,CACrF,GAAI,GAAc,EAEhB,MAAO,EAAE,CAGX,GAAI,GAAc,EAAK,OAErB,MAAO,CAAC,GAAG,EAAK,CAsBlB,IAAM,EAAmB,KAAK,IAAI,EAAY,EAAK,OAAS,EAAW,CAEjE,EAAgB,IAAI,IAC1B,KAAO,EAAc,KAAO,GAAkB,CAC5C,IAAM,EAAc,KAAK,MAAM,KAAK,QAAQ,CAAG,EAAK,OAAO,CAC3D,EAAc,IAAI,EAAY,CAShC,OANI,IAAe,EACV,CAAC,GAAG,EAAc,CACtB,MAAM,EAAG,IAAM,EAAI,EAAE,CACrB,IAAK,GAAU,EAAK,GAAQ,CAG1B,EAAK,QAAQ,EAAG,IAAU,CAAC,EAAc,IAAI,EAAM,CAAC"}

package/dist/sample.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){if(t<=0)return[];if(t>=e.length)return[...e];let n=Math.min(t,e.length-t),r=new Set;for(;r.size<n;){let t=Math.floor(Math.random()*e.length);r.add(t)}return t===n?[...r].sort((e,t)=>e-t).map(t=>e[t]):e.filter((e,t)=>!r.has(t))}export{t as sample};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){if(t<=0)return[];if(t>=e.length)return[...e];let n=Math.min(t,e.length-t),r=new Set;for(;r.size<n;){let t=Math.floor(Math.random()*e.length);r.add(t)}return t===n?[...r].sort((e,t)=>e-t).map(t=>e[t]):e.filter((e,t)=>!r.has(t))}export{t as sample};
 //# sourceMappingURL=sample.js.map