@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/sample.js.map

@@ -1 +1 @@
-{"version":3,"file":"sample.js","names":[],"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 * 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 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 *    P.sample(array, sampleSize)\n * @example\n *    P.sample([\"hello\", \"world\"], 1); // => [\"hello\"] // typed string[]\n *    P.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 = 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 *    P.sample(sampleSize)(array)\n * @example\n *    P.sample(1)([\"hello\", \"world\"]); // => [\"hello\"] // typed string[]\n *    P.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 = 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>(\n  data: ReadonlyArray<T>,\n  sampleSize: number,\n): 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":"wCAuJA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACU,CACV,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"}
+{"version":3,"file":"sample.js","names":[],"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":"mCAyJA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,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/set-path.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t,r){let[i,...a]=t;if(i===void 0)return r;if(Array.isArray(e)){let t=[...e];return t[i]=n(e[i],a,r),t}let{[i]:o,...s}=e;return{...s,[i]:n(o,a,r)}}exports.setPath=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,r){let[i,...a]=t;if(i===void 0)return r;if(Array.isArray(e)){let t=[...e];return t[i]=n(e[i],a,r),t}let{[i]:o,...s}=e;return{...s,[i]:n(o,a,r)}}exports.setPath=t;
+//# sourceMappingURL=set-path.cjs.map

package/dist/set-path.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-path.cjs","names":["curry"],"sources":["../src/set-path.ts"],"sourcesContent":["import type { ValueOf } from 'type-fest';\nimport type { PerkakasTypeError } from './internal/types/perkakas-type-error';\nimport { curry } from './curry';\n\ntype Paths<T, Prefix extends ReadonlyArray<unknown> = []>\n  = | Prefix\n    | (T extends object\n      ? ValueOf<{\n        [K in ProperKeyOf<T>]-?: Paths<T[K], [...Prefix, K]>;\n      }>\n      : PerkakasTypeError<\n        'setPath',\n        'Can only compute paths objects',\n        { type: never; metadata: T }\n      >) extends infer Path\n    ? // The Paths type is used to define the path param in `setPath`. In order\n    // for both mutable arrays and readonly arrays to be supported we need to\n    // make all results `readonly` (because mutable arrays extend readonly\n    // arrays, but not the other way around). Because the result of Paths is\n    // a union of arrays we need to distribute Result so that the operator is\n    // applied to each member separately.\n    Readonly<Path>\n    : never;\n\n/**\n * Array objects have all Array.prototype keys in their \"keyof\" type, which\n * is not what we'd expect from the operator. We only want the numeric keys\n * which represent proper elements of the array.\n */\ntype ProperKeyOf<T> = Extract<\n  keyof T,\n  T extends ReadonlyArray<unknown> ? number : keyof T\n>;\n\ntype ValueAtPath<T, Path> = Path extends readonly [\n  infer Head extends keyof T,\n  ...infer Rest,\n]\n  ? ValueAtPath<T[Head], Rest>\n  : T;\n\n/**\n * Sets the value at `path` of `object`.\n *\n * For simple cases where the path is only one level deep, prefer `set` instead.\n *\n * @param data - The target method.\n * @param path - The array of properties.\n * @param value - The value to set.\n * @signature\n *    setPath(obj, path, value)\n * @example\n *    setPath({ a: { b: 1 } }, ['a', 'b'], 2) // => { a: { b: 2 } }\n * @dataFirst\n * @category Object\n */\nexport function setPath<T, Path extends Paths<T>>(\n  data: T,\n  path: Path,\n  value: ValueAtPath<T, Path>,\n): T;\n\n/**\n * Sets the value at `path` of `object`.\n *\n * @param path - The array of properties.\n * @param value - The value to set.\n * @signature\n *    setPath(path, value)(obj)\n * @example\n *    pipe({ a: { b: 1 } }, setPath(['a', 'b'], 2)) // { a: { b: 2 } }\n * @dataLast\n * @category Object\n */\nexport function setPath<\n  T,\n  Path extends Paths<T>,\n  // TODO [>2] -- TODO: The following eslint is solvable by inlining Value and wrapping the T parameter with `NoInfer` (e.g. `ValueAtPath<NoInfer<T>, TPath>); to prevent typescript from inferring it as `unknown`. This is only available in TS 5.4, which is above what we currently support (5.1).\n  Value extends ValueAtPath<T, Path>,\n>(path: Path, value: Value): (data: T) => T;\n\nexport function setPath(...args: ReadonlyArray<unknown>): unknown {\n  return curry(setPathImplementation, args);\n}\n\nfunction setPathImplementation(\n  data: unknown,\n  path: ReadonlyArray<PropertyKey>,\n  value: unknown,\n): unknown {\n  const [pivot, ...rest] = path;\n  if (pivot === undefined) {\n    return value;\n  }\n\n  if (Array.isArray(data)) {\n    const copy = [...data];\n    copy[pivot as number] = setPathImplementation(\n      data[pivot as number],\n      rest,\n      value,\n    );\n    return copy;\n  }\n\n  const { [pivot]: currentValue, ...remaining } = data as Record<\n    PropertyKey,\n    unknown\n  >;\n\n  return {\n    ...remaining,\n    [pivot]: setPathImplementation(currentValue, rest, value),\n  };\n}\n"],"mappings":"kGAiFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACA,EACS,CACT,GAAM,CAAC,EAAO,GAAG,GAAQ,EACzB,GAAI,IAAU,IAAA,GACZ,OAAO,EAGT,GAAI,MAAM,QAAQ,EAAK,CAAE,CACvB,IAAM,EAAO,CAAC,GAAG,EAAK,CAMtB,MALA,GAAK,GAAmB,EACtB,EAAK,GACL,EACA,EACD,CACM,EAGT,GAAM,EAAG,GAAQ,EAAc,GAAG,GAAc,EAKhD,MAAO,CACL,GAAG,GACF,GAAQ,EAAsB,EAAc,EAAM,EAAM,CAC1D"}

package/dist/set-path.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t,r){let[i,...a]=t;if(i===void 0)return r;if(Array.isArray(e)){let t=[...e];return t[i]=n(e[i],a,r),t}let{[i]:o,...s}=e;return{...s,[i]:n(o,a,r)}}export{t as setPath};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t,r){let[i,...a]=t;if(i===void 0)return r;if(Array.isArray(e)){let t=[...e];return t[i]=n(e[i],a,r),t}let{[i]:o,...s}=e;return{...s,[i]:n(o,a,r)}}export{t as setPath};
 //# sourceMappingURL=set-path.js.map

package/dist/set-path.js.map

@@ -1 +1 @@
-{"version":3,"file":"set-path.js","names":[],"sources":["../src/set-path.ts"],"sourcesContent":["import type { ValueOf } from 'type-fest';\nimport type { PerkakasTypeError } from './internal/types/perkakas-type-error';\nimport { curry } from './curry';\n\ntype Paths<T, Prefix extends ReadonlyArray<unknown> = []>\n  = | Prefix\n    | (T extends object\n      ? ValueOf<{\n        [K in ProperKeyOf<T>]-?: Paths<T[K], [...Prefix, K]>;\n      }>\n      : PerkakasTypeError<\n          'setPath',\n          'Can only compute paths objects',\n          { type: never; metadata: T }\n        >) extends infer Path\n    // The Paths type is used to define the path param in `setPath`. In order\n    // for both mutable arrays and readonly arrays to be supported we need to\n    // make all results `readonly` (because mutable arrays extend readonly\n    // arrays, but not the other way around). Because the result of Paths is\n    // a union of arrays we need to distribute Result so that the operator is\n    // applied to each member separately.\n    ? Readonly<Path>\n    : never;\n\n/**\n * Array objects have all Array.prototype keys in their \"keyof\" type, which\n * is not what we'd expect from the operator. We only want the numeric keys\n * which represent proper elements of the array.\n */\ntype ProperKeyOf<T> = Extract<\n  keyof T,\n  T extends ReadonlyArray<unknown> ? number : keyof T\n>;\n\ntype ValueAtPath<T, Path> = Path extends readonly [\n  infer Head extends keyof T,\n  ...infer Rest,\n]\n  ? ValueAtPath<T[Head], Rest>\n  : T;\n\n/**\n * Sets the value at `path` of `object`.\n *\n * For simple cases where the path is only one level deep, prefer `set` instead.\n *\n * @param data - The target method.\n * @param path - The array of properties.\n * @param value - The value to set.\n * @signature\n *    P.setPath(obj, path, value)\n * @example\n *    P.setPath({ a: { b: 1 } }, ['a', 'b'], 2) // => { a: { b: 2 } }\n * @dataFirst\n * @category Object\n */\nexport function setPath<T, Path extends Paths<T>>(\n  data: T,\n  path: Path,\n  value: ValueAtPath<T, Path>,\n): T;\n\n/**\n * Sets the value at `path` of `object`.\n *\n * @param path - The array of properties.\n * @param value - The value to set.\n * @signature\n *    P.setPath(path, value)(obj)\n * @example\n *    P.pipe({ a: { b: 1 } }, P.setPath(['a', 'b'], 2)) // { a: { b: 2 } }\n * @dataLast\n * @category Object\n */\nexport function setPath<\n  T,\n  Path extends Paths<T>,\n  // TODO [>2] -- TODO: The following eslint is solvable by inlining Value and wrapping the T parameter with `NoInfer` (e.g. `ValueAtPath<NoInfer<T>, TPath>); to prevent typescript from inferring it as `unknown`. This is only available in TS 5.4, which is above what we currently support (5.1).\n  Value extends ValueAtPath<T, Path>,\n>(path: Path, value: Value): (data: T) => T;\n\nexport function setPath(...args: ReadonlyArray<unknown>): unknown {\n  return curry(setPathImplementation, args);\n}\n\nfunction setPathImplementation(\n  data: unknown,\n  path: ReadonlyArray<PropertyKey>,\n  value: unknown,\n): unknown {\n  const [pivot, ...rest] = path;\n  if (pivot === undefined) {\n    return value;\n  }\n\n  if (Array.isArray(data)) {\n    const copy = [...data];\n    copy[pivot as number] = setPathImplementation(\n      data[pivot as number],\n      rest,\n      value,\n    );\n    return copy;\n  }\n\n  const { [pivot]: currentValue, ...remaining } = data as Record<\n    PropertyKey,\n    unknown\n  >;\n\n  return {\n    ...remaining,\n    [pivot]: setPathImplementation(currentValue, rest, value),\n  };\n}\n"],"mappings":"wCAiFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACA,EACS,CACT,GAAM,CAAC,EAAO,GAAG,GAAQ,EACzB,GAAI,IAAU,IAAA,GACZ,OAAO,EAGT,GAAI,MAAM,QAAQ,EAAK,CAAE,CACvB,IAAM,EAAO,CAAC,GAAG,EAAK,CAMtB,MALA,GAAK,GAAmB,EACtB,EAAK,GACL,EACA,EACD,CACM,EAGT,GAAM,EAAG,GAAQ,EAAc,GAAG,GAAc,EAKhD,MAAO,CACL,GAAG,GACF,GAAQ,EAAsB,EAAc,EAAM,EAAM,CAC1D"}
+{"version":3,"file":"set-path.js","names":[],"sources":["../src/set-path.ts"],"sourcesContent":["import type { ValueOf } from 'type-fest';\nimport type { PerkakasTypeError } from './internal/types/perkakas-type-error';\nimport { curry } from './curry';\n\ntype Paths<T, Prefix extends ReadonlyArray<unknown> = []>\n  = | Prefix\n    | (T extends object\n      ? ValueOf<{\n        [K in ProperKeyOf<T>]-?: Paths<T[K], [...Prefix, K]>;\n      }>\n      : PerkakasTypeError<\n        'setPath',\n        'Can only compute paths objects',\n        { type: never; metadata: T }\n      >) extends infer Path\n    ? // The Paths type is used to define the path param in `setPath`. In order\n    // for both mutable arrays and readonly arrays to be supported we need to\n    // make all results `readonly` (because mutable arrays extend readonly\n    // arrays, but not the other way around). Because the result of Paths is\n    // a union of arrays we need to distribute Result so that the operator is\n    // applied to each member separately.\n    Readonly<Path>\n    : never;\n\n/**\n * Array objects have all Array.prototype keys in their \"keyof\" type, which\n * is not what we'd expect from the operator. We only want the numeric keys\n * which represent proper elements of the array.\n */\ntype ProperKeyOf<T> = Extract<\n  keyof T,\n  T extends ReadonlyArray<unknown> ? number : keyof T\n>;\n\ntype ValueAtPath<T, Path> = Path extends readonly [\n  infer Head extends keyof T,\n  ...infer Rest,\n]\n  ? ValueAtPath<T[Head], Rest>\n  : T;\n\n/**\n * Sets the value at `path` of `object`.\n *\n * For simple cases where the path is only one level deep, prefer `set` instead.\n *\n * @param data - The target method.\n * @param path - The array of properties.\n * @param value - The value to set.\n * @signature\n *    setPath(obj, path, value)\n * @example\n *    setPath({ a: { b: 1 } }, ['a', 'b'], 2) // => { a: { b: 2 } }\n * @dataFirst\n * @category Object\n */\nexport function setPath<T, Path extends Paths<T>>(\n  data: T,\n  path: Path,\n  value: ValueAtPath<T, Path>,\n): T;\n\n/**\n * Sets the value at `path` of `object`.\n *\n * @param path - The array of properties.\n * @param value - The value to set.\n * @signature\n *    setPath(path, value)(obj)\n * @example\n *    pipe({ a: { b: 1 } }, setPath(['a', 'b'], 2)) // { a: { b: 2 } }\n * @dataLast\n * @category Object\n */\nexport function setPath<\n  T,\n  Path extends Paths<T>,\n  // TODO [>2] -- TODO: The following eslint is solvable by inlining Value and wrapping the T parameter with `NoInfer` (e.g. `ValueAtPath<NoInfer<T>, TPath>); to prevent typescript from inferring it as `unknown`. This is only available in TS 5.4, which is above what we currently support (5.1).\n  Value extends ValueAtPath<T, Path>,\n>(path: Path, value: Value): (data: T) => T;\n\nexport function setPath(...args: ReadonlyArray<unknown>): unknown {\n  return curry(setPathImplementation, args);\n}\n\nfunction setPathImplementation(\n  data: unknown,\n  path: ReadonlyArray<PropertyKey>,\n  value: unknown,\n): unknown {\n  const [pivot, ...rest] = path;\n  if (pivot === undefined) {\n    return value;\n  }\n\n  if (Array.isArray(data)) {\n    const copy = [...data];\n    copy[pivot as number] = setPathImplementation(\n      data[pivot as number],\n      rest,\n      value,\n    );\n    return copy;\n  }\n\n  const { [pivot]: currentValue, ...remaining } = data as Record<\n    PropertyKey,\n    unknown\n  >;\n\n  return {\n    ...remaining,\n    [pivot]: setPathImplementation(currentValue, rest, value),\n  };\n}\n"],"mappings":"mCAiFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACA,EACS,CACT,GAAM,CAAC,EAAO,GAAG,GAAQ,EACzB,GAAI,IAAU,IAAA,GACZ,OAAO,EAGT,GAAI,MAAM,QAAQ,EAAK,CAAE,CACvB,IAAM,EAAO,CAAC,GAAG,EAAK,CAMtB,MALA,GAAK,GAAmB,EACtB,EAAK,GACL,EACA,EACD,CACM,EAGT,GAAM,EAAG,GAAQ,EAAc,GAAG,GAAc,EAKhD,MAAO,CACL,GAAG,GACF,GAAQ,EAAsB,EAAc,EAAM,EAAM,CAC1D"}

package/dist/set.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,[t]:n}}exports.set=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,[t]:n}}exports.set=t;
+//# sourceMappingURL=set.cjs.map

package/dist/set.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.cjs","names":["curry"],"sources":["../src/set.ts"],"sourcesContent":["import type { UpsertProp } from './internal/types/upsert-prop';\nimport { curry } from './curry';\n\n/**\n * Sets the `value` at `prop` of `object`.\n *\n * To add a new property to an object, or to override its type, use `addProp`\n * instead, and to set a property within a nested object use `setPath`.\n *\n * @param obj - The target method.\n * @param prop - The property name.\n * @param value - The value to set.\n * @signature\n *    set(obj, prop, value)\n * @example\n *    set({ a: 1 }, 'a', 2) // => { a: 2 }\n * @dataFirst\n * @category Object\n */\nexport function set<T, K extends keyof T, V extends Required<T>[K]>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V>;\n\n/**\n * Sets the `value` at `prop` of `object`.\n *\n * To add a new property to an object, or to override it's type use `addProp`\n * instead.\n *\n * @param prop - The property name.\n * @param value - The value to set.\n * @signature\n *    set(prop, value)(obj)\n * @example\n *    pipe({ a: 1 }, set('a', 2)) // => { a: 2 }\n * @dataLast\n * @category Object\n */\nexport function set<T, K extends keyof T, V extends Required<T>[K]>(\n  prop: K,\n  value: V,\n): (obj: T) => UpsertProp<T, K, V>;\n\nexport function set(...args: ReadonlyArray<unknown>): unknown {\n  return curry(setImplementation, args);\n}\n\nfunction setImplementation<T, K extends keyof T, V extends Required<T>[K]>(obj: T, prop: K, value: V): UpsertProp<T, K, V> {\n  return { ...obj, [prop]: value };\n}\n"],"mappings":"kGA6CA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAOA,EAAAA,MAAM,EAAmB,EAAK,CAGvC,SAAS,EAAkE,EAAQ,EAAS,EAA+B,CACzH,MAAO,CAAE,GAAG,GAAM,GAAO,EAAO"}

package/dist/set.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,[t]:n}}export{t as set};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t,n){return{...e,[t]:n}}export{t as set};
 //# sourceMappingURL=set.js.map

package/dist/set.js.map

@@ -1 +1 @@
-{"version":3,"file":"set.js","names":[],"sources":["../src/set.ts"],"sourcesContent":["import type { UpsertProp } from './internal/types/upsert-prop';\n\nimport { curry } from './curry';\n\n/**\n * Sets the `value` at `prop` of `object`.\n *\n * To add a new property to an object, or to override its type, use `addProp`\n * instead, and to set a property within a nested object use `setPath`.\n *\n * @param obj - The target method.\n * @param prop - The property name.\n * @param value - The value to set.\n * @signature\n *    P.set(obj, prop, value)\n * @example\n *    P.set({ a: 1 }, 'a', 2) // => { a: 2 }\n * @dataFirst\n * @category Object\n */\nexport function set<T, K extends keyof T, V extends Required<T>[K]>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V>;\n\n/**\n * Sets the `value` at `prop` of `object`.\n *\n * To add a new property to an object, or to override it's type use `addProp`\n * instead.\n *\n * @param prop - The property name.\n * @param value - The value to set.\n * @signature\n *    P.set(prop, value)(obj)\n * @example\n *    P.pipe({ a: 1 }, P.set('a', 2)) // => { a: 2 }\n * @dataLast\n * @category Object\n */\nexport function set<T, K extends keyof T, V extends Required<T>[K]>(\n  prop: K,\n  value: V,\n): (obj: T) => UpsertProp<T, K, V>;\n\nexport function set(...args: ReadonlyArray<unknown>): unknown {\n  return curry(setImplementation, args);\n}\n\nfunction setImplementation<T, K extends keyof T, V extends Required<T>[K]>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V> {\n  // @ts-expect-error [ts2322] - Hard to type this function\n  return ({ ...obj, [prop]: value });\n}\n"],"mappings":"wCA8CA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EACP,EACA,EACA,EACqB,CAErB,MAAQ,CAAE,GAAG,GAAM,GAAO,EAAO"}
+{"version":3,"file":"set.js","names":[],"sources":["../src/set.ts"],"sourcesContent":["import type { UpsertProp } from './internal/types/upsert-prop';\nimport { curry } from './curry';\n\n/**\n * Sets the `value` at `prop` of `object`.\n *\n * To add a new property to an object, or to override its type, use `addProp`\n * instead, and to set a property within a nested object use `setPath`.\n *\n * @param obj - The target method.\n * @param prop - The property name.\n * @param value - The value to set.\n * @signature\n *    set(obj, prop, value)\n * @example\n *    set({ a: 1 }, 'a', 2) // => { a: 2 }\n * @dataFirst\n * @category Object\n */\nexport function set<T, K extends keyof T, V extends Required<T>[K]>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V>;\n\n/**\n * Sets the `value` at `prop` of `object`.\n *\n * To add a new property to an object, or to override it's type use `addProp`\n * instead.\n *\n * @param prop - The property name.\n * @param value - The value to set.\n * @signature\n *    set(prop, value)(obj)\n * @example\n *    pipe({ a: 1 }, set('a', 2)) // => { a: 2 }\n * @dataLast\n * @category Object\n */\nexport function set<T, K extends keyof T, V extends Required<T>[K]>(\n  prop: K,\n  value: V,\n): (obj: T) => UpsertProp<T, K, V>;\n\nexport function set(...args: ReadonlyArray<unknown>): unknown {\n  return curry(setImplementation, args);\n}\n\nfunction setImplementation<T, K extends keyof T, V extends Required<T>[K]>(obj: T, prop: K, value: V): UpsertProp<T, K, V> {\n  return { ...obj, [prop]: value };\n}\n"],"mappings":"mCA6CA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EAAkE,EAAQ,EAAS,EAA+B,CACzH,MAAO,CAAE,GAAG,GAAM,GAAO,EAAO"}

package/dist/shuffle.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){let t=[...e];for(let n=0;n<e.length;n++){let r=n+Math.floor(Math.random()*(e.length-n)),i=t[r];t[r]=t[n],t[n]=i}return t}exports.shuffle=t;
+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=[...e];for(let n=0;n<e.length;n++){let r=n+Math.floor(Math.random()*(e.length-n)),i=t[r];t[r]=t[n],t[n]=i}return t}exports.shuffle=t;
+//# sourceMappingURL=shuffle.cjs.map

package/dist/shuffle.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shuffle.cjs","names":["curry"],"sources":["../src/shuffle.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curry } from './curry';\n\n/**\n * Shuffles the input array, returning a new array with the same elements in a random order.\n *\n * @param items - The array to shuffle.\n * @signature\n *    shuffle(array)\n * @example\n *    shuffle([4, 2, 7, 5]) // => [7, 5, 4, 2]\n * @dataFirst\n * @category Array\n */\nexport function shuffle<T extends IterableContainer>(\n  items: T,\n): ReorderedArray<T>;\n\n/**\n * Shuffles the input array, returning a new array with the same elements in a random order.\n *\n * @signature\n *    shuffle()(array)\n * @example\n *    pipe([4, 2, 7, 5], shuffle()) // => [7, 5, 4, 2]\n * @dataLast\n * @category Array\n */\nexport function shuffle(): <T extends IterableContainer>(\n  items: T,\n) => ReorderedArray<T>;\n\nexport function shuffle(...args: ReadonlyArray<unknown>): unknown {\n  return curry(shuffleImplementation, args);\n}\n\nfunction shuffleImplementation<T>(items: ReadonlyArray<T>): Array<T> {\n  const result = [...items];\n  for (let index = 0; index < items.length; index++) {\n    const rand = index + Math.floor(Math.random() * (items.length - index));\n    const value = result[rand]!;\n    result[rand] = result[index]!;\n    result[index] = value;\n  }\n  return result;\n}\n"],"mappings":"kGAiCA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAmC,CACnE,IAAM,EAAS,CAAC,GAAG,EAAM,CACzB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAM,OAAQ,IAAS,CACjD,IAAM,EAAO,EAAQ,KAAK,MAAM,KAAK,QAAQ,EAAI,EAAM,OAAS,GAAO,CACjE,EAAQ,EAAO,GACrB,EAAO,GAAQ,EAAO,GACtB,EAAO,GAAS,EAElB,OAAO"}

package/dist/shuffle.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=[...e];for(let n=0;n<e.length;n++){let r=n+Math.floor(Math.random()*(e.length-n)),i=t[r];t[r]=t[n],t[n]=i}return t}export{t as shuffle};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){let t=[...e];for(let n=0;n<e.length;n++){let r=n+Math.floor(Math.random()*(e.length-n)),i=t[r];t[r]=t[n],t[n]=i}return t}export{t as shuffle};
 //# sourceMappingURL=shuffle.js.map

package/dist/shuffle.js.map

@@ -1 +1 @@
-{"version":3,"file":"shuffle.js","names":[],"sources":["../src/shuffle.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { ReorderedArray } from './internal/types/reordered-array';\n\nimport { curry } from './curry';\n\n/**\n * Shuffles the input array, returning a new array with the same elements in a random order.\n *\n * @param items - The array to shuffle.\n * @signature\n *    P.shuffle(array)\n * @example\n *    P.shuffle([4, 2, 7, 5]) // => [7, 5, 4, 2]\n * @dataFirst\n * @category Array\n */\nexport function shuffle<T extends IterableContainer>(\n  items: T,\n): ReorderedArray<T>;\n\n/**\n * Shuffles the input array, returning a new array with the same elements in a random order.\n *\n * @signature\n *    P.shuffle()(array)\n * @example\n *    P.pipe([4, 2, 7, 5], P.shuffle()) // => [7, 5, 4, 2]\n * @dataLast\n * @category Array\n */\nexport function shuffle(): <T extends IterableContainer>(\n  items: T,\n) => ReorderedArray<T>;\n\nexport function shuffle(...args: ReadonlyArray<unknown>): unknown {\n  return curry(shuffleImplementation, args);\n}\n\nfunction shuffleImplementation<T>(items: ReadonlyArray<T>): Array<T> {\n  const result = [...items];\n  for (let index = 0; index < items.length; index++) {\n    const rand = index + Math.floor(Math.random() * (items.length - index));\n    const value = result[rand]!;\n    result[rand] = result[index]!;\n    result[index] = value;\n  }\n  return result;\n}\n"],"mappings":"wCAkCA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAmC,CACnE,IAAM,EAAS,CAAC,GAAG,EAAM,CACzB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAM,OAAQ,IAAS,CACjD,IAAM,EAAO,EAAQ,KAAK,MAAM,KAAK,QAAQ,EAAI,EAAM,OAAS,GAAO,CACjE,EAAQ,EAAO,GACrB,EAAO,GAAQ,EAAO,GACtB,EAAO,GAAS,EAElB,OAAO"}
+{"version":3,"file":"shuffle.js","names":[],"sources":["../src/shuffle.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curry } from './curry';\n\n/**\n * Shuffles the input array, returning a new array with the same elements in a random order.\n *\n * @param items - The array to shuffle.\n * @signature\n *    shuffle(array)\n * @example\n *    shuffle([4, 2, 7, 5]) // => [7, 5, 4, 2]\n * @dataFirst\n * @category Array\n */\nexport function shuffle<T extends IterableContainer>(\n  items: T,\n): ReorderedArray<T>;\n\n/**\n * Shuffles the input array, returning a new array with the same elements in a random order.\n *\n * @signature\n *    shuffle()(array)\n * @example\n *    pipe([4, 2, 7, 5], shuffle()) // => [7, 5, 4, 2]\n * @dataLast\n * @category Array\n */\nexport function shuffle(): <T extends IterableContainer>(\n  items: T,\n) => ReorderedArray<T>;\n\nexport function shuffle(...args: ReadonlyArray<unknown>): unknown {\n  return curry(shuffleImplementation, args);\n}\n\nfunction shuffleImplementation<T>(items: ReadonlyArray<T>): Array<T> {\n  const result = [...items];\n  for (let index = 0; index < items.length; index++) {\n    const rand = index + Math.floor(Math.random() * (items.length - index));\n    const value = result[rand]!;\n    result[rand] = result[index]!;\n    result[index] = value;\n  }\n  return result;\n}\n"],"mappings":"mCAiCA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAmC,CACnE,IAAM,EAAS,CAAC,GAAG,EAAM,CACzB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAM,OAAQ,IAAS,CACjD,IAAM,EAAO,EAAQ,KAAK,MAAM,KAAK,QAAQ,EAAI,EAAM,OAAS,GAAO,CACjE,EAAQ,EAAO,GACrB,EAAO,GAAQ,EAAO,GACtB,EAAO,GAAS,EAElB,OAAO"}

package/dist/sleep.cjs

@@ -1 +1,2 @@
-function e(e){return new Promise(t=>{setTimeout(t,e)})}exports.sleep=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return new Promise(t=>{setTimeout(t,e)})}exports.sleep=e;
+//# sourceMappingURL=sleep.cjs.map

package/dist/sleep.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.cjs","names":[],"sources":["../src/sleep.ts"],"sourcesContent":["/**\n * Delay execution for a given number of milliseconds.\n *\n * @param timeout the number of milliseconds to wait\n *\n * @signature\n *  P.sleep(timeout)\n * @example\n *  P.sleep(1000); // => Promise<void>\n * @category Function\n */\nexport function sleep(timeout: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeout);\n  });\n}\n"],"mappings":"mEAWA,SAAgB,EAAM,EAAgC,CACpD,OAAO,IAAI,QAAS,GAAY,CAC9B,WAAW,EAAS,EAAQ,EAC5B"}

package/dist/slice-string.cjs

@@ -1 +1,2 @@
-function e(e,t,n){return typeof e==`string`?e.slice(t,n):n=>n.slice(e,t)}exports.sliceString=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,t,n){return typeof e==`string`?e.slice(t,n):n=>n.slice(e,t)}exports.sliceString=e;
+//# sourceMappingURL=slice-string.cjs.map

package/dist/slice-string.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice-string.cjs","names":[],"sources":["../src/slice-string.ts"],"sourcesContent":["/* eslint-disable sonar/argument-type */\n/**\n * Extracts a section of a string between two indices.\n *\n * This function is a wrapper around the built-in [`String.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice)\n * method.\n *\n * @param data - The string to extract from.\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    sliceString(data, indexStart, indexEnd)\n * @example\n *    sliceString(\"abcdefghijkl\", 1) // => `bcdefghijkl`\n *    sliceString(\"abcdefghijkl\", 4, 7) // => `efg`\n * @dataFirst\n * @category String\n */\nexport function sliceString(\n  data: string,\n  indexStart: number,\n  indexEnd?: number,\n): string;\n\n/**\n * Extracts a section of a string between two indices.\n *\n * This function is a wrapper around the built-in [`String.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice)\n * method.\n *\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring, or `undefined` for the rest of the string.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    sliceString(indexStart, indexEnd)(string)\n * @example\n *    sliceString(1)(\"abcdefghijkl\") // => `bcdefghijkl`\n *    sliceString(4, 7)(\"abcdefghijkl\") // => `efg`\n * @dataLast\n * @category String\n */\nexport function sliceString(\n  indexStart: number,\n  indexEnd?: number,\n): (data: string) => string;\n\nexport function sliceString(\n  dataOrIndexStart: number | string,\n  indexStartOrIndexEnd?: number,\n  indexEnd?: number,\n): unknown {\n  return typeof dataOrIndexStart === 'string'\n    ? dataOrIndexStart.slice(indexStartOrIndexEnd, indexEnd)\n    : (data: string) => data.slice(dataOrIndexStart, indexStartOrIndexEnd);\n}\n"],"mappings":"mEAmDA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,SAC/B,EAAiB,MAAM,EAAsB,EAAS,CACrD,GAAiB,EAAK,MAAM,EAAkB,EAAqB"}

package/dist/slice-string.js.map

@@ -1 +1 @@
-{"version":3,"file":"slice-string.js","names":[],"sources":["../src/slice-string.ts"],"sourcesContent":["/**\n * Extracts a section of this string and returns it as a new string, without\n * modifying the original string. Equivalent to `String.prototype.slice`.\n *\n * @param data - The string to extract from.\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    P.sliceString(data, indexStart, indexEnd)\n * @example\n *    P.sliceString(\"abcdefghijkl\", 1) // => `bcdefghijkl`\n *    P.sliceString(\"abcdefghijkl\", 4, 7) // => `efg`\n * @dataLast\n * @category String\n */\nexport function sliceString(\n  data: string,\n  indexStart: number,\n  indexEnd?: number,\n): string;\n\n/**\n * Extracts a section of this string and returns it as a new string, without\n * modifying the original string. Equivalent to `String.prototype.slice`.\n *\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring, or `undefined` for the rest of the string.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    P.sliceString(indexStart, indexEnd)(string)\n * @example\n *    P.sliceString(1)(\"abcdefghijkl\") // => `bcdefghijkl`\n *    P.sliceString(4, 7)(\"abcdefghijkl\") // => `efg`\n * @dataLast\n * @category String\n */\nexport function sliceString(\n  indexStart: number,\n  indexEnd?: number,\n): (data: string) => string;\n\nexport function sliceString(\n  dataOrIndexStart: number | string,\n  indexStartOrIndexEnd?: number,\n  indexEnd?: number,\n): unknown {\n  return typeof dataOrIndexStart === 'string'\n    ? dataOrIndexStart.slice(indexStartOrIndexEnd, indexEnd)\n    : (data: string) => data.slice(dataOrIndexStart, indexStartOrIndexEnd);\n}\n"],"mappings":"AA8CA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,SAC/B,EAAiB,MAAM,EAAsB,EAAS,CACrD,GAAiB,EAAK,MAAM,EAAkB,EAAqB"}
+{"version":3,"file":"slice-string.js","names":[],"sources":["../src/slice-string.ts"],"sourcesContent":["/* eslint-disable sonar/argument-type */\n/**\n * Extracts a section of a string between two indices.\n *\n * This function is a wrapper around the built-in [`String.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice)\n * method.\n *\n * @param data - The string to extract from.\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    sliceString(data, indexStart, indexEnd)\n * @example\n *    sliceString(\"abcdefghijkl\", 1) // => `bcdefghijkl`\n *    sliceString(\"abcdefghijkl\", 4, 7) // => `efg`\n * @dataFirst\n * @category String\n */\nexport function sliceString(\n  data: string,\n  indexStart: number,\n  indexEnd?: number,\n): string;\n\n/**\n * Extracts a section of a string between two indices.\n *\n * This function is a wrapper around the built-in [`String.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice)\n * method.\n *\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring, or `undefined` for the rest of the string.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    sliceString(indexStart, indexEnd)(string)\n * @example\n *    sliceString(1)(\"abcdefghijkl\") // => `bcdefghijkl`\n *    sliceString(4, 7)(\"abcdefghijkl\") // => `efg`\n * @dataLast\n * @category String\n */\nexport function sliceString(\n  indexStart: number,\n  indexEnd?: number,\n): (data: string) => string;\n\nexport function sliceString(\n  dataOrIndexStart: number | string,\n  indexStartOrIndexEnd?: number,\n  indexEnd?: number,\n): unknown {\n  return typeof dataOrIndexStart === 'string'\n    ? dataOrIndexStart.slice(indexStartOrIndexEnd, indexEnd)\n    : (data: string) => data.slice(dataOrIndexStart, indexStartOrIndexEnd);\n}\n"],"mappings":"AAmDA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,SAC/B,EAAiB,MAAM,EAAsB,EAAS,CACrD,GAAiB,EAAK,MAAM,EAAkB,EAAqB"}

package/dist/slugify.cjs

@@ -1 +1,2 @@
-function e(e){return e.normalize(`NFD`).replace(/[\u0300-\u036F]/g,``).toLowerCase().replace(/[^a-z0-9]/g,` `).trim().replace(/\s+/g,`-`)}exports.slugify=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return e.normalize(`NFD`).replace(/[\u0300-\u036F]/g,``).toLowerCase().replace(/[^a-z0-9]/g,` `).trim().replace(/\s+/g,`-`)}exports.slugify=e;
+//# sourceMappingURL=slugify.cjs.map

package/dist/slugify.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"slugify.cjs","names":[],"sources":["../src/slugify.ts"],"sourcesContent":["/**\n * Turn any string into a URL/DOM safe string.\n * @param str the string to slugify\n * @signature\n *  P.slugify(str)\n * @example\n *  P.slugify('FooBar'); // => 'foobar'\n *  P.slugify('This!-is*&%#@^up!'); // => 'this-is-up'\n * @category String\n */\nexport function slugify(str: string): string {\n  return str\n    .normalize('NFD')\n    .replace(/[\\u0300-\\u036F]/g, '')\n    .toLowerCase()\n    .replace(/[^a-z0-9]/g, ' ')\n    .trim()\n    .replace(/\\s+/g, '-');\n}\n"],"mappings":"mEAUA,SAAgB,EAAQ,EAAqB,CAC3C,OAAO,EACJ,UAAU,MAAM,CAChB,QAAQ,mBAAoB,GAAG,CAC/B,aAAa,CACb,QAAQ,aAAc,IAAI,CAC1B,MAAM,CACN,QAAQ,OAAQ,IAAI"}

package/dist/sort-by.cjs

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

package/dist/sort-by.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-by.cjs","names":["curryOrderRules"],"sources":["../src/sort-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    sortBy(...rules)(data)\n * @example\n *    pipe(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      sortBy(prop('a')),\n *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n * @dataLast\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (array: T) => ReorderedArray<T>;\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param array - The input array.\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    sortBy(data, ...rules)\n * @example\n *    sortBy(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      prop('a'),\n *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n *    sortBy(\n *      [\n *        {color: 'red', weight: 2},\n *        {color: 'blue', weight: 3},\n *        {color: 'green', weight: 1},\n *        {color: 'purple', weight: 1},\n *      ],\n *      [prop('weight'), 'asc'],\n *      prop('color'),\n *    ); // => [\n *    //   {color: 'green', weight: 1},\n *    //   {color: 'purple', weight: 1},\n *    //   {color: 'red', weight: 2},\n *    //   {color: 'blue', weight: 3},\n *    // ]\n * @dataFirst\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  array: T,\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): ReorderedArray<T>;\n\nexport function sortBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(sortByImplementation, args);\n}\n\nfunction sortByImplementation<T>(data: ReadonlyArray<T>, compareFn: CompareFunction<T>): Array<T> {\n  return [...data].sort(compareFn);\n}\n"],"mappings":"uHA4FA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,EAAgB,EAAsB,EAAK,CAGpD,SAAS,EAAwB,EAAwB,EAAyC,CAChG,MAAO,CAAC,GAAG,EAAK,CAAC,KAAK,EAAU"}

package/dist/sort-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-order-rules-DwrF-_P1.js";function t(...t){return e(n,t)}function n(e,t){return[...e].sort(t)}export{t as sortBy};
+import{t as e}from"./curry-order-rules-BLyCSMdZ.js";function t(...t){return e(n,t)}function n(e,t){return[...e].sort(t)}export{t as sortBy};
 //# sourceMappingURL=sort-by.js.map

package/dist/sort-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"sort-by.js","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    P.sortBy(...rules)(data)\n * @example\n *    P.pipe(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      P.sortBy(P.prop('a')),\n *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n * @dataLast\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (array: T) => ReorderedArray<T>;\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param array - The input array.\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    P.sortBy(data, ...rules)\n * @example\n *    P.sortBy(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      prop('a'),\n *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n *    P.sortBy(\n *      [\n *        {color: 'red', weight: 2},\n *        {color: 'blue', weight: 3},\n *        {color: 'green', weight: 1},\n *        {color: 'purple', weight: 1},\n *      ],\n *      [prop('weight'), 'asc'],\n *      prop('color'),\n *    ); // => [\n *    //   {color: 'green', weight: 1},\n *    //   {color: 'purple', weight: 1},\n *    //   {color: 'red', weight: 2},\n *    //   {color: 'blue', weight: 3},\n *    // ]\n * @dataFirst\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  array: T,\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): ReorderedArray<T>;\n\nexport function sortBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(sortByImplementation, args);\n}\n\nfunction sortByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): Array<T> {\n  // TODO: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toSorted` here.\n  return [...data].sort(compareFn);\n}\n"],"mappings":"oDA4FA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAgB,EAAsB,EAAK,CAGpD,SAAS,EACP,EACA,EACU,CAEV,MAAO,CAAC,GAAG,EAAK,CAAC,KAAK,EAAU"}
+{"version":3,"file":"sort-by.js","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    sortBy(...rules)(data)\n * @example\n *    pipe(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      sortBy(prop('a')),\n *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n * @dataLast\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (array: T) => ReorderedArray<T>;\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param array - The input array.\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    sortBy(data, ...rules)\n * @example\n *    sortBy(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      prop('a'),\n *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n *    sortBy(\n *      [\n *        {color: 'red', weight: 2},\n *        {color: 'blue', weight: 3},\n *        {color: 'green', weight: 1},\n *        {color: 'purple', weight: 1},\n *      ],\n *      [prop('weight'), 'asc'],\n *      prop('color'),\n *    ); // => [\n *    //   {color: 'green', weight: 1},\n *    //   {color: 'purple', weight: 1},\n *    //   {color: 'red', weight: 2},\n *    //   {color: 'blue', weight: 3},\n *    // ]\n * @dataFirst\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  array: T,\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): ReorderedArray<T>;\n\nexport function sortBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(sortByImplementation, args);\n}\n\nfunction sortByImplementation<T>(data: ReadonlyArray<T>, compareFn: CompareFunction<T>): Array<T> {\n  return [...data].sort(compareFn);\n}\n"],"mappings":"oDA4FA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAgB,EAAsB,EAAK,CAGpD,SAAS,EAAwB,EAAwB,EAAyC,CAChG,MAAO,CAAC,GAAG,EAAK,CAAC,KAAK,EAAU"}

package/dist/sort.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n=[...e];return n.sort(t),n}exports.sort=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=[...e];return n.sort(t),n}exports.sort=t;
+//# sourceMappingURL=sort.cjs.map

package/dist/sort.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.cjs","names":["curry"],"sources":["../src/sort.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curry } from './curry';\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param items - The array to sort.\n * @param cmp - The comparator function.\n * @signature\n *    sort(items, cmp)\n * @example\n *    sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]\n * @dataFirst\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T>;\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param cmp - The comparator function.\n * @signature\n *    sort(cmp)(items)\n * @example\n *    pipe([4, 2, 7, 5], sort((a, b) => a - b)) // => [2, 4, 5, 7]\n * @dataLast\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  cmp: (a: T[number], b: T[number]) => number,\n): (items: T) => ReorderedArray<T>;\n\nexport function sort(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortImplementation, args);\n}\n\nfunction sortImplementation<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T> {\n  const ret = [...items];\n  ret.sort(cmp);\n  return ret as ReorderedArray<T>;\n}\n"],"mappings":"kGA0CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACA,EACmB,CACnB,IAAM,EAAM,CAAC,GAAG,EAAM,CAEtB,OADA,EAAI,KAAK,EAAI,CACN"}

package/dist/sort.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=[...e];return n.sort(t),n}export{t as sort};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){let n=[...e];return n.sort(t),n}export{t as sort};
 //# sourceMappingURL=sort.js.map

package/dist/sort.js.map

@@ -1 +1 @@
-{"version":3,"file":"sort.js","names":[],"sources":["../src/sort.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curry } from './curry';\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param items - The array to sort.\n * @param cmp - The comparator function.\n * @signature\n *    P.sort(items, cmp)\n * @example\n *    P.sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]\n * @dataFirst\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T>;\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param cmp - The comparator function.\n * @signature\n *    P.sort(cmp)(items)\n * @example\n *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7]\n * @dataLast\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  cmp: (a: T[number], b: T[number]) => number,\n): (items: T) => ReorderedArray<T>;\n\nexport function sort(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortImplementation, args);\n}\n\nfunction sortImplementation<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T> {\n  const ret = [...items];\n  ret.sort(cmp);\n  return ret as ReorderedArray<T>;\n}\n"],"mappings":"wCA0CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACA,EACmB,CACnB,IAAM,EAAM,CAAC,GAAG,EAAM,CAEtB,OADA,EAAI,KAAK,EAAI,CACN"}
+{"version":3,"file":"sort.js","names":[],"sources":["../src/sort.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curry } from './curry';\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param items - The array to sort.\n * @param cmp - The comparator function.\n * @signature\n *    sort(items, cmp)\n * @example\n *    sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]\n * @dataFirst\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T>;\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param cmp - The comparator function.\n * @signature\n *    sort(cmp)(items)\n * @example\n *    pipe([4, 2, 7, 5], sort((a, b) => a - b)) // => [2, 4, 5, 7]\n * @dataLast\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  cmp: (a: T[number], b: T[number]) => number,\n): (items: T) => ReorderedArray<T>;\n\nexport function sort(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortImplementation, args);\n}\n\nfunction sortImplementation<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T> {\n  const ret = [...items];\n  ret.sort(cmp);\n  return ret as ReorderedArray<T>;\n}\n"],"mappings":"mCA0CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACA,EACmB,CACnB,IAAM,EAAM,CAAC,GAAG,EAAM,CAEtB,OADA,EAAI,KAAK,EAAI,CACN"}

package/dist/sorted-index-by.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./binary-search-cutoff-index-ClkmTCR5.cjs`);function n(...t){return e.t(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t.t(e,(t,n)=>r(t,n,e)<i)}exports.sortedIndexBy=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./binary-search-cutoff-index-CLFtXYPc.cjs`);function n(...t){return e.curry(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t.t(e,(t,n)=>r(t,n,e)<i)}exports.sortedIndexBy=n;
+//# sourceMappingURL=sorted-index-by.cjs.map

package/dist/sorted-index-by.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-by.cjs","names":["curry","binarySearchCutoffIndex"],"sources":["../src/sorted-index-by.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedIndexBy(data, item, valueFunction)\n * @example\n *    sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataFirst\n * @category Array\n */\nexport function sortedIndexBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @signature\n *    sortedIndexBy(data, item, valueFunction)\n * @example\n *    sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataLast\n * @category Array\n */\nexport function sortedIndexBy<T>(\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexByImplementation, args);\n}\n\nfunction sortedIndexByImplementation<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number {\n  const value = valueFunction(item, undefined /* index */, data);\n  return binarySearchCutoffIndex(\n    data,\n    (pivot, index) => valueFunction(pivot, index, data) < value,\n  );\n}\n"],"mappings":"yJAsFA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACA,EAKQ,CACR,IAAM,EAAQ,EAAc,EAAM,IAAA,GAAuB,EAAK,CAC9D,OAAOC,EAAAA,EACL,GACC,EAAO,IAAU,EAAc,EAAO,EAAO,EAAK,CAAG,EACvD"}

package/dist/sorted-index-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./binary-search-cutoff-index-CN25H71A.js";function n(...t){return e(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t(e,(t,n)=>r(t,n,e)<i)}export{n as sortedIndexBy};
+import{curry as e}from"./curry.js";import{t}from"./binary-search-cutoff-index-TJlnoie4.js";function n(...t){return e(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t(e,(t,n)=>r(t,n,e)<i)}export{n as sortedIndexBy};
 //# sourceMappingURL=sorted-index-by.js.map

package/dist/sorted-index-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"sorted-index-by.js","names":[],"sources":["../src/sorted-index-by.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedIndexBy(data, item, valueFunction)\n * @example\n *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataFirst\n * @category Array\n */\nexport function sortedIndexBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @signature\n *    P.sortedIndexBy(data, item, valueFunction)\n * @example\n *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataLast\n * @category Array\n */\nexport function sortedIndexBy<T>(\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexByImplementation, args);\n}\n\nfunction sortedIndexByImplementation<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number {\n  const value = valueFunction(item, undefined /* index */, data);\n  return binarySearchCutoffIndex(\n    data,\n    (pivot, index) => valueFunction(pivot, index, data) < value,\n  );\n}\n"],"mappings":"gGAsFA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACA,EAKQ,CACR,IAAM,EAAQ,EAAc,EAAM,IAAA,GAAuB,EAAK,CAC9D,OAAO,EACL,GACC,EAAO,IAAU,EAAc,EAAO,EAAO,EAAK,CAAG,EACvD"}
+{"version":3,"file":"sorted-index-by.js","names":[],"sources":["../src/sorted-index-by.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedIndexBy(data, item, valueFunction)\n * @example\n *    sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataFirst\n * @category Array\n */\nexport function sortedIndexBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @signature\n *    sortedIndexBy(data, item, valueFunction)\n * @example\n *    sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataLast\n * @category Array\n */\nexport function sortedIndexBy<T>(\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexByImplementation, args);\n}\n\nfunction sortedIndexByImplementation<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number {\n  const value = valueFunction(item, undefined /* index */, data);\n  return binarySearchCutoffIndex(\n    data,\n    (pivot, index) => valueFunction(pivot, index, data) < value,\n  );\n}\n"],"mappings":"2FAsFA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACA,EAKQ,CACR,IAAM,EAAQ,EAAc,EAAM,IAAA,GAAuB,EAAK,CAC9D,OAAO,EACL,GACC,EAAO,IAAU,EAAc,EAAO,EAAO,EAAK,CAAG,EACvD"}

package/dist/sorted-index-with.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./binary-search-cutoff-index-ClkmTCR5.cjs`);function n(...n){return e.t(t.t,n)}exports.sortedIndexWith=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./binary-search-cutoff-index-CLFtXYPc.cjs`);function n(...n){return e.curry(t.t,n)}exports.sortedIndexWith=n;
+//# sourceMappingURL=sorted-index-with.cjs.map

package/dist/sorted-index-with.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-with.cjs","names":["curry","binarySearchCutoffIndex"],"sources":["../src/sorted-index-with.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Performs a **binary search** for the index of the item at which the predicate\n * stops returning `true`. This function assumes that the array is \"sorted\" in\n * regards to the predicate, meaning that running the predicate as a mapper on\n * it would result in an array `[...true[], ...false[]]`.\n * This stricter requirement from the predicate provides us 2 benefits over\n * `findIndex` which does a similar thing:\n * 1. It would run at O(logN) time instead of O(N) time.\n * 2. It always returns a value (it would return `data.length` if the\n * predicate returns `true` for all items).\n *\n * This function is the basis for all other sortedIndex functions which search\n * for a specific item in a sorted array, and it could be used to perform\n * similar efficient searches.\n * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.\n * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.\n * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.\n * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - Array, \"sorted\" by `predicate`.\n * @param predicate - A predicate which also defines the array's order.\n * @returns Index (In the range 0..data.length).\n * @signature\n *    sortedIndexWith(data, predicate)\n * @example\n *    sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1\n * @dataFirst\n * @category Array\n * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndexWith<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Performs a **binary search** for the index of the item at which the predicate\n * stops returning `true`. This function assumes that the array is \"sorted\" in\n * regards to the predicate, meaning that running the predicate as a mapper on\n * it would result in an array `[...true[], ...false[]]`.\n * This stricter requirement from the predicate provides us 2 benefits over\n * `findIndex` which does a similar thing:\n * 1. It would run at O(logN) time instead of O(N) time.\n * 2. It always returns a value (it would return `data.length` if the\n * predicate returns `true` for all items).\n *\n * This function is the basis for all other sortedIndex functions which search\n * for a specific item in a sorted array, and it could be used to perform\n * similar efficient searches.\n * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.\n * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.\n * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.\n * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param predicate - A predicate which also defines the array's order.\n * @returns Index (In the range 0..data.length).\n * @signature\n *    sortedIndexWith(predicate)(data)\n * @example\n *    pipe(['a','ab','abc'], sortedIndexWith((item) => item.length < 2)) // => 1\n * @dataLast\n * @category Array\n */\nexport function sortedIndexWith<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndexWith(...args: ReadonlyArray<unknown>): unknown {\n  return curry(binarySearchCutoffIndex, args);\n}\n"],"mappings":"yJA8EA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAOA,EAAAA,MAAMC,EAAAA,EAAyB,EAAK"}

package/dist/sorted-index-with.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./binary-search-cutoff-index-CN25H71A.js";function n(...n){return e(t,n)}export{n as sortedIndexWith};
+import{curry as e}from"./curry.js";import{t}from"./binary-search-cutoff-index-TJlnoie4.js";function n(...n){return e(t,n)}export{n as sortedIndexWith};
 //# sourceMappingURL=sorted-index-with.js.map

package/dist/sorted-index-with.js.map

@@ -1 +1 @@
-{"version":3,"file":"sorted-index-with.js","names":[],"sources":["../src/sorted-index-with.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Performs a **binary search** for the index of the item at which the predicate\n * stops returning `true`. This function assumes that the array is \"sorted\" in\n * regards to the predicate, meaning that running the predicate as a mapper on\n * it would result in an array `[...true[], ...false[]]`.\n * This stricter requirement from the predicate provides us 2 benefits over\n * `findIndex` which does a similar thing:\n * 1. It would run at O(logN) time instead of O(N) time.\n * 2. It always returns a value (it would return `data.length` if the\n * predicate returns `true` for all items).\n *\n * This function is the basis for all other sortedIndex functions which search\n * for a specific item in a sorted array, and it could be used to perform\n * similar efficient searches.\n * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.\n * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.\n * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.\n * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - Array, \"sorted\" by `predicate`.\n * @param predicate - A predicate which also defines the array's order.\n * @returns Index (In the range 0..data.length).\n * @signature\n *    P.sortedIndexWith(data, predicate)\n * @example\n *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1\n * @dataFirst\n * @category Array\n * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndexWith<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Performs a **binary search** for the index of the item at which the predicate\n * stops returning `true`. This function assumes that the array is \"sorted\" in\n * regards to the predicate, meaning that running the predicate as a mapper on\n * it would result in an array `[...true[], ...false[]]`.\n * This stricter requirement from the predicate provides us 2 benefits over\n * `findIndex` which does a similar thing:\n * 1. It would run at O(logN) time instead of O(N) time.\n * 2. It always returns a value (it would return `data.length` if the\n * predicate returns `true` for all items).\n *\n * This function is the basis for all other sortedIndex functions which search\n * for a specific item in a sorted array, and it could be used to perform\n * similar efficient searches.\n * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.\n * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.\n * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.\n * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param predicate - A predicate which also defines the array's order.\n * @returns Index (In the range 0..data.length).\n * @signature\n *    P.sortedIndexWith(predicate)(data)\n * @example\n *    P.pipe(['a','ab','abc'], P.sortedIndexWith((item) => item.length < 2)) // => 1\n * @dataLast\n * @category Array\n */\nexport function sortedIndexWith<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndexWith(...args: ReadonlyArray<unknown>): unknown {\n  return curry(binarySearchCutoffIndex, args);\n}\n"],"mappings":"gGA8EA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAO,EAAM,EAAyB,EAAK"}
+{"version":3,"file":"sorted-index-with.js","names":[],"sources":["../src/sorted-index-with.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Performs a **binary search** for the index of the item at which the predicate\n * stops returning `true`. This function assumes that the array is \"sorted\" in\n * regards to the predicate, meaning that running the predicate as a mapper on\n * it would result in an array `[...true[], ...false[]]`.\n * This stricter requirement from the predicate provides us 2 benefits over\n * `findIndex` which does a similar thing:\n * 1. It would run at O(logN) time instead of O(N) time.\n * 2. It always returns a value (it would return `data.length` if the\n * predicate returns `true` for all items).\n *\n * This function is the basis for all other sortedIndex functions which search\n * for a specific item in a sorted array, and it could be used to perform\n * similar efficient searches.\n * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.\n * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.\n * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.\n * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - Array, \"sorted\" by `predicate`.\n * @param predicate - A predicate which also defines the array's order.\n * @returns Index (In the range 0..data.length).\n * @signature\n *    sortedIndexWith(data, predicate)\n * @example\n *    sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1\n * @dataFirst\n * @category Array\n * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndexWith<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Performs a **binary search** for the index of the item at which the predicate\n * stops returning `true`. This function assumes that the array is \"sorted\" in\n * regards to the predicate, meaning that running the predicate as a mapper on\n * it would result in an array `[...true[], ...false[]]`.\n * This stricter requirement from the predicate provides us 2 benefits over\n * `findIndex` which does a similar thing:\n * 1. It would run at O(logN) time instead of O(N) time.\n * 2. It always returns a value (it would return `data.length` if the\n * predicate returns `true` for all items).\n *\n * This function is the basis for all other sortedIndex functions which search\n * for a specific item in a sorted array, and it could be used to perform\n * similar efficient searches.\n * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.\n * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.\n * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.\n * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param predicate - A predicate which also defines the array's order.\n * @returns Index (In the range 0..data.length).\n * @signature\n *    sortedIndexWith(predicate)(data)\n * @example\n *    pipe(['a','ab','abc'], sortedIndexWith((item) => item.length < 2)) // => 1\n * @dataLast\n * @category Array\n */\nexport function sortedIndexWith<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndexWith(...args: ReadonlyArray<unknown>): unknown {\n  return curry(binarySearchCutoffIndex, args);\n}\n"],"mappings":"2FA8EA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAO,EAAM,EAAyB,EAAK"}

package/dist/sorted-index.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./binary-search-cutoff-index-ClkmTCR5.cjs`);function n(...t){return e.t(r,t)}function r(e,n){return t.t(e,e=>e<n)}exports.sortedIndex=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./binary-search-cutoff-index-CLFtXYPc.cjs`);function n(...t){return e.curry(r,t)}function r(e,n){return t.t(e,e=>e<n)}exports.sortedIndex=n;
+//# sourceMappingURL=sorted-index.cjs.map

package/dist/sorted-index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index.cjs","names":["curry","binarySearchCutoffIndex"],"sources":["../src/sorted-index.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..array.length).\n * @signature\n *    sortedIndex(data, item)\n * @example\n *    sortedIndex(['a','a','b','c','c'], 'c') // => 3\n * @dataFirst\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<T>(data: ReadonlyArray<T>, item: T): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..array.length).\n * @signature\n *    sortedIndex(item)(data)\n * @example\n *    pipe(['a','a','b','c','c'], sortedIndex('c')) // => 3\n * @dataLast\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexImplementation, args);\n}\n\nfunction sortedIndexImplementation<T>(array: ReadonlyArray<T>, item: T): number {\n  return binarySearchCutoffIndex(array, (pivot) => pivot < item);\n}\n"],"mappings":"yJA8CA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA6B,EAAyB,EAAiB,CAC9E,OAAOC,EAAAA,EAAwB,EAAQ,GAAU,EAAQ,EAAK"}

package/dist/sorted-index.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./binary-search-cutoff-index-CN25H71A.js";function n(...t){return e(r,t)}function r(e,n){return t(e,e=>e<n)}export{n as sortedIndex};
+import{curry as e}from"./curry.js";import{t}from"./binary-search-cutoff-index-TJlnoie4.js";function n(...t){return e(r,t)}function r(e,n){return t(e,e=>e<n)}export{n as sortedIndex};
 //# sourceMappingURL=sorted-index.js.map

package/dist/sorted-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"sorted-index.js","names":[],"sources":["../src/sorted-index.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..array.length).\n * @signature\n *    P.sortedIndex(data, item)\n * @example\n *    P.sortedIndex(['a','a','b','c','c'], 'c') // => 3\n * @dataFirst\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<T>(data: ReadonlyArray<T>, item: T): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..array.length).\n * @signature\n *    P.sortedIndex(item)(data)\n * @example\n *    P.pipe(['a','a','b','c','c'], P.sortedIndex('c')) // => 3\n * @dataLast\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexImplementation, args);\n}\n\nfunction sortedIndexImplementation<T>(\n  array: ReadonlyArray<T>,\n  item: T,\n): number {\n  return binarySearchCutoffIndex(array, (pivot) => pivot < item);\n}\n"],"mappings":"gGA8CA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EACP,EACA,EACQ,CACR,OAAO,EAAwB,EAAQ,GAAU,EAAQ,EAAK"}
+{"version":3,"file":"sorted-index.js","names":[],"sources":["../src/sorted-index.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..array.length).\n * @signature\n *    sortedIndex(data, item)\n * @example\n *    sortedIndex(['a','a','b','c','c'], 'c') // => 3\n * @dataFirst\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<T>(data: ReadonlyArray<T>, item: T): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..array.length).\n * @signature\n *    sortedIndex(item)(data)\n * @example\n *    pipe(['a','a','b','c','c'], sortedIndex('c')) // => 3\n * @dataLast\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexImplementation, args);\n}\n\nfunction sortedIndexImplementation<T>(array: ReadonlyArray<T>, item: T): number {\n  return binarySearchCutoffIndex(array, (pivot) => pivot < item);\n}\n"],"mappings":"2FA8CA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA6B,EAAyB,EAAiB,CAC9E,OAAO,EAAwB,EAAQ,GAAU,EAAQ,EAAK"}

package/dist/sorted-last-index-by.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./binary-search-cutoff-index-ClkmTCR5.cjs`);function n(...t){return e.t(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t.t(e,(t,n)=>r(t,n,e)<=i)}exports.sortedLastIndexBy=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./binary-search-cutoff-index-CLFtXYPc.cjs`);function n(...t){return e.curry(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t.t(e,(t,n)=>r(t,n,e)<=i)}exports.sortedLastIndexBy=n;
+//# sourceMappingURL=sorted-last-index-by.cjs.map

package/dist/sorted-last-index-by.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-last-index-by.cjs","names":["curry","binarySearchCutoffIndex"],"sources":["../src/sorted-last-index-by.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedLastIndex` - a simplified version of this function, without a callbackfn.\n * `sortedIndexBy` - like this function, but returns the first suitable index.\n * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedLastIndexBy(data, item, valueFunction)\n * @example\n *    sortedLastIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataFirst\n * @category Array\n */\nexport function sortedLastIndexBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedLastIndex` - a simplified version of this function, without a callbackfn.\n * `sortedIndexBy` - like this function, but returns the first suitable index.\n * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedLastIndexBy(item, valueFunction)(data)\n * @example\n *    pipe([{age:20},{age:22}],sortedLastIndexBy({age:21},prop('age'))) // => 1\n * @dataLast\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex\n */\nexport function sortedLastIndexBy<T>(\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedLastIndexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedLastIndexByImplementation, args);\n}\n\nfunction sortedLastIndexByImplementation<T>(\n  array: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number {\n  const value = valueFunction(item, undefined /* index */, array);\n  return binarySearchCutoffIndex(\n    array,\n    // The only difference between the regular implementation and the \"last\"\n    // variation is that we consider the pivot with equality too, so that we\n    // skip all equal values in addition to the lower ones.\n    (pivot, index) => valueFunction(pivot, index, array) <= value,\n  );\n}\n"],"mappings":"yJAwFA,SAAgB,EAAkB,GAAG,EAAuC,CAC1E,OAAOA,EAAAA,MAAM,EAAiC,EAAK,CAGrD,SAAS,EACP,EACA,EACA,EAKQ,CACR,IAAM,EAAQ,EAAc,EAAM,IAAA,GAAuB,EAAM,CAC/D,OAAOC,EAAAA,EACL,GAIC,EAAO,IAAU,EAAc,EAAO,EAAO,EAAM,EAAI,EACzD"}

package/dist/sorted-last-index-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./binary-search-cutoff-index-CN25H71A.js";function n(...t){return e(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t(e,(t,n)=>r(t,n,e)<=i)}export{n as sortedLastIndexBy};
+import{curry as e}from"./curry.js";import{t}from"./binary-search-cutoff-index-TJlnoie4.js";function n(...t){return e(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t(e,(t,n)=>r(t,n,e)<=i)}export{n as sortedLastIndexBy};
 //# sourceMappingURL=sorted-last-index-by.js.map

package/dist/sorted-last-index-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"sorted-last-index-by.js","names":[],"sources":["../src/sorted-last-index-by.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedLastIndex` - a simplified version of this function, without a callbackfn.\n * `sortedIndexBy` - like this function, but returns the first suitable index.\n * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedLastIndexBy(data, item, valueFunction)\n * @example\n *    P.sortedLastIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataFirst\n * @category Array\n */\nexport function sortedLastIndexBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedLastIndex` - a simplified version of this function, without a callbackfn.\n * `sortedIndexBy` - like this function, but returns the first suitable index.\n * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedLastIndexBy(item, valueFunction)(data)\n * @example\n *    P.pipe([{age:20},{age:22}],sortedLastIndexBy({age:21},prop('age'))) // => 1\n * @dataLast\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex\n */\nexport function sortedLastIndexBy<T>(\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedLastIndexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedLastIndexByImplementation, args);\n}\n\nfunction sortedLastIndexByImplementation<T>(\n  array: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number {\n  const value = valueFunction(item, undefined /* index */, array);\n  return binarySearchCutoffIndex(\n    array,\n    // The only difference between the regular implementation and the \"last\"\n    // variation is that we consider the pivot with equality too, so that we\n    // skip all equal values in addition to the lower ones.\n    (pivot, index) => valueFunction(pivot, index, array) <= value,\n  );\n}\n"],"mappings":"gGAwFA,SAAgB,EAAkB,GAAG,EAAuC,CAC1E,OAAO,EAAM,EAAiC,EAAK,CAGrD,SAAS,EACP,EACA,EACA,EAKQ,CACR,IAAM,EAAQ,EAAc,EAAM,IAAA,GAAuB,EAAM,CAC/D,OAAO,EACL,GAIC,EAAO,IAAU,EAAc,EAAO,EAAO,EAAM,EAAI,EACzD"}
+{"version":3,"file":"sorted-last-index-by.js","names":[],"sources":["../src/sorted-last-index-by.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedLastIndex` - a simplified version of this function, without a callbackfn.\n * `sortedIndexBy` - like this function, but returns the first suitable index.\n * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedLastIndexBy(data, item, valueFunction)\n * @example\n *    sortedLastIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataFirst\n * @category Array\n */\nexport function sortedLastIndexBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedLastIndex` - a simplified version of this function, without a callbackfn.\n * `sortedIndexBy` - like this function, but returns the first suitable index.\n * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedLastIndexBy(item, valueFunction)(data)\n * @example\n *    pipe([{age:20},{age:22}],sortedLastIndexBy({age:21},prop('age'))) // => 1\n * @dataLast\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex\n */\nexport function sortedLastIndexBy<T>(\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedLastIndexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedLastIndexByImplementation, args);\n}\n\nfunction sortedLastIndexByImplementation<T>(\n  array: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number {\n  const value = valueFunction(item, undefined /* index */, array);\n  return binarySearchCutoffIndex(\n    array,\n    // The only difference between the regular implementation and the \"last\"\n    // variation is that we consider the pivot with equality too, so that we\n    // skip all equal values in addition to the lower ones.\n    (pivot, index) => valueFunction(pivot, index, array) <= value,\n  );\n}\n"],"mappings":"2FAwFA,SAAgB,EAAkB,GAAG,EAAuC,CAC1E,OAAO,EAAM,EAAiC,EAAK,CAGrD,SAAS,EACP,EACA,EACA,EAKQ,CACR,IAAM,EAAQ,EAAc,EAAM,IAAA,GAAuB,EAAM,CAC/D,OAAO,EACL,GAIC,EAAO,IAAU,EAAc,EAAO,EAAO,EAAM,EAAI,EACzD"}

package/dist/sorted-last-index.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./binary-search-cutoff-index-ClkmTCR5.cjs`);function n(...t){return e.t(r,t)}function r(e,n){return t.t(e,e=>e<=n)}exports.sortedLastIndex=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./binary-search-cutoff-index-CLFtXYPc.cjs`);function n(...t){return e.curry(r,t)}function r(e,n){return t.t(e,e=>e<=n)}exports.sortedLastIndex=n;
+//# sourceMappingURL=sorted-last-index.cjs.map

package/dist/sorted-last-index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-last-index.cjs","names":["curry","binarySearchCutoffIndex"],"sources":["../src/sorted-last-index.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedLastIndex(data, item)\n * @example\n *    sortedLastIndex(['a','a','b','c','c'], 'c') // => 5\n * @dataFirst\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy\n */\nexport function sortedLastIndex<T>(data: ReadonlyArray<T>, item: T): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedLastIndex(item)(data)\n * @example\n *    pipe(['a','a','b','c','c'], sortedLastIndex('c')) // => 5\n * @dataLast\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy\n */\nexport function sortedLastIndex<T>(item: T): (data: ReadonlyArray<T>) => number;\n\nexport function sortedLastIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedLastIndexImplementation, args);\n}\n\nfunction sortedLastIndexImplementation<T>(array: ReadonlyArray<T>, item: T): number {\n  return binarySearchCutoffIndex(\n    array,\n    // The only difference between the regular implementation and the \"last\"\n    // variation is that we consider the pivot with equality too, so that we\n    // skip all equal values in addition to the lower ones.\n    (pivot) => pivot <= item,\n  );\n}\n"],"mappings":"yJA8CA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAOA,EAAAA,MAAM,EAA+B,EAAK,CAGnD,SAAS,EAAiC,EAAyB,EAAiB,CAClF,OAAOC,EAAAA,EACL,EAIC,GAAU,GAAS,EACrB"}

package/dist/sorted-last-index.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./binary-search-cutoff-index-CN25H71A.js";function n(...t){return e(r,t)}function r(e,n){return t(e,e=>e<=n)}export{n as sortedLastIndex};
+import{curry as e}from"./curry.js";import{t}from"./binary-search-cutoff-index-TJlnoie4.js";function n(...t){return e(r,t)}function r(e,n){return t(e,e=>e<=n)}export{n as sortedLastIndex};
 //# sourceMappingURL=sorted-last-index.js.map

package/dist/sorted-last-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"sorted-last-index.js","names":[],"sources":["../src/sorted-last-index.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedLastIndex(data, item)\n * @example\n *    P.sortedLastIndex(['a','a','b','c','c'], 'c') // => 5\n * @dataFirst\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy\n */\nexport function sortedLastIndex<T>(data: ReadonlyArray<T>, item: T): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedLastIndex(item)(data)\n * @example\n *    P.pipe(['a','a','b','c','c'], sortedLastIndex('c')) // => 5\n * @dataLast\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy\n */\nexport function sortedLastIndex<T>(item: T): (data: ReadonlyArray<T>) => number;\n\nexport function sortedLastIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedLastIndexImplementation, args);\n}\n\nfunction sortedLastIndexImplementation<T>(\n  array: ReadonlyArray<T>,\n  item: T,\n): number {\n  return binarySearchCutoffIndex(\n    array,\n    // The only difference between the regular implementation and the \"last\"\n    // variation is that we consider the pivot with equality too, so that we\n    // skip all equal values in addition to the lower ones.\n    (pivot) => pivot <= item,\n  );\n}\n"],"mappings":"gGA8CA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAO,EAAM,EAA+B,EAAK,CAGnD,SAAS,EACP,EACA,EACQ,CACR,OAAO,EACL,EAIC,GAAU,GAAS,EACrB"}
+{"version":3,"file":"sorted-last-index.js","names":[],"sources":["../src/sorted-last-index.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedLastIndex(data, item)\n * @example\n *    sortedLastIndex(['a','a','b','c','c'], 'c') // => 5\n * @dataFirst\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy\n */\nexport function sortedLastIndex<T>(data: ReadonlyArray<T>, item: T): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    sortedLastIndex(item)(data)\n * @example\n *    pipe(['a','a','b','c','c'], sortedLastIndex('c')) // => 5\n * @dataLast\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy\n */\nexport function sortedLastIndex<T>(item: T): (data: ReadonlyArray<T>) => number;\n\nexport function sortedLastIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedLastIndexImplementation, args);\n}\n\nfunction sortedLastIndexImplementation<T>(array: ReadonlyArray<T>, item: T): number {\n  return binarySearchCutoffIndex(\n    array,\n    // The only difference between the regular implementation and the \"last\"\n    // variation is that we consider the pivot with equality too, so that we\n    // skip all equal values in addition to the lower ones.\n    (pivot) => pivot <= item,\n  );\n}\n"],"mappings":"2FA8CA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAO,EAAM,EAA+B,EAAK,CAGnD,SAAS,EAAiC,EAAyB,EAAiB,CAClF,OAAO,EACL,EAIC,GAAU,GAAS,EACrB"}

package/dist/splice.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t,n,r){let i=[...e];return i.splice(t,n,...r),i}exports.splice=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,r){let i=[...e];return i.splice(t,n,...r),i}exports.splice=t;
+//# sourceMappingURL=splice.cjs.map

package/dist/splice.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice.cjs","names":["curry"],"sources":["../src/splice.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Removes elements from an array and, inserts new elements in their place.\n *\n * @param items - The array to splice.\n * @param start - The index from which to start removing elements.\n * @param deleteCount - The number of elements to remove.\n * @param replacement - The elements to insert into the array in place of the deleted elements.\n * @signature\n *    splice(items, start, deleteCount, replacement)\n * @example\n *    splice([1,2,3,4,5,6,7,8], 2, 3, []); //=> [1,2,6,7,8]\n *    splice([1,2,3,4,5,6,7,8], 2, 3, [9, 10]); //=> [1,2,9,10,6,7,8]\n * @dataFirst\n * @category Array\n */\nexport function splice<T>(\n  items: ReadonlyArray<T>,\n  start: number,\n  deleteCount: number,\n  replacement: ReadonlyArray<T>,\n): Array<T>;\n\n/**\n * Removes elements from an array and, inserts new elements in their place.\n *\n * @param start - The index from which to start removing elements.\n * @param deleteCount - The number of elements to remove.\n * @param replacement - The elements to insert into the array in place of the deleted elements.\n * @signature\n *    splice(start, deleteCount, replacement)(items)\n * @example\n *    pipe([1,2,3,4,5,6,7,8], splice(2, 3, [])) // => [1,2,6,7,8]\n *    pipe([1,2,3,4,5,6,7,8], splice(2, 3, [9, 10])) // => [1,2,9,10,6,7,8]\n * @dataLast\n * @category Array\n */\nexport function splice<T>(\n  start: number,\n  deleteCount: number,\n  replacement: ReadonlyArray<T>,\n): (items: ReadonlyArray<T>) => Array<T>;\n\nexport function splice(...args: ReadonlyArray<unknown>): unknown {\n  return curry(spliceImplementation, args);\n}\n\nfunction spliceImplementation<T>(\n  items: ReadonlyArray<T>,\n  start: number,\n  deleteCount: number,\n  replacement: ReadonlyArray<T>,\n): Array<T> {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toSpliced` here.\n  const result = [...items];\n  result.splice(start, deleteCount, ...replacement);\n  return result;\n}\n"],"mappings":"kGA4CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACA,EACA,EACU,CAEV,IAAM,EAAS,CAAC,GAAG,EAAM,CAEzB,OADA,EAAO,OAAO,EAAO,EAAa,GAAG,EAAY,CAC1C"}

package/dist/splice.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,r){let i=[...e];return i.splice(t,n,...r),i}export{t as splice};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t,n,r){let i=[...e];return i.splice(t,n,...r),i}export{t as splice};
 //# sourceMappingURL=splice.js.map