@depup/remeda 2.33.6-depup.0

package/dist/sample.js.map

@@ -0,0 +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/CoercedArray\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { NTuple } from \"./internal/types/NTuple\";\nimport type { PartialArray } from \"./internal/types/PartialArray\";\nimport type { TupleParts } from \"./internal/types/TupleParts\";\nimport { purry } from \"./purry\";\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 readonly unknown[],\n  Item,\n  Suffix extends readonly 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 readonly 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: readonly unknown[]): unknown {\n  return purry(sampleImplementation, args);\n}\n\nfunction sampleImplementation<T>(data: readonly T[], sampleSize: number): 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,EAAmC,CAC3D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAAwB,EAAoB,EAAyB,CAC5E,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.cjs

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

package/dist/set.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.cjs","names":["purry"],"sources":["../src/set.ts"],"sourcesContent":["import type { UpsertProp } from \"./internal/types/UpsertProp\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(setImplementation, args);\n}\n\nconst 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\n  ({ ...obj, [prop]: value });\n"],"mappings":"kGA6CA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAOA,EAAAA,MAAM,EAAmB,EAAK,CAGvC,MAAM,GACJ,EACA,EACA,KAGC,CAAE,GAAG,GAAM,GAAO,EAAO"}

package/dist/set.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}const n=(e,t,n)=>({...e,[t]:n});export{t as set};
+//# sourceMappingURL=set.js.map

package/dist/set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.js","names":[],"sources":["../src/set.ts"],"sourcesContent":["import type { UpsertProp } from \"./internal/types/UpsertProp\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(setImplementation, args);\n}\n\nconst 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\n  ({ ...obj, [prop]: value });\n"],"mappings":"mCA6CA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAO,EAAM,EAAmB,EAAK,CAGvC,MAAM,GACJ,EACA,EACA,KAGC,CAAE,GAAG,GAAM,GAAO,EAAO"}

package/dist/setPath.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(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=setPath.cjs.map

package/dist/setPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"setPath.cjs","names":["purry"],"sources":["../src/setPath.ts"],"sourcesContent":["import type { ValueOf } from \"type-fest\";\nimport type { RemedaTypeError } from \"./internal/types/RemedaTypeError\";\nimport { purry } from \"./purry\";\n\ntype Paths<T, Prefix extends readonly unknown[] = []> =\n  | Prefix\n  | (T extends object\n      ? ValueOf<{\n          [K in ProperKeyOf<T>]-?: Paths<T[K], [...Prefix, K]>;\n        }>\n      : RemedaTypeError<\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 readonly 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  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- See TODO above...\n  Value extends ValueAtPath<T, Path>,\n>(path: Path, value: Value): (data: T) => T;\n\nexport function setPath(...args: readonly unknown[]): unknown {\n  return purry(setPathImplementation, args);\n}\n\nfunction setPathImplementation(\n  data: unknown,\n  path: readonly 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    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\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":"kGAkFA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,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,CAEvB,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/setPath.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.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=setPath.js.map

package/dist/setPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setPath.js","names":[],"sources":["../src/setPath.ts"],"sourcesContent":["import type { ValueOf } from \"type-fest\";\nimport type { RemedaTypeError } from \"./internal/types/RemedaTypeError\";\nimport { purry } from \"./purry\";\n\ntype Paths<T, Prefix extends readonly unknown[] = []> =\n  | Prefix\n  | (T extends object\n      ? ValueOf<{\n          [K in ProperKeyOf<T>]-?: Paths<T[K], [...Prefix, K]>;\n        }>\n      : RemedaTypeError<\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 readonly 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  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- See TODO above...\n  Value extends ValueAtPath<T, Path>,\n>(path: Path, value: Value): (data: T) => T;\n\nexport function setPath(...args: readonly unknown[]): unknown {\n  return purry(setPathImplementation, args);\n}\n\nfunction setPathImplementation(\n  data: unknown,\n  path: readonly 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    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\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":"mCAkFA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,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,CAEvB,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/shuffle.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(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":["purry"],"sources":["../src/shuffle.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { ReorderedArray } from \"./internal/types/ReorderedArray\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(shuffleImplementation, args);\n}\n\nfunction shuffleImplementation<T>(items: readonly T[]): 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,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAA0B,CAC1D,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

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.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

@@ -0,0 +1 @@
+{"version":3,"file":"shuffle.js","names":[],"sources":["../src/shuffle.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { ReorderedArray } from \"./internal/types/ReorderedArray\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(shuffleImplementation, args);\n}\n\nfunction shuffleImplementation<T>(items: readonly T[]): 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,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAA0B,CAC1D,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/sliceString.cjs

@@ -0,0 +1,2 @@
+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=sliceString.cjs.map

package/dist/sliceString.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliceString.cjs","names":[],"sources":["../src/sliceString.ts"],"sourcesContent":["/**\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":"mEAkDA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,SAC/B,EAAiB,MAAM,EAAsB,EAAS,CACrD,GAAiB,EAAK,MAAM,EAAkB,EAAqB"}

package/dist/sliceString.js

@@ -0,0 +1,2 @@
+function e(e,t,n){return typeof e==`string`?e.slice(t,n):n=>n.slice(e,t)}export{e as sliceString};
+//# sourceMappingURL=sliceString.js.map

package/dist/sliceString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliceString.js","names":[],"sources":["../src/sliceString.ts"],"sourcesContent":["/**\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":"AAkDA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,SAC/B,EAAiB,MAAM,EAAsB,EAAS,CACrD,GAAiB,EAAK,MAAM,EAAkB,EAAqB"}

package/dist/sort.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(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":["purry"],"sources":["../src/sort.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { ReorderedArray } from \"./internal/types/ReorderedArray\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(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,EAAmC,CACzD,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

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.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

@@ -0,0 +1 @@
+{"version":3,"file":"sort.js","names":[],"sources":["../src/sort.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { ReorderedArray } from \"./internal/types/ReorderedArray\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(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,EAAmC,CACzD,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACA,EACmB,CACnB,IAAM,EAAM,CAAC,GAAG,EAAM,CAEtB,OADA,EAAI,KAAK,EAAI,CACN"}

package/dist/sortBy.cjs

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

package/dist/sortBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortBy.cjs","names":["purryOrderRules"],"sources":["../src/sortBy.ts"],"sourcesContent":["import { purryOrderRules, type OrderRule } from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\nimport type { ReorderedArray } from \"./internal/types/ReorderedArray\";\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: readonly unknown[]): unknown {\n  return purryOrderRules(sortByImplementation, args);\n}\n\nconst sortByImplementation = <T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n): T[] =>\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toSorted` here.\n  [...data].sort(compareFn);\n"],"mappings":"qHA2FA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAOA,EAAAA,EAAgB,EAAsB,EAAK,CAGpD,MAAM,GACJ,EACA,IAGA,CAAC,GAAG,EAAK,CAAC,KAAK,EAAU"}

package/dist/sortBy.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purryOrderRules-4JgY6z4X.js";function t(...t){return e(n,t)}const n=(e,t)=>[...e].sort(t);export{t as sortBy};
+//# sourceMappingURL=sortBy.js.map

package/dist/sortBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortBy.js","names":[],"sources":["../src/sortBy.ts"],"sourcesContent":["import { purryOrderRules, type OrderRule } from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\nimport type { ReorderedArray } from \"./internal/types/ReorderedArray\";\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: readonly unknown[]): unknown {\n  return purryOrderRules(sortByImplementation, args);\n}\n\nconst sortByImplementation = <T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n): T[] =>\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toSorted` here.\n  [...data].sort(compareFn);\n"],"mappings":"kDA2FA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAO,EAAgB,EAAsB,EAAK,CAGpD,MAAM,GACJ,EACA,IAGA,CAAC,GAAG,EAAK,CAAC,KAAK,EAAU"}

package/dist/sortedIndex.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./binarySearchCutoffIndex-DdLPjZiy.cjs`);function n(...t){return e.purry(r,t)}const r=(e,n)=>t.t(e,e=>e<n);exports.sortedIndex=n;
+//# sourceMappingURL=sortedIndex.cjs.map

package/dist/sortedIndex.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedIndex.cjs","names":["purry","binarySearchCutoffIndex"],"sources":["../src/sortedIndex.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly 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: readonly T[]) => number;\n\nexport function sortedIndex(...args: readonly unknown[]): unknown {\n  return purry(sortedIndexImplementation, args);\n}\n\nconst sortedIndexImplementation = <T>(array: readonly T[], item: T): number =>\n  binarySearchCutoffIndex(array, (pivot) => pivot < item);\n"],"mappings":"sJA8CA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,MAAM,GAAgC,EAAqB,IACzDC,EAAAA,EAAwB,EAAQ,GAAU,EAAQ,EAAK"}

package/dist/sortedIndex.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";import{t}from"./binarySearchCutoffIndex-CLQRwIY1.js";function n(...t){return e(r,t)}const r=(e,n)=>t(e,e=>e<n);export{n as sortedIndex};
+//# sourceMappingURL=sortedIndex.js.map

package/dist/sortedIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedIndex.js","names":[],"sources":["../src/sortedIndex.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly 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: readonly T[]) => number;\n\nexport function sortedIndex(...args: readonly unknown[]): unknown {\n  return purry(sortedIndexImplementation, args);\n}\n\nconst sortedIndexImplementation = <T>(array: readonly T[], item: T): number =>\n  binarySearchCutoffIndex(array, (pivot) => pivot < item);\n"],"mappings":"wFA8CA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAO,EAAM,EAA2B,EAAK,CAG/C,MAAM,GAAgC,EAAqB,IACzD,EAAwB,EAAQ,GAAU,EAAQ,EAAK"}

package/dist/sortedIndexBy.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./binarySearchCutoffIndex-DdLPjZiy.cjs`);function n(...t){return e.purry(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=sortedIndexBy.cjs.map

package/dist/sortedIndexBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedIndexBy.cjs","names":["purry","binarySearchCutoffIndex"],"sources":["../src/sortedIndexBy.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly T[],\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: readonly 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: readonly T[],\n  ) => NonNullable<unknown>,\n): (data: readonly T[]) => number;\n\nexport function sortedIndexBy(...args: readonly unknown[]): unknown {\n  return purry(sortedIndexByImplementation, args);\n}\n\nfunction sortedIndexByImplementation<T>(\n  data: readonly T[],\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: readonly 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":"sJAsFA,SAAgB,EAAc,GAAG,EAAmC,CAClE,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/sortedIndexBy.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";import{t}from"./binarySearchCutoffIndex-CLQRwIY1.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=sortedIndexBy.js.map

package/dist/sortedIndexBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedIndexBy.js","names":[],"sources":["../src/sortedIndexBy.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly T[],\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: readonly 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: readonly T[],\n  ) => NonNullable<unknown>,\n): (data: readonly T[]) => number;\n\nexport function sortedIndexBy(...args: readonly unknown[]): unknown {\n  return purry(sortedIndexByImplementation, args);\n}\n\nfunction sortedIndexByImplementation<T>(\n  data: readonly T[],\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: readonly 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":"wFAsFA,SAAgB,EAAc,GAAG,EAAmC,CAClE,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/sortedIndexWith.cjs

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

package/dist/sortedIndexWith.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedIndexWith.cjs","names":["purry","binarySearchCutoffIndex"],"sources":["../src/sortedIndexWith.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly T[],\n  predicate: (value: T, index: number, data: readonly 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: readonly T[]) => boolean,\n): (data: readonly T[]) => number;\n\nexport function sortedIndexWith(...args: readonly unknown[]): unknown {\n  return purry(binarySearchCutoffIndex, args);\n}\n"],"mappings":"sJA8EA,SAAgB,EAAgB,GAAG,EAAmC,CACpE,OAAOA,EAAAA,MAAMC,EAAAA,EAAyB,EAAK"}

package/dist/sortedIndexWith.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";import{t}from"./binarySearchCutoffIndex-CLQRwIY1.js";function n(...n){return e(t,n)}export{n as sortedIndexWith};
+//# sourceMappingURL=sortedIndexWith.js.map

package/dist/sortedIndexWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedIndexWith.js","names":[],"sources":["../src/sortedIndexWith.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly T[],\n  predicate: (value: T, index: number, data: readonly 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: readonly T[]) => boolean,\n): (data: readonly T[]) => number;\n\nexport function sortedIndexWith(...args: readonly unknown[]): unknown {\n  return purry(binarySearchCutoffIndex, args);\n}\n"],"mappings":"wFA8EA,SAAgB,EAAgB,GAAG,EAAmC,CACpE,OAAO,EAAM,EAAyB,EAAK"}

package/dist/sortedLastIndex.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./binarySearchCutoffIndex-DdLPjZiy.cjs`);function n(...t){return e.purry(r,t)}const r=(e,n)=>t.t(e,e=>e<=n);exports.sortedLastIndex=n;
+//# sourceMappingURL=sortedLastIndex.cjs.map

package/dist/sortedLastIndex.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedLastIndex.cjs","names":["purry","binarySearchCutoffIndex"],"sources":["../src/sortedLastIndex.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly 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: readonly T[]) => number;\n\nexport function sortedLastIndex(...args: readonly unknown[]): unknown {\n  return purry(sortedLastIndexImplementation, args);\n}\n\nconst sortedLastIndexImplementation = <T>(\n  array: readonly T[],\n  item: T,\n): number =>\n  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"],"mappings":"sJA8CA,SAAgB,EAAgB,GAAG,EAAmC,CACpE,OAAOA,EAAAA,MAAM,EAA+B,EAAK,CAGnD,MAAM,GACJ,EACA,IAEAC,EAAAA,EACE,EAIC,GAAU,GAAS,EACrB"}

package/dist/sortedLastIndex.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";import{t}from"./binarySearchCutoffIndex-CLQRwIY1.js";function n(...t){return e(r,t)}const r=(e,n)=>t(e,e=>e<=n);export{n as sortedLastIndex};
+//# sourceMappingURL=sortedLastIndex.js.map

package/dist/sortedLastIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedLastIndex.js","names":[],"sources":["../src/sortedLastIndex.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly 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: readonly T[]) => number;\n\nexport function sortedLastIndex(...args: readonly unknown[]): unknown {\n  return purry(sortedLastIndexImplementation, args);\n}\n\nconst sortedLastIndexImplementation = <T>(\n  array: readonly T[],\n  item: T,\n): number =>\n  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"],"mappings":"wFA8CA,SAAgB,EAAgB,GAAG,EAAmC,CACpE,OAAO,EAAM,EAA+B,EAAK,CAGnD,MAAM,GACJ,EACA,IAEA,EACE,EAIC,GAAU,GAAS,EACrB"}

package/dist/sortedLastIndexBy.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./binarySearchCutoffIndex-DdLPjZiy.cjs`);function n(...t){return e.purry(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=sortedLastIndexBy.cjs.map

package/dist/sortedLastIndexBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedLastIndexBy.cjs","names":["purry","binarySearchCutoffIndex"],"sources":["../src/sortedLastIndexBy.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly T[],\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: readonly 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: readonly T[],\n  ) => NonNullable<unknown>,\n): (data: readonly T[]) => number;\n\nexport function sortedLastIndexBy(...args: readonly unknown[]): unknown {\n  return purry(sortedLastIndexByImplementation, args);\n}\n\nfunction sortedLastIndexByImplementation<T>(\n  array: readonly T[],\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: readonly 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":"sJAwFA,SAAgB,EAAkB,GAAG,EAAmC,CACtE,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/sortedLastIndexBy.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";import{t}from"./binarySearchCutoffIndex-CLQRwIY1.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=sortedLastIndexBy.js.map

package/dist/sortedLastIndexBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedLastIndexBy.js","names":[],"sources":["../src/sortedLastIndexBy.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport { binarySearchCutoffIndex } from \"./internal/binarySearchCutoffIndex\";\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: readonly T[],\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: readonly 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: readonly T[],\n  ) => NonNullable<unknown>,\n): (data: readonly T[]) => number;\n\nexport function sortedLastIndexBy(...args: readonly unknown[]): unknown {\n  return purry(sortedLastIndexByImplementation, args);\n}\n\nfunction sortedLastIndexByImplementation<T>(\n  array: readonly T[],\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: readonly 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":"wFAwFA,SAAgB,EAAkB,GAAG,EAAmC,CACtE,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/splice.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(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":["purry"],"sources":["../src/splice.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly T[],\n  start: number,\n  deleteCount: number,\n  replacement: readonly T[],\n): 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: readonly T[],\n): (items: readonly T[]) => T[];\n\nexport function splice(...args: readonly unknown[]): unknown {\n  return purry(spliceImplementation, args);\n}\n\nfunction spliceImplementation<T>(\n  items: readonly T[],\n  start: number,\n  deleteCount: number,\n  replacement: readonly T[],\n): 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,EAAmC,CAC3D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACA,EACA,EACK,CAEL,IAAM,EAAS,CAAC,GAAG,EAAM,CAEzB,OADA,EAAO,OAAO,EAAO,EAAa,GAAG,EAAY,CAC1C"}

package/dist/splice.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.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

package/dist/splice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice.js","names":[],"sources":["../src/splice.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly T[],\n  start: number,\n  deleteCount: number,\n  replacement: readonly T[],\n): 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: readonly T[],\n): (items: readonly T[]) => T[];\n\nexport function splice(...args: readonly unknown[]): unknown {\n  return purry(spliceImplementation, args);\n}\n\nfunction spliceImplementation<T>(\n  items: readonly T[],\n  start: number,\n  deleteCount: number,\n  replacement: readonly T[],\n): 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":"mCA4CA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACA,EACA,EACK,CAEL,IAAM,EAAS,CAAC,GAAG,EAAM,CAEzB,OADA,EAAO,OAAO,EAAO,EAAa,GAAG,EAAY,CAC1C"}

package/dist/split.cjs

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

package/dist/split.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.cjs","names":[],"sources":["../src/split.ts"],"sourcesContent":["import type {\n  ArraySlice,\n  IsFloat,\n  NonNegative,\n  Split as SplitBase,\n} from \"type-fest\";\n\n// We can use the type-fest's split **only** if all the params are literals.\n// For all other cases it would return the wrong type so we use\n// `Array.prototype.split`s return type instead.\ntype BuiltInReturnType = ReturnType<typeof String.prototype.split>;\n\ntype Split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n> = string extends S\n  ? BuiltInReturnType\n  : string extends Separator\n    ? BuiltInReturnType\n    : number extends N\n      ? BuiltInReturnType\n      : // TODO: We need a way to \"floor\" non-integer numbers, until then we return a lower fidelity type instead.\n        IsFloat<N> extends true\n        ? BuiltInReturnType\n        : N extends number\n          ? ArraySlice<SplitBase<S, Separator>, 0, NonNegative<N>>\n          : SplitBase<S, Separator>;\n\n/**\n * Splits a string into an array of substrings using a separator pattern.\n *\n * This function is a wrapper around the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)\n * method.\n *\n * @param data - The string to split.\n * @param separator - The pattern describing where each split should occur. Can\n * be a string, or a regular expression.\n * @param limit - A non-negative integer specifying a limit on the number of\n * substrings to be included in the array. If provided, splits the string at\n * each occurrence of the specified separator, but stops when limit entries have\n * been placed in the array. Any leftover text is not included in the array at\n * all. The array may contain fewer entries than limit if the end of the string\n * is reached before the limit is reached. If limit is 0, [] is returned.\n * @returns An array of strings, split at each point where the separator occurs\n * in the given string.\n * @signature\n *   split(data, separator, limit);\n * @example\n *   split(\"a,b,c\", \",\"); //=> [\"a\", \"b\", \"c\"]\n *   split(\"a,b,c\", \",\", 2); //=> [\"a\", \"b\"]\n *   split(\"a1b2c3d\", /\\d/u); //=> [\"a\", \"b\", \"c\", \"d\"]\n * @dataFirst\n * @category String\n */\nexport function split(\n  data: string,\n  separator: RegExp,\n  limit?: number,\n): string[];\nexport function split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n>(data: S, separator: Separator, limit?: N): Split<S, Separator, N>;\n\n/**\n * Splits a string into an array of substrings using a separator pattern.\n *\n * This function is a wrapper around the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)\n * method.\n *\n * @param separator - The pattern describing where each split should occur. Can\n * be a string, or a regular expression.\n * @param limit - A non-negative integer specifying a limit on the number of\n * substrings to be included in the array. If provided, splits the string at\n * each occurrence of the specified separator, but stops when limit entries have\n * been placed in the array. Any leftover text is not included in the array at\n * all. The array may contain fewer entries than limit if the end of the string\n * is reached before the limit is reached. If limit is 0, [] is returned.\n * @returns An array of strings, split at each point where the separator occurs\n * in the given string.\n * @signature\n *   split(separator, limit)(data);\n * @example\n *   pipe(\"a,b,c\", split(\",\")); //=> [\"a\", \"b\", \"c\"]\n *   pipe(\"a,b,c\", split(\",\", 2)); //=> [\"a\", \"b\"]\n *   pipe(\"a1b2c3d\", split(/\\d/u)); //=> [\"a\", \"b\", \"c\", \"d\"]\n * @dataLast\n * @category String\n */\nexport function split(\n  separator: RegExp,\n  limit?: number,\n): (data: string) => string[];\nexport function split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n>(separator: Separator, limit?: N): (data: S) => Split<S, Separator, N>;\n\nexport function split(\n  dataOrSeparator: RegExp | string,\n  separatorOrLimit?: RegExp | number | string,\n  limit?: number,\n): unknown {\n  return typeof separatorOrLimit === \"number\" || separatorOrLimit === undefined\n    ? // dataLast\n      (data: string) => data.split(dataOrSeparator, separatorOrLimit)\n    : // dataFirst\n      (dataOrSeparator as string).split(separatorOrLimit, limit);\n}\n"],"mappings":"mEAqGA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,UAAY,IAAqB,IAAA,GAE/D,GAAiB,EAAK,MAAM,EAAiB,EAAiB,CAE9D,EAA2B,MAAM,EAAkB,EAAM"}

package/dist/split.js

@@ -0,0 +1,2 @@
+function e(e,t,n){return typeof t==`number`||t===void 0?n=>n.split(e,t):e.split(t,n)}export{e as split};
+//# sourceMappingURL=split.js.map

package/dist/split.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.js","names":[],"sources":["../src/split.ts"],"sourcesContent":["import type {\n  ArraySlice,\n  IsFloat,\n  NonNegative,\n  Split as SplitBase,\n} from \"type-fest\";\n\n// We can use the type-fest's split **only** if all the params are literals.\n// For all other cases it would return the wrong type so we use\n// `Array.prototype.split`s return type instead.\ntype BuiltInReturnType = ReturnType<typeof String.prototype.split>;\n\ntype Split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n> = string extends S\n  ? BuiltInReturnType\n  : string extends Separator\n    ? BuiltInReturnType\n    : number extends N\n      ? BuiltInReturnType\n      : // TODO: We need a way to \"floor\" non-integer numbers, until then we return a lower fidelity type instead.\n        IsFloat<N> extends true\n        ? BuiltInReturnType\n        : N extends number\n          ? ArraySlice<SplitBase<S, Separator>, 0, NonNegative<N>>\n          : SplitBase<S, Separator>;\n\n/**\n * Splits a string into an array of substrings using a separator pattern.\n *\n * This function is a wrapper around the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)\n * method.\n *\n * @param data - The string to split.\n * @param separator - The pattern describing where each split should occur. Can\n * be a string, or a regular expression.\n * @param limit - A non-negative integer specifying a limit on the number of\n * substrings to be included in the array. If provided, splits the string at\n * each occurrence of the specified separator, but stops when limit entries have\n * been placed in the array. Any leftover text is not included in the array at\n * all. The array may contain fewer entries than limit if the end of the string\n * is reached before the limit is reached. If limit is 0, [] is returned.\n * @returns An array of strings, split at each point where the separator occurs\n * in the given string.\n * @signature\n *   split(data, separator, limit);\n * @example\n *   split(\"a,b,c\", \",\"); //=> [\"a\", \"b\", \"c\"]\n *   split(\"a,b,c\", \",\", 2); //=> [\"a\", \"b\"]\n *   split(\"a1b2c3d\", /\\d/u); //=> [\"a\", \"b\", \"c\", \"d\"]\n * @dataFirst\n * @category String\n */\nexport function split(\n  data: string,\n  separator: RegExp,\n  limit?: number,\n): string[];\nexport function split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n>(data: S, separator: Separator, limit?: N): Split<S, Separator, N>;\n\n/**\n * Splits a string into an array of substrings using a separator pattern.\n *\n * This function is a wrapper around the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)\n * method.\n *\n * @param separator - The pattern describing where each split should occur. Can\n * be a string, or a regular expression.\n * @param limit - A non-negative integer specifying a limit on the number of\n * substrings to be included in the array. If provided, splits the string at\n * each occurrence of the specified separator, but stops when limit entries have\n * been placed in the array. Any leftover text is not included in the array at\n * all. The array may contain fewer entries than limit if the end of the string\n * is reached before the limit is reached. If limit is 0, [] is returned.\n * @returns An array of strings, split at each point where the separator occurs\n * in the given string.\n * @signature\n *   split(separator, limit)(data);\n * @example\n *   pipe(\"a,b,c\", split(\",\")); //=> [\"a\", \"b\", \"c\"]\n *   pipe(\"a,b,c\", split(\",\", 2)); //=> [\"a\", \"b\"]\n *   pipe(\"a1b2c3d\", split(/\\d/u)); //=> [\"a\", \"b\", \"c\", \"d\"]\n * @dataLast\n * @category String\n */\nexport function split(\n  separator: RegExp,\n  limit?: number,\n): (data: string) => string[];\nexport function split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n>(separator: Separator, limit?: N): (data: S) => Split<S, Separator, N>;\n\nexport function split(\n  dataOrSeparator: RegExp | string,\n  separatorOrLimit?: RegExp | number | string,\n  limit?: number,\n): unknown {\n  return typeof separatorOrLimit === \"number\" || separatorOrLimit === undefined\n    ? // dataLast\n      (data: string) => data.split(dataOrSeparator, separatorOrLimit)\n    : // dataFirst\n      (dataOrSeparator as string).split(separatorOrLimit, limit);\n}\n"],"mappings":"AAqGA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,UAAY,IAAqB,IAAA,GAE/D,GAAiB,EAAK,MAAM,EAAiB,EAAiB,CAE9D,EAA2B,MAAM,EAAkB,EAAM"}

package/dist/splitAt.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}function n(e,t){let n=Math.max(Math.min(t<0?e.length+t:t,e.length),0);return[e.slice(0,n),e.slice(n)]}exports.splitAt=t;
+//# sourceMappingURL=splitAt.cjs.map

package/dist/splitAt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitAt.cjs","names":["purry"],"sources":["../src/splitAt.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Splits a given array at a given index.\n *\n * @param array - The array to split.\n * @param index - The index to split at.\n * @signature\n *    splitAt(array, index)\n * @example\n *    splitAt([1, 2, 3], 1) // => [[1], [2, 3]]\n *    splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]\n * @dataFirst\n * @category Array\n */\nexport function splitAt<T>(array: readonly T[], index: number): [T[], T[]];\n\n/**\n * Splits a given array at a given index.\n *\n * @param index - The index to split at.\n * @signature\n *    splitAt(index)(array)\n * @example\n *    splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]\n *    splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]\n * @dataLast\n * @category Array\n */\nexport function splitAt<T>(index: number): (array: readonly T[]) => [T[], T[]];\n\nexport function splitAt(...args: readonly unknown[]): unknown {\n  return purry(splitAtImplementation, args);\n}\n\nfunction splitAtImplementation<T>(\n  array: readonly T[],\n  index: number,\n): [T[], T[]] {\n  const effectiveIndex = Math.max(\n    Math.min(index < 0 ? array.length + index : index, array.length),\n    0,\n  );\n  return [array.slice(0, effectiveIndex), array.slice(effectiveIndex)];\n}\n"],"mappings":"kGA+BA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACY,CACZ,IAAM,EAAiB,KAAK,IAC1B,KAAK,IAAI,EAAQ,EAAI,EAAM,OAAS,EAAQ,EAAO,EAAM,OAAO,CAChE,EACD,CACD,MAAO,CAAC,EAAM,MAAM,EAAG,EAAe,CAAE,EAAM,MAAM,EAAe,CAAC"}

package/dist/splitAt.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e,t){let n=Math.max(Math.min(t<0?e.length+t:t,e.length),0);return[e.slice(0,n),e.slice(n)]}export{t as splitAt};
+//# sourceMappingURL=splitAt.js.map

package/dist/splitAt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitAt.js","names":[],"sources":["../src/splitAt.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Splits a given array at a given index.\n *\n * @param array - The array to split.\n * @param index - The index to split at.\n * @signature\n *    splitAt(array, index)\n * @example\n *    splitAt([1, 2, 3], 1) // => [[1], [2, 3]]\n *    splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]\n * @dataFirst\n * @category Array\n */\nexport function splitAt<T>(array: readonly T[], index: number): [T[], T[]];\n\n/**\n * Splits a given array at a given index.\n *\n * @param index - The index to split at.\n * @signature\n *    splitAt(index)(array)\n * @example\n *    splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]\n *    splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]\n * @dataLast\n * @category Array\n */\nexport function splitAt<T>(index: number): (array: readonly T[]) => [T[], T[]];\n\nexport function splitAt(...args: readonly unknown[]): unknown {\n  return purry(splitAtImplementation, args);\n}\n\nfunction splitAtImplementation<T>(\n  array: readonly T[],\n  index: number,\n): [T[], T[]] {\n  const effectiveIndex = Math.max(\n    Math.min(index < 0 ? array.length + index : index, array.length),\n    0,\n  );\n  return [array.slice(0, effectiveIndex), array.slice(effectiveIndex)];\n}\n"],"mappings":"mCA+BA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACY,CACZ,IAAM,EAAiB,KAAK,IAC1B,KAAK,IAAI,EAAQ,EAAI,EAAM,OAAS,EAAQ,EAAO,EAAM,OAAO,CAChE,EACD,CACD,MAAO,CAAC,EAAM,MAAM,EAAG,EAAe,CAAE,EAAM,MAAM,EAAe,CAAC"}

package/dist/splitWhen.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}function n(e,t){let n=e.findIndex(t);return n===-1?[[...e],[]]:[e.slice(0,n),e.slice(n)]}exports.splitWhen=t;
+//# sourceMappingURL=splitWhen.cjs.map

package/dist/splitWhen.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitWhen.cjs","names":["purry"],"sources":["../src/splitWhen.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Splits a given array at the first index where the given predicate returns true.\n *\n * @param data - The array to split.\n * @param predicate - The predicate.\n * @signature\n *    splitWhen(array, fn)\n * @example\n *    splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]\n * @dataFirst\n * @category Array\n */\nexport function splitWhen<T>(\n  data: readonly T[],\n  predicate: (item: T, index: number, data: readonly T[]) => boolean,\n): [T[], T[]];\n\n/**\n * Splits a given array at an index where the given predicate returns true.\n *\n * @param predicate - The predicate.\n * @signature\n *    splitWhen(fn)(array)\n * @example\n *    splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]\n * @dataLast\n * @category Array\n */\nexport function splitWhen<T>(\n  predicate: (item: T, index: number, data: readonly T[]) => boolean,\n): (array: readonly T[]) => [T[], T[]];\n\nexport function splitWhen(...args: readonly unknown[]): unknown {\n  return purry(splitWhenImplementation, args);\n}\n\nfunction splitWhenImplementation<T>(\n  data: readonly T[],\n  predicate: (item: T, index: number, data: readonly T[]) => boolean,\n): [T[], T[]] {\n  const index = data.findIndex(predicate);\n  return index === -1\n    ? [[...data], []]\n    : [data.slice(0, index), data.slice(index)];\n}\n"],"mappings":"kGAkCA,SAAgB,EAAU,GAAG,EAAmC,CAC9D,OAAOA,EAAAA,MAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACY,CACZ,IAAM,EAAQ,EAAK,UAAU,EAAU,CACvC,OAAO,IAAU,GACb,CAAC,CAAC,GAAG,EAAK,CAAE,EAAE,CAAC,CACf,CAAC,EAAK,MAAM,EAAG,EAAM,CAAE,EAAK,MAAM,EAAM,CAAC"}

package/dist/splitWhen.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e,t){let n=e.findIndex(t);return n===-1?[[...e],[]]:[e.slice(0,n),e.slice(n)]}export{t as splitWhen};
+//# sourceMappingURL=splitWhen.js.map

package/dist/splitWhen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitWhen.js","names":[],"sources":["../src/splitWhen.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Splits a given array at the first index where the given predicate returns true.\n *\n * @param data - The array to split.\n * @param predicate - The predicate.\n * @signature\n *    splitWhen(array, fn)\n * @example\n *    splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]\n * @dataFirst\n * @category Array\n */\nexport function splitWhen<T>(\n  data: readonly T[],\n  predicate: (item: T, index: number, data: readonly T[]) => boolean,\n): [T[], T[]];\n\n/**\n * Splits a given array at an index where the given predicate returns true.\n *\n * @param predicate - The predicate.\n * @signature\n *    splitWhen(fn)(array)\n * @example\n *    splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]\n * @dataLast\n * @category Array\n */\nexport function splitWhen<T>(\n  predicate: (item: T, index: number, data: readonly T[]) => boolean,\n): (array: readonly T[]) => [T[], T[]];\n\nexport function splitWhen(...args: readonly unknown[]): unknown {\n  return purry(splitWhenImplementation, args);\n}\n\nfunction splitWhenImplementation<T>(\n  data: readonly T[],\n  predicate: (item: T, index: number, data: readonly T[]) => boolean,\n): [T[], T[]] {\n  const index = data.findIndex(predicate);\n  return index === -1\n    ? [[...data], []]\n    : [data.slice(0, index), data.slice(index)];\n}\n"],"mappings":"mCAkCA,SAAgB,EAAU,GAAG,EAAmC,CAC9D,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACY,CACZ,IAAM,EAAQ,EAAK,UAAU,EAAU,CACvC,OAAO,IAAU,GACb,CAAC,CAAC,GAAG,EAAK,CAAE,EAAE,CAAC,CACf,CAAC,EAAK,MAAM,EAAG,EAAM,CAAE,EAAK,MAAM,EAAM,CAAC"}

package/dist/startsWith.cjs

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

package/dist/startsWith.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"startsWith.cjs","names":["purry"],"sources":["../src/startsWith.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether a string begins with the provided prefix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith)\n * method, but doesn't expose the `startPosition` parameter. To check from a\n * specific position, use\n * `startsWith(sliceString(data, startPosition), prefix)`.\n *\n * @param data - The input string.\n * @param prefix - The string to check for at the beginning.\n * @signature\n *   startsWith(data, prefix);\n * @example\n *   startsWith(\"hello world\", \"hello\"); // true\n *   startsWith(\"hello world\", \"world\"); // false\n * @dataFirst\n * @category String\n */\nexport function startsWith<T extends string, Prefix extends string>(\n  data: T,\n  prefix: string extends Prefix ? never : Prefix,\n): data is T & `${Prefix}${string}`;\nexport function startsWith(data: string, prefix: string): boolean;\n\n/**\n * Determines whether a string begins with the provided prefix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith)\n * method, but doesn't expose the `startPosition` parameter. To check from a\n * specific position, use\n * `startsWith(sliceString(data, startPosition), prefix)`.\n *\n * @param prefix - The string to check for at the beginning.\n * @signature\n *   startsWith(prefix)(data);\n * @example\n *   pipe(\"hello world\", startsWith(\"hello\")); // true\n *   pipe(\"hello world\", startsWith(\"world\")); // false\n * @dataLast\n * @category String\n */\nexport function startsWith<Prefix extends string>(\n  prefix: string extends Prefix ? never : Prefix,\n): <T extends string>(data: T) => data is T & `${Prefix}${string}`;\nexport function startsWith(prefix: string): (data: string) => boolean;\n\nexport function startsWith(...args: readonly unknown[]): unknown {\n  return purry(startsWithImplementation, args);\n}\n\nconst startsWithImplementation = (data: string, prefix: string): boolean =>\n  data.startsWith(prefix);\n"],"mappings":"kGAkDA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAOA,EAAAA,MAAM,EAA0B,EAAK,CAG9C,MAAM,GAA4B,EAAc,IAC9C,EAAK,WAAW,EAAO"}

package/dist/startsWith.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}const n=(e,t)=>e.startsWith(t);export{t as startsWith};
+//# sourceMappingURL=startsWith.js.map

package/dist/startsWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startsWith.js","names":[],"sources":["../src/startsWith.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether a string begins with the provided prefix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith)\n * method, but doesn't expose the `startPosition` parameter. To check from a\n * specific position, use\n * `startsWith(sliceString(data, startPosition), prefix)`.\n *\n * @param data - The input string.\n * @param prefix - The string to check for at the beginning.\n * @signature\n *   startsWith(data, prefix);\n * @example\n *   startsWith(\"hello world\", \"hello\"); // true\n *   startsWith(\"hello world\", \"world\"); // false\n * @dataFirst\n * @category String\n */\nexport function startsWith<T extends string, Prefix extends string>(\n  data: T,\n  prefix: string extends Prefix ? never : Prefix,\n): data is T & `${Prefix}${string}`;\nexport function startsWith(data: string, prefix: string): boolean;\n\n/**\n * Determines whether a string begins with the provided prefix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith)\n * method, but doesn't expose the `startPosition` parameter. To check from a\n * specific position, use\n * `startsWith(sliceString(data, startPosition), prefix)`.\n *\n * @param prefix - The string to check for at the beginning.\n * @signature\n *   startsWith(prefix)(data);\n * @example\n *   pipe(\"hello world\", startsWith(\"hello\")); // true\n *   pipe(\"hello world\", startsWith(\"world\")); // false\n * @dataLast\n * @category String\n */\nexport function startsWith<Prefix extends string>(\n  prefix: string extends Prefix ? never : Prefix,\n): <T extends string>(data: T) => data is T & `${Prefix}${string}`;\nexport function startsWith(prefix: string): (data: string) => boolean;\n\nexport function startsWith(...args: readonly unknown[]): unknown {\n  return purry(startsWithImplementation, args);\n}\n\nconst startsWithImplementation = (data: string, prefix: string): boolean =>\n  data.startsWith(prefix);\n"],"mappings":"mCAkDA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAO,EAAM,EAA0B,EAAK,CAG9C,MAAM,GAA4B,EAAc,IAC9C,EAAK,WAAW,EAAO"}

package/dist/stringToPath.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=/^(?:0|[1-9][0-9]*)$/u;function t(n){let r=[],i=/\.{0,4096}(?<propName>[^.[\]]+)|\['(?<quoted>.{0,4096}?)'\]|\["(?<doubleQuoted>.{0,4096}?)"\]|\[(?<unquoted>.{0,4096}?)\]/uy,a;for(;(a=i.exec(n))!==null;){let{propName:n,quoted:i,doubleQuoted:o,unquoted:s}=a.groups;if(s!==void 0){r.push(...t(s));continue}r.push(n===void 0?i??o:e.test(n)?Number(n):n)}return r}exports.stringToPath=t;
+//# sourceMappingURL=stringToPath.cjs.map

package/dist/stringToPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringToPath.cjs","names":[],"sources":["../src/stringToPath.ts"],"sourcesContent":["import type { IsNumericLiteral, IsStringLiteral } from \"type-fest\";\n\n// This is the most efficient way to check an arbitrary string if it is a simple\n// non-negative integer. We use character ranges instead of the `\\d` character\n// class to avoid matching non-ascii digits (e.g. Arabic-Indic digits), while\n// maintaining that the regular expression supports unicode.\nconst NON_NEGATIVE_INTEGER_RE = /^(?:0|[1-9][0-9]*)$/u;\n\ntype StringToPath<S> =\n  // We can only compute the path type for literals that TypeScript can\n  // break down further into parts.\n  IsStringLiteral<S> extends true ? StringToPathImpl<S> : (string | number)[];\n\ntype StringToPathImpl<S> =\n  // We start by checking the 2 quoted variants of the square bracket access\n  // syntax. We do this in a single check and not in a subsequent check that\n  // would only extract the quoted part so that we can catch cases where the\n  // quoted part itself contains square brackets. This allows TypeScript to be\n  // \"greedy\" about what it infers into Quoted and DoubleQuoted.\n  S extends `${infer Head}['${infer Quoted}']${infer Tail}`\n    ? [...StringToPath<Head>, Quoted, ...StringToPath<Tail>]\n    : S extends `${infer Head}[\"${infer DoubleQuoted}\"]${infer Tail}`\n      ? [...StringToPath<Head>, DoubleQuoted, ...StringToPath<Tail>]\n      : // If we have an unquoted property access we also need to run the\n        // contents recursively too (unlike the quoted variants above).\n        S extends `${infer Head}[${infer Unquoted}]${infer Tail}`\n        ? [\n            ...StringToPath<Head>,\n            ...StringToPath<Unquoted>,\n            ...StringToPath<Tail>,\n          ]\n        : // Finally, we process any dots one after the other from left to\n          // right. TypeScript will be non-greedy here, putting *everything*\n          // after the first dot into the Tail.\n          S extends `${infer Head}.${infer Tail}`\n          ? [...StringToPath<Head>, ...StringToPath<Tail>]\n          : // Finally we need to handle the few cases of simple literals.\n            \"\" extends S\n            ? // There are some edge-cases where Lodash will try to access an\n              // empty property, but those seem nonsensical in practice so we\n              // prefer just skipping these cases.\n              []\n            : // We differ from Lodash in the way we handle numbers. Lodash\n              // returns everything in the path as a string, and relies on JS to\n              // coerce array accessors to numbers (or the other way around in\n              // practice, e.g., `myArray[123] === myArray['123']`), but from a\n              // typing perspective the two are not the same and we need the\n              // path to be accurate about it.\n              S extends `${infer N extends number}`\n              ? [\n                  // TypeScript considers \" 123 \" to still extend `${number}`,\n                  // but would type is as `string` instead of a literal. We\n                  // can use that fact to make sure we only consider simple\n                  // number literals as numbers, and take the rest as strings.\n                  IsNumericLiteral<N> extends true ? N : S,\n                ]\n              : // This simplest form of a path is just a single string literal.\n                [S];\n\n/**\n * A utility to allow JSONPath-like strings to be used in other utilities which\n * take an array of path segments as input (e.g. `prop`, `setPath`, etc...).\n * The main purpose of this utility is to act as a bridge between the runtime\n * implementation that converts the path to an array, and the type-system that\n * parses the path string **type** into an array **type**. This type allows us\n * to return fine-grained types and to enforce correctness at the type-level.\n *\n * We **discourage** using this utility for new code. This utility is for legacy\n * code that already contains path strings (which are accepted by Lodash). We\n * strongly recommend using *path arrays* instead as they provide better\n * developer experience via significantly faster type-checking, fine-grained\n * error messages, and automatic typeahead suggestions for each segment of the\n * path.\n *\n * *There are a bunch of limitations to this utility derived from the\n * limitations of the type itself, these are usually edge-cases around deeply\n * nested paths, escaping, whitespaces, and empty segments. This is true even\n * in cases where the runtime implementation can better handle them, this is\n * intentional. See the tests for this utility for more details and the\n * expected outputs*.\n *\n * @param path - A string path.\n * @signature\n *   stringToPath(path)\n * @example\n *   stringToPath('a.b[0].c') // => ['a', 'b', 0, 'c']\n * @dataFirst\n * @category Utility\n */\nexport function stringToPath<const Path extends string>(\n  path: Path,\n): StringToPath<Path> {\n  const result: (string | number)[] = [];\n\n  // There are four possible ways to define a path segment::\n  // - `propName`: is used to parse dot-notation paths, e.g. 'foo.bar.baz', we\n  // allow multiple sequential dots because our type allows them, but they are\n  // semantically meaningless. Note that this would also allow strings starting\n  // with a dot, e.g. `.foo`, this is fine because the dot itself is just used\n  // as a separator and is ignored in the final path.\n  // - `quoted`, `doubleQuoted`: used within square bracket notation to prevent\n  // any recursive parsing of their contents. As for the type itself, we only\n  // allow quote symbols to appear immediately after the opening square bracket\n  // and immediately before the closing square bracket, this allows us to handle\n  // more gracefully cases where a quote symbol might appear within the quoted\n  // part.\n  // - `unquoted`: If the contents of the square brackets are not quoted they\n  // will match this group (this is why the order is important here!). Contents\n  // of this group get parsed *recursively*.\n  //\n  // NOTE: We limit all repeats to 4096 characters to avoid a possible attack\n  // vector when the input to this function is controlled by the user. This is\n  // due to a DoS timing attack because regex backtracking is non-linear.\n  // @see: https://codeql.github.com/codeql-query-help/javascript/js-polynomial-redos/\n  const pathSegmentRe =\n    /\\.{0,4096}(?<propName>[^.[\\]]+)|\\['(?<quoted>.{0,4096}?)'\\]|\\[\"(?<doubleQuoted>.{0,4096}?)\"\\]|\\[(?<unquoted>.{0,4096}?)\\]/uy;\n\n  let match: RegExpExecArray | null;\n  while ((match = pathSegmentRe.exec(path)) !== null) {\n    const { propName, quoted, doubleQuoted, unquoted } = match.groups!;\n\n    if (unquoted !== undefined) {\n      result.push(...stringToPath(unquoted));\n      continue;\n    }\n\n    result.push(\n      propName === undefined\n        ? (quoted ?? doubleQuoted!)\n        : // The only way to differentiate between array indices and properties\n          // is to check if the property is a non-negative integer. In those\n          // cases we perform the conversion (unlike Lodash).\n          NON_NEGATIVE_INTEGER_RE.test(propName)\n          ? Number(propName)\n          : propName,\n    );\n  }\n\n  return result;\n}\n"],"mappings":"mEAMA,MAAM,EAA0B,uBAmFhC,SAAgB,EACd,EACoB,CACpB,IAAM,EAA8B,EAAE,CAsBhC,EACJ,8HAEE,EACJ,MAAQ,EAAQ,EAAc,KAAK,EAAK,IAAM,MAAM,CAClD,GAAM,CAAE,WAAU,SAAQ,eAAc,YAAa,EAAM,OAE3D,GAAI,IAAa,IAAA,GAAW,CAC1B,EAAO,KAAK,GAAG,EAAa,EAAS,CAAC,CACtC,SAGF,EAAO,KACL,IAAa,IAAA,GACR,GAAU,EAIX,EAAwB,KAAK,EAAS,CACpC,OAAO,EAAS,CAChB,EACP,CAGH,OAAO"}

package/dist/stringToPath.js

@@ -0,0 +1,2 @@
+const e=/^(?:0|[1-9][0-9]*)$/u;function t(n){let r=[],i=/\.{0,4096}(?<propName>[^.[\]]+)|\['(?<quoted>.{0,4096}?)'\]|\["(?<doubleQuoted>.{0,4096}?)"\]|\[(?<unquoted>.{0,4096}?)\]/uy,a;for(;(a=i.exec(n))!==null;){let{propName:n,quoted:i,doubleQuoted:o,unquoted:s}=a.groups;if(s!==void 0){r.push(...t(s));continue}r.push(n===void 0?i??o:e.test(n)?Number(n):n)}return r}export{t as stringToPath};
+//# sourceMappingURL=stringToPath.js.map

package/dist/stringToPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringToPath.js","names":[],"sources":["../src/stringToPath.ts"],"sourcesContent":["import type { IsNumericLiteral, IsStringLiteral } from \"type-fest\";\n\n// This is the most efficient way to check an arbitrary string if it is a simple\n// non-negative integer. We use character ranges instead of the `\\d` character\n// class to avoid matching non-ascii digits (e.g. Arabic-Indic digits), while\n// maintaining that the regular expression supports unicode.\nconst NON_NEGATIVE_INTEGER_RE = /^(?:0|[1-9][0-9]*)$/u;\n\ntype StringToPath<S> =\n  // We can only compute the path type for literals that TypeScript can\n  // break down further into parts.\n  IsStringLiteral<S> extends true ? StringToPathImpl<S> : (string | number)[];\n\ntype StringToPathImpl<S> =\n  // We start by checking the 2 quoted variants of the square bracket access\n  // syntax. We do this in a single check and not in a subsequent check that\n  // would only extract the quoted part so that we can catch cases where the\n  // quoted part itself contains square brackets. This allows TypeScript to be\n  // \"greedy\" about what it infers into Quoted and DoubleQuoted.\n  S extends `${infer Head}['${infer Quoted}']${infer Tail}`\n    ? [...StringToPath<Head>, Quoted, ...StringToPath<Tail>]\n    : S extends `${infer Head}[\"${infer DoubleQuoted}\"]${infer Tail}`\n      ? [...StringToPath<Head>, DoubleQuoted, ...StringToPath<Tail>]\n      : // If we have an unquoted property access we also need to run the\n        // contents recursively too (unlike the quoted variants above).\n        S extends `${infer Head}[${infer Unquoted}]${infer Tail}`\n        ? [\n            ...StringToPath<Head>,\n            ...StringToPath<Unquoted>,\n            ...StringToPath<Tail>,\n          ]\n        : // Finally, we process any dots one after the other from left to\n          // right. TypeScript will be non-greedy here, putting *everything*\n          // after the first dot into the Tail.\n          S extends `${infer Head}.${infer Tail}`\n          ? [...StringToPath<Head>, ...StringToPath<Tail>]\n          : // Finally we need to handle the few cases of simple literals.\n            \"\" extends S\n            ? // There are some edge-cases where Lodash will try to access an\n              // empty property, but those seem nonsensical in practice so we\n              // prefer just skipping these cases.\n              []\n            : // We differ from Lodash in the way we handle numbers. Lodash\n              // returns everything in the path as a string, and relies on JS to\n              // coerce array accessors to numbers (or the other way around in\n              // practice, e.g., `myArray[123] === myArray['123']`), but from a\n              // typing perspective the two are not the same and we need the\n              // path to be accurate about it.\n              S extends `${infer N extends number}`\n              ? [\n                  // TypeScript considers \" 123 \" to still extend `${number}`,\n                  // but would type is as `string` instead of a literal. We\n                  // can use that fact to make sure we only consider simple\n                  // number literals as numbers, and take the rest as strings.\n                  IsNumericLiteral<N> extends true ? N : S,\n                ]\n              : // This simplest form of a path is just a single string literal.\n                [S];\n\n/**\n * A utility to allow JSONPath-like strings to be used in other utilities which\n * take an array of path segments as input (e.g. `prop`, `setPath`, etc...).\n * The main purpose of this utility is to act as a bridge between the runtime\n * implementation that converts the path to an array, and the type-system that\n * parses the path string **type** into an array **type**. This type allows us\n * to return fine-grained types and to enforce correctness at the type-level.\n *\n * We **discourage** using this utility for new code. This utility is for legacy\n * code that already contains path strings (which are accepted by Lodash). We\n * strongly recommend using *path arrays* instead as they provide better\n * developer experience via significantly faster type-checking, fine-grained\n * error messages, and automatic typeahead suggestions for each segment of the\n * path.\n *\n * *There are a bunch of limitations to this utility derived from the\n * limitations of the type itself, these are usually edge-cases around deeply\n * nested paths, escaping, whitespaces, and empty segments. This is true even\n * in cases where the runtime implementation can better handle them, this is\n * intentional. See the tests for this utility for more details and the\n * expected outputs*.\n *\n * @param path - A string path.\n * @signature\n *   stringToPath(path)\n * @example\n *   stringToPath('a.b[0].c') // => ['a', 'b', 0, 'c']\n * @dataFirst\n * @category Utility\n */\nexport function stringToPath<const Path extends string>(\n  path: Path,\n): StringToPath<Path> {\n  const result: (string | number)[] = [];\n\n  // There are four possible ways to define a path segment::\n  // - `propName`: is used to parse dot-notation paths, e.g. 'foo.bar.baz', we\n  // allow multiple sequential dots because our type allows them, but they are\n  // semantically meaningless. Note that this would also allow strings starting\n  // with a dot, e.g. `.foo`, this is fine because the dot itself is just used\n  // as a separator and is ignored in the final path.\n  // - `quoted`, `doubleQuoted`: used within square bracket notation to prevent\n  // any recursive parsing of their contents. As for the type itself, we only\n  // allow quote symbols to appear immediately after the opening square bracket\n  // and immediately before the closing square bracket, this allows us to handle\n  // more gracefully cases where a quote symbol might appear within the quoted\n  // part.\n  // - `unquoted`: If the contents of the square brackets are not quoted they\n  // will match this group (this is why the order is important here!). Contents\n  // of this group get parsed *recursively*.\n  //\n  // NOTE: We limit all repeats to 4096 characters to avoid a possible attack\n  // vector when the input to this function is controlled by the user. This is\n  // due to a DoS timing attack because regex backtracking is non-linear.\n  // @see: https://codeql.github.com/codeql-query-help/javascript/js-polynomial-redos/\n  const pathSegmentRe =\n    /\\.{0,4096}(?<propName>[^.[\\]]+)|\\['(?<quoted>.{0,4096}?)'\\]|\\[\"(?<doubleQuoted>.{0,4096}?)\"\\]|\\[(?<unquoted>.{0,4096}?)\\]/uy;\n\n  let match: RegExpExecArray | null;\n  while ((match = pathSegmentRe.exec(path)) !== null) {\n    const { propName, quoted, doubleQuoted, unquoted } = match.groups!;\n\n    if (unquoted !== undefined) {\n      result.push(...stringToPath(unquoted));\n      continue;\n    }\n\n    result.push(\n      propName === undefined\n        ? (quoted ?? doubleQuoted!)\n        : // The only way to differentiate between array indices and properties\n          // is to check if the property is a non-negative integer. In those\n          // cases we perform the conversion (unlike Lodash).\n          NON_NEGATIVE_INTEGER_RE.test(propName)\n          ? Number(propName)\n          : propName,\n    );\n  }\n\n  return result;\n}\n"],"mappings":"AAMA,MAAM,EAA0B,uBAmFhC,SAAgB,EACd,EACoB,CACpB,IAAM,EAA8B,EAAE,CAsBhC,EACJ,8HAEE,EACJ,MAAQ,EAAQ,EAAc,KAAK,EAAK,IAAM,MAAM,CAClD,GAAM,CAAE,WAAU,SAAQ,eAAc,YAAa,EAAM,OAE3D,GAAI,IAAa,IAAA,GAAW,CAC1B,EAAO,KAAK,GAAG,EAAa,EAAS,CAAC,CACtC,SAGF,EAAO,KACL,IAAa,IAAA,GACR,GAAU,EAIX,EAAwB,KAAK,EAAS,CACpC,OAAO,EAAS,CAChB,EACP,CAGH,OAAO"}

package/dist/subtract.cjs

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