@vinicunca/perkakas 1.8.0 → 1.9.0

package/dist/sample-9vI5EmCM.d.cts

@@ -1,69 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { NTuple } from "./n-tuple-Co_jgwEn.cjs";
-import { PartialArray } from "./partial-array-CzOnr197.cjs";
-import { TupleParts } from "./tuple-parts-BIyABPYv.cjs";
-import { CoercedArray } from "./coerced-array-kVJtBrMl.cjs";
-import { FixedLengthArray, IsEqual, IsNever, NonNegativeInteger, Or, Writable } from "type-fest";
-
-//#region src/sample.d.ts
-type Sampled<T extends IterableContainer, N extends number> = Or<IsEqual<N, 0>, IsEqual<T['length'], 0>> extends true ? [] : IsNever<NonNegativeInteger<N>> extends true ? SampledPrimitive<T> : IsLongerThan<T, N> extends true ? SampledLiteral<T, N> : Writable<T>;
-/**
- * When N is not a non-negative integer **literal** we can't use it in our
- * reconstructing logic so we fallback to a simpler definition of the output of
- * sample, which is any sub-tuple shape of T, of **any length**.
- */
-type SampledPrimitive<T extends IterableContainer> = [...FixedSubTuples<TupleParts<T>['required']>, ...PartialArray<FixedSubTuples<TupleParts<T>['optional']>>, ...CoercedArray<TupleParts<T>['item']>, ...FixedSubTuples<TupleParts<T>['suffix']>];
-/**
- * Knowing N is a non-negative literal integer we can construct all sub-tuples
- * of T that are exactly N elements long.
- */
-type SampledLiteral<T extends IterableContainer, N extends number> = Extract<FixedSubTuples<[...TupleParts<T>['required'], ...(IsNever<TupleParts<T>['item']> extends true ? [] : NTuple<TupleParts<T>['item'], N>), ...TupleParts<T>['suffix']]>, FixedLengthArray<unknown, N>> | SubSampled<TupleParts<T>['required'], TupleParts<T>['item'], TupleParts<T>['suffix'], N>;
-type SubSampled<Prefix extends ReadonlyArray<unknown>, Item, Suffix extends ReadonlyArray<unknown>, N extends number> = IsLongerThan<[...Prefix, ...Suffix], N> extends true ? never : [...Prefix, ...Suffix]['length'] extends N ? never : [...Prefix, ...Suffix] | SubSampled<[...Prefix, Item], Item, Suffix, N>;
-type IsLongerThan<T extends ReadonlyArray<unknown>, N extends number> = IsEqual<T[N], undefined> extends true ? false : true;
-type FixedSubTuples<T> = T extends readonly [infer Head, ...infer Rest] ? FixedSubTuples<Rest> | [Head, ...FixedSubTuples<Rest>] : [];
-/**
- * Returns a random subset of size `sampleSize` from `array`.
- *
- * Maintains and infers most of the typing information that could be passed
- * along to the output. This means that when using tuples, the output will be
- * a tuple too, and when using literals, those literals would be preserved.
- *
- * The items in the result are kept in the same order as they are in the input.
- * If you need to get a shuffled response you can pipe the shuffle function
- * after this one.
- *
- * @param data - The array.
- * @param sampleSize - The number of elements to take.
- * @signature
- *    P.sample(array, sampleSize)
- * @example
- *    P.sample(["hello", "world"], 1); // => ["hello"] // typed string[]
- *    P.sample(["hello", "world"] as const, 1); // => ["world"] // typed ["hello" | "world"]
- * @dataFirst
- * @category Array
- */
-declare function sample<const T extends IterableContainer, N extends number = number>(data: T, sampleSize: N): Sampled<T, N>;
-/**
- * Returns a random subset of size `sampleSize` from `array`.
- *
- * Maintains and infers most of the typing information that could be passed
- * along to the output. This means that when using tuples, the output will be
- * a tuple too, and when using literals, those literals would be preserved.
- *
- * The items in the result are kept in the same order as they are in the input.
- * If you need to get a shuffled response you can pipe the shuffle function
- * after this one.
- *
- * @param sampleSize - The number of elements to take.
- * @signature
- *    P.sample(sampleSize)(array)
- * @example
- *    P.sample(1)(["hello", "world"]); // => ["hello"] // typed string[]
- *    P.sample(1)(["hello", "world"] as const); // => ["world"] // typed ["hello" | "world"]
- * @dataLast
- * @category Array
- */
-declare function sample<const T extends IterableContainer, N extends number = number>(sampleSize: N): (data: T) => Sampled<T, N>;
-//#endregion
-export { sample };
-//# sourceMappingURL=sample-9vI5EmCM.d.cts.map

package/dist/sample-9vI5EmCM.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sample-9vI5EmCM.d.cts","names":[],"sources":["../src/sample.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAeK,kBAAkB,uCACnB,GAAG,QAAQ,OAAO,QAAQ,qCAGxB,QAAQ,mBAAmB,mBACzB,iBAAiB,KACjB,aAAa,GAAG,kBACd,eAAe,GAAG,KAIlB,SAAS;;AAd4C;;;;KAqB1D,gBAjBE,CAAA,UAiByB,iBAjBzB,CAAA,GAAA,IAkBF,cAlByB,CAkBV,UAlBU,CAkBC,CAlBD,CAAA,CAAA,UAAA,CAAA,CAAA,KAoBzB,YApBiB,CAoBJ,cApBI,CAoBW,UApBX,CAoBsB,CApBtB,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,KAqBjB,YArBD,CAqBc,UArBd,CAqByB,CArBzB,CAAA,CAAA,MAAA,CAAA,CAAA,KAsBC,cAnB4B,CAmBb,UAnBa,CAmBF,CAnBE,CAAA,CAAA,QAAA,CAAA,CAAA;;;;;KAyB5B,cAvBmB,CAAA,UAuBM,iBAvBN,EAAA,UAAA,MAAA,CAAA,GAwBlB,OAxBkB,CAyBlB,cAzBkB,CAAA,IA2BX,UA3BL,CA2BgB,CA3BhB,CAAA,CAAA,UAAA,CAAA,KACiB,CA+BX,OA/BW,CA+BH,UA/BG,CA+BQ,CA/BR,CAAA,CAAA,MAAA,CAAA,CAAA,SAAA,IAAA,GAAA,EAAA,GAiCX,MAjCW,CAiCJ,UAjCI,CAiCO,CAjCP,CAAA,CAAA,MAAA,CAAA,EAiCmB,CAjCnB,CAAA,CAAA,KAkCZ,UAlCe,CAkCJ,CAlCI,CAAA,CAAA,QAAA,CAAA,IAsCtB,gBAtCI,CAAA,OAAA,EAsCsB,CAtCtB,CAAA,CAAA,GA2CJ,UA3CI,CA4CJ,UA5CI,CA4CO,CA5CP,CAAA,CAAA,UAAA,CAAA,EA8CJ,UA9CI,CA8CO,CA9CP,CAAA,CAAA,MAAA,CAAA,EA+CJ,UA/CI,CA+CO,CA/CP,CAAA,CAAA,QAAA,CAAA,EAgDJ,CAhDI,CAAA;KAsDL,UAlDc,CAAA,eAmDF,aAnDE,CAAA,OAAA,CAAA,EAAA,IAAA,EAAA,eAqDF,aArDE,CAAA,OAAA,CAAA,EAAA,UAAA,MAAA,CAAA,GAwDf,YAxDe,CAAA,CAAA,GAwDE,MAxDF,EAAA,GAwDa,MAxDb,CAAA,EAwDsB,CAxDtB,CAAA,SAAA,IAAA,GAAA,KAAA,GAAA,CAAA,GA2DT,MA3DS,EAAA,GA2DE,MA3DF,CAAA,CAAA,QAAA,CAAA,SA2D4B,CA3D5B,GAAA,KAAA,GAAA,CAAA,GA6DL,MA7DK,EAAA,GA6DM,MA7DN,CAAA,GA6DgB,UA7DhB,CAAA,CAAA,GA6D+B,MA7D/B,EA6DuC,IA7DvC,CAAA,EA6D8C,IA7D9C,EA6DoD,MA7DpD,EA6D4D,CA7D5D,CAAA;KA+Dd,YA/DK,CAAA,UA+DkB,aA/DlB,CAAA,OAAA,CAAA,EAAA,UAAA,MAAA,CAAA,GAmEN,OAnEM,CAmEE,CAnEF,CAmEI,CAnEJ,CAAA,EAAA,SAAA,CAAA,SAAA,IAAA,GAAA,KAAA,GAAA,IAAA;KAsEL,cAtEa,CAAA,CAAA,CAAA,GAsEO,CAtEP,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAwEd,cAxEc,CAwEC,IAxED,CAAA,GAAA,CAwEU,IAxEV,EAAA,GAwEmB,cAxEnB,CAwEkC,IAxElC,CAAA,CAAA,GAAA,EAAA;AAAA;;;;;;;;;;;;;;;;;AAYC;;;;AAUN,iBA0EG,MA1EH,CAAA,gBA0E0B,iBA1E1B,EAAA,UAAA,MAAA,GAAA,MAAA,CAAA,CAAA,IAAA,EA2EL,CA3EK,EAAA,UAAA,EA4EC,CA5ED,CAAA,EA6EV,OA7EU,CA6EF,CA7EE,EA6EC,CA7ED,CAAA;;;;;;;;;;;;;;;;;;;;;AAiBP,iBAkFU,MAlFV,CAAA,gBAkFiC,iBAlFjC,EAAA,UAAA,MAAA,GAAA,MAAA,CAAA,CAAA,UAAA,EAmFQ,CAnFR,CAAA,EAAA,CAAA,IAAA,EAoFI,CApFJ,EAAA,GAoFU,OApFV,CAoFkB,CApFlB,EAoFqB,CApFrB,CAAA"}

package/dist/sample-BHIZQL57.d.ts

@@ -1,69 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { NTuple } from "./n-tuple-BELi5yRe.js";
-import { PartialArray } from "./partial-array-IoGI5gCo.js";
-import { TupleParts } from "./tuple-parts-BxpZLJ7r.js";
-import { CoercedArray } from "./coerced-array-DyA0Yc12.js";
-import { FixedLengthArray, IsEqual, IsNever, NonNegativeInteger, Or, Writable } from "type-fest";
-
-//#region src/sample.d.ts
-type Sampled<T extends IterableContainer, N extends number> = Or<IsEqual<N, 0>, IsEqual<T['length'], 0>> extends true ? [] : IsNever<NonNegativeInteger<N>> extends true ? SampledPrimitive<T> : IsLongerThan<T, N> extends true ? SampledLiteral<T, N> : Writable<T>;
-/**
- * When N is not a non-negative integer **literal** we can't use it in our
- * reconstructing logic so we fallback to a simpler definition of the output of
- * sample, which is any sub-tuple shape of T, of **any length**.
- */
-type SampledPrimitive<T extends IterableContainer> = [...FixedSubTuples<TupleParts<T>['required']>, ...PartialArray<FixedSubTuples<TupleParts<T>['optional']>>, ...CoercedArray<TupleParts<T>['item']>, ...FixedSubTuples<TupleParts<T>['suffix']>];
-/**
- * Knowing N is a non-negative literal integer we can construct all sub-tuples
- * of T that are exactly N elements long.
- */
-type SampledLiteral<T extends IterableContainer, N extends number> = Extract<FixedSubTuples<[...TupleParts<T>['required'], ...(IsNever<TupleParts<T>['item']> extends true ? [] : NTuple<TupleParts<T>['item'], N>), ...TupleParts<T>['suffix']]>, FixedLengthArray<unknown, N>> | SubSampled<TupleParts<T>['required'], TupleParts<T>['item'], TupleParts<T>['suffix'], N>;
-type SubSampled<Prefix extends ReadonlyArray<unknown>, Item, Suffix extends ReadonlyArray<unknown>, N extends number> = IsLongerThan<[...Prefix, ...Suffix], N> extends true ? never : [...Prefix, ...Suffix]['length'] extends N ? never : [...Prefix, ...Suffix] | SubSampled<[...Prefix, Item], Item, Suffix, N>;
-type IsLongerThan<T extends ReadonlyArray<unknown>, N extends number> = IsEqual<T[N], undefined> extends true ? false : true;
-type FixedSubTuples<T> = T extends readonly [infer Head, ...infer Rest] ? FixedSubTuples<Rest> | [Head, ...FixedSubTuples<Rest>] : [];
-/**
- * Returns a random subset of size `sampleSize` from `array`.
- *
- * Maintains and infers most of the typing information that could be passed
- * along to the output. This means that when using tuples, the output will be
- * a tuple too, and when using literals, those literals would be preserved.
- *
- * The items in the result are kept in the same order as they are in the input.
- * If you need to get a shuffled response you can pipe the shuffle function
- * after this one.
- *
- * @param data - The array.
- * @param sampleSize - The number of elements to take.
- * @signature
- *    P.sample(array, sampleSize)
- * @example
- *    P.sample(["hello", "world"], 1); // => ["hello"] // typed string[]
- *    P.sample(["hello", "world"] as const, 1); // => ["world"] // typed ["hello" | "world"]
- * @dataFirst
- * @category Array
- */
-declare function sample<const T extends IterableContainer, N extends number = number>(data: T, sampleSize: N): Sampled<T, N>;
-/**
- * Returns a random subset of size `sampleSize` from `array`.
- *
- * Maintains and infers most of the typing information that could be passed
- * along to the output. This means that when using tuples, the output will be
- * a tuple too, and when using literals, those literals would be preserved.
- *
- * The items in the result are kept in the same order as they are in the input.
- * If you need to get a shuffled response you can pipe the shuffle function
- * after this one.
- *
- * @param sampleSize - The number of elements to take.
- * @signature
- *    P.sample(sampleSize)(array)
- * @example
- *    P.sample(1)(["hello", "world"]); // => ["hello"] // typed string[]
- *    P.sample(1)(["hello", "world"] as const); // => ["world"] // typed ["hello" | "world"]
- * @dataLast
- * @category Array
- */
-declare function sample<const T extends IterableContainer, N extends number = number>(sampleSize: N): (data: T) => Sampled<T, N>;
-//#endregion
-export { sample };
-//# sourceMappingURL=sample-BHIZQL57.d.ts.map

package/dist/sample-BHIZQL57.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sample-BHIZQL57.d.ts","names":[],"sources":["../src/sample.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/sample-DEt8y7NC.js

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

package/dist/sample-DEt8y7NC.js.map

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

package/dist/set-C3uDSGtA.d.cts

@@ -1,40 +0,0 @@
-import { UpsertProp } from "./upsert-prop-Dtu5xY0L.cjs";
-
-//#region src/set.d.ts
-
-/**
- * Sets the `value` at `prop` of `object`.
- *
- * To add a new property to an object, or to override its type, use `addProp`
- * instead, and to set a property within a nested object use `setPath`.
- *
- * @param obj - The target method.
- * @param prop - The property name.
- * @param value - The value to set.
- * @signature
- *    P.set(obj, prop, value)
- * @example
- *    P.set({ a: 1 }, 'a', 2) // => { a: 2 }
- * @dataFirst
- * @category Object
- */
-declare function set<T, K extends keyof T, V extends Required<T>[K]>(obj: T, prop: K, value: V): UpsertProp<T, K, V>;
-/**
- * Sets the `value` at `prop` of `object`.
- *
- * To add a new property to an object, or to override it's type use `addProp`
- * instead.
- *
- * @param prop - The property name.
- * @param value - The value to set.
- * @signature
- *    P.set(prop, value)(obj)
- * @example
- *    P.pipe({ a: 1 }, P.set('a', 2)) // => { a: 2 }
- * @dataLast
- * @category Object
- */
-declare function set<T, K extends keyof T, V extends Required<T>[K]>(prop: K, value: V): (obj: T) => UpsertProp<T, K, V>;
-//#endregion
-export { set };
-//# sourceMappingURL=set-C3uDSGtA.d.cts.map

package/dist/set-C3uDSGtA.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set-C3uDSGtA.d.cts","names":[],"sources":["../src/set.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;;AAqBgB,iBArBA,GAqBG,CAAA,CAAA,EAAA,UAAA,MArBoB,CAqBpB,EAAA,UArBiC,QAqBjC,CArB0C,CAqB1C,CAAA,CArB6C,CAqB7C,CAAA,CAAA,CAAA,GAAA,EApBZ,CAoBY,EAAA,IAAA,EAnBX,CAmBW,EAAA,KAAA,EAlBV,CAkBU,CAAA,EAjBhB,UAiBgB,CAjBL,CAiBK,EAjBF,CAiBE,EAjBC,CAiBD,CAAA;;;;;;;;;;;;;;;;iBAAH,uBAAuB,aAAa,SAAS,GAAG,UACxD,UACC,UACA,MAAM,WAAW,GAAG,GAAG"}

package/dist/set-DXK1kRjm.js

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

package/dist/set-DXK1kRjm.js.map

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

package/dist/set-Dg5x0drC.d.ts

@@ -1,40 +0,0 @@
-import { UpsertProp } from "./upsert-prop-CE7fi_mP.js";
-
-//#region src/set.d.ts
-
-/**
- * Sets the `value` at `prop` of `object`.
- *
- * To add a new property to an object, or to override its type, use `addProp`
- * instead, and to set a property within a nested object use `setPath`.
- *
- * @param obj - The target method.
- * @param prop - The property name.
- * @param value - The value to set.
- * @signature
- *    P.set(obj, prop, value)
- * @example
- *    P.set({ a: 1 }, 'a', 2) // => { a: 2 }
- * @dataFirst
- * @category Object
- */
-declare function set<T, K extends keyof T, V extends Required<T>[K]>(obj: T, prop: K, value: V): UpsertProp<T, K, V>;
-/**
- * Sets the `value` at `prop` of `object`.
- *
- * To add a new property to an object, or to override it's type use `addProp`
- * instead.
- *
- * @param prop - The property name.
- * @param value - The value to set.
- * @signature
- *    P.set(prop, value)(obj)
- * @example
- *    P.pipe({ a: 1 }, P.set('a', 2)) // => { a: 2 }
- * @dataLast
- * @category Object
- */
-declare function set<T, K extends keyof T, V extends Required<T>[K]>(prop: K, value: V): (obj: T) => UpsertProp<T, K, V>;
-//#endregion
-export { set };
-//# sourceMappingURL=set-Dg5x0drC.d.ts.map

package/dist/set-Dg5x0drC.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set-Dg5x0drC.d.ts","names":[],"sources":["../src/set.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;;AAqBgB,iBArBA,GAqBG,CAAA,CAAA,EAAA,UAAA,MArBoB,CAqBpB,EAAA,UArBiC,QAqBjC,CArB0C,CAqB1C,CAAA,CArB6C,CAqB7C,CAAA,CAAA,CAAA,GAAA,EApBZ,CAoBY,EAAA,IAAA,EAnBX,CAmBW,EAAA,KAAA,EAlBV,CAkBU,CAAA,EAjBhB,UAiBgB,CAjBL,CAiBK,EAjBF,CAiBE,EAjBC,CAiBD,CAAA;;;;;;;;;;;;;;;;iBAAH,uBAAuB,aAAa,SAAS,GAAG,UACxD,UACC,UACA,MAAM,WAAW,GAAG,GAAG"}

package/dist/set-path-BBiEMMBi.d.cts

@@ -1,47 +0,0 @@
-import { PerkakasTypeError } from "./perkakas-type-error-0tHtaPbi.cjs";
-import { ValueOf } from "type-fest";
-
-//#region src/set-path.d.ts
-type Paths<T, Prefix extends ReadonlyArray<unknown> = []> = Prefix | (T extends object ? ValueOf<{ [K in ProperKeyOf<T>]-?: Paths<T[K], [...Prefix, K]> }> : PerkakasTypeError<'setPath', 'Can only compute paths objects', {
-  type: never;
-  metadata: T;
-}>) extends infer Path ? Readonly<Path> : never;
-/**
- * Array objects have all Array.prototype keys in their "keyof" type, which
- * is not what we'd expect from the operator. We only want the numeric keys
- * which represent proper elements of the array.
- */
-type ProperKeyOf<T> = Extract<keyof T, T extends ReadonlyArray<unknown> ? number : keyof T>;
-type ValueAtPath<T, Path> = Path extends readonly [infer Head extends keyof T, ...infer Rest] ? ValueAtPath<T[Head], Rest> : T;
-/**
- * Sets the value at `path` of `object`.
- *
- * For simple cases where the path is only one level deep, prefer `set` instead.
- *
- * @param data - The target method.
- * @param path - The array of properties.
- * @param value - The value to set.
- * @signature
- *    P.setPath(obj, path, value)
- * @example
- *    P.setPath({ a: { b: 1 } }, ['a', 'b'], 2) // => { a: { b: 2 } }
- * @dataFirst
- * @category Object
- */
-declare function setPath<T, Path extends Paths<T>>(data: T, path: Path, value: ValueAtPath<T, Path>): T;
-/**
- * Sets the value at `path` of `object`.
- *
- * @param path - The array of properties.
- * @param value - The value to set.
- * @signature
- *    P.setPath(path, value)(obj)
- * @example
- *    P.pipe({ a: { b: 1 } }, P.setPath(['a', 'b'], 2)) // { a: { b: 2 } }
- * @dataLast
- * @category Object
- */
-declare function setPath<T, Path extends Paths<T>, Value extends ValueAtPath<T, Path>>(path: Path, value: Value): (data: T) => T;
-//#endregion
-export { setPath };
-//# sourceMappingURL=set-path-BBiEMMBi.d.cts.map

package/dist/set-path-BBiEMMBi.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set-path-BBiEMMBi.d.cts","names":[],"sources":["../src/set-path.ts"],"sourcesContent":[],"mappings":";;;;KAIK,wBAAwB,+BACvB,UACC,mBACC,gBACM,YAAY,OAAO,MAAM,EAAE,QAAQ,QAAQ,KAPqB,CAAA,GAStE,iBANE,CAAA,SAAA,EAAA,gCAAA,EAAA;EAAA,IAAA,EAAA,KAAA;UAAmB,EASM,CATN;YACvB,KAAA,KAAA,GAgBA,QAhBA,CAgBS,IAhBT,CAAA,GAAA,KAAA;;;;;;KAwBD,WArB4C,CAAA,CAAA,CAAA,GAqB3B,OArB2B,CAAA,MAsBzC,CAtByC,EAuB/C,CAvB+C,SAuBrC,aAvBqC,CAAA,OAAA,CAAA,GAAA,MAAA,GAAA,MAuBG,CAvBH,CAAA;KA0B5C,WA1BoD,CAAA,CAAA,EAAA,IAAA,CAAA,GA0B7B,IA1B6B,SAAA,SAAA,MAAxB,cAAA,MA2BN,CA3BM,KADzB,KAAA,KAAA,IA+BJ,WAzB+B,CAyBnB,CAzBmB,CAyBjB,IAzBiB,CAAA,EAyBV,IAzBU,CAAA,GA0B/B,CA1B+B;;;;;AAQrB;;;;;;;;AAQe;;;AAMF,iBAqBX,OArBW,CAAA,CAAA,EAAA,aAqBa,KArBb,CAqBmB,CArBnB,CAAA,CAAA,CAAA,IAAA,EAsBnB,CAtBmB,EAAA,IAAA,EAuBnB,IAvBmB,EAAA,KAAA,EAwBlB,WAxBkB,CAwBN,CAxBM,EAwBH,IAxBG,CAAA,CAAA,EAyBxB,CAzBwB;;;;;;;AAqB3B;;;;;;AAGqB,iBAeL,OAfK,CAAA,CAAA,EAAA,aAiBN,KAjBM,CAiBA,CAjBA,CAAA,EAAA,cAmBL,WAnBK,CAmBO,CAnBP,EAmBU,IAnBV,CAAA,CAAA,CAAA,IAAA,EAoBb,IApBa,EAAA,KAAA,EAoBA,KApBA,CAAA,EAAA,CAAA,IAAA,EAoBe,CApBf,EAAA,GAoBqB,CApBrB"}

package/dist/set-path-BIWA01lW.d.ts

@@ -1,47 +0,0 @@
-import { PerkakasTypeError } from "./perkakas-type-error-Da3ni385.js";
-import { ValueOf } from "type-fest";
-
-//#region src/set-path.d.ts
-type Paths<T, Prefix extends ReadonlyArray<unknown> = []> = Prefix | (T extends object ? ValueOf<{ [K in ProperKeyOf<T>]-?: Paths<T[K], [...Prefix, K]> }> : PerkakasTypeError<'setPath', 'Can only compute paths objects', {
-  type: never;
-  metadata: T;
-}>) extends infer Path ? Readonly<Path> : never;
-/**
- * Array objects have all Array.prototype keys in their "keyof" type, which
- * is not what we'd expect from the operator. We only want the numeric keys
- * which represent proper elements of the array.
- */
-type ProperKeyOf<T> = Extract<keyof T, T extends ReadonlyArray<unknown> ? number : keyof T>;
-type ValueAtPath<T, Path> = Path extends readonly [infer Head extends keyof T, ...infer Rest] ? ValueAtPath<T[Head], Rest> : T;
-/**
- * Sets the value at `path` of `object`.
- *
- * For simple cases where the path is only one level deep, prefer `set` instead.
- *
- * @param data - The target method.
- * @param path - The array of properties.
- * @param value - The value to set.
- * @signature
- *    P.setPath(obj, path, value)
- * @example
- *    P.setPath({ a: { b: 1 } }, ['a', 'b'], 2) // => { a: { b: 2 } }
- * @dataFirst
- * @category Object
- */
-declare function setPath<T, Path extends Paths<T>>(data: T, path: Path, value: ValueAtPath<T, Path>): T;
-/**
- * Sets the value at `path` of `object`.
- *
- * @param path - The array of properties.
- * @param value - The value to set.
- * @signature
- *    P.setPath(path, value)(obj)
- * @example
- *    P.pipe({ a: { b: 1 } }, P.setPath(['a', 'b'], 2)) // { a: { b: 2 } }
- * @dataLast
- * @category Object
- */
-declare function setPath<T, Path extends Paths<T>, Value extends ValueAtPath<T, Path>>(path: Path, value: Value): (data: T) => T;
-//#endregion
-export { setPath };
-//# sourceMappingURL=set-path-BIWA01lW.d.ts.map

package/dist/set-path-BIWA01lW.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set-path-BIWA01lW.d.ts","names":[],"sources":["../src/set-path.ts"],"sourcesContent":[],"mappings":";;;;KAIK,wBAAwB,+BACvB,UACC,mBACC,gBACM,YAAY,OAAO,MAAM,EAAE,QAAQ,QAAQ,KAPqB,CAAA,GAStE,iBANE,CAAA,SAAA,EAAA,gCAAA,EAAA;EAAA,IAAA,EAAA,KAAA;UAAmB,EASM,CATN;YACvB,KAAA,KAAA,GAgBA,QAhBA,CAgBS,IAhBT,CAAA,GAAA,KAAA;;;;;;KAwBD,WArB4C,CAAA,CAAA,CAAA,GAqB3B,OArB2B,CAAA,MAsBzC,CAtByC,EAuB/C,CAvB+C,SAuBrC,aAvBqC,CAAA,OAAA,CAAA,GAAA,MAAA,GAAA,MAuBG,CAvBH,CAAA;KA0B5C,WA1BoD,CAAA,CAAA,EAAA,IAAA,CAAA,GA0B7B,IA1B6B,SAAA,SAAA,MAAxB,cAAA,MA2BN,CA3BM,KADzB,KAAA,KAAA,IA+BJ,WAzB+B,CAyBnB,CAzBmB,CAyBjB,IAzBiB,CAAA,EAyBV,IAzBU,CAAA,GA0B/B,CA1B+B;;;;;AAQrB;;;;;;;;AAQe;;;AAMF,iBAqBX,OArBW,CAAA,CAAA,EAAA,aAqBa,KArBb,CAqBmB,CArBnB,CAAA,CAAA,CAAA,IAAA,EAsBnB,CAtBmB,EAAA,IAAA,EAuBnB,IAvBmB,EAAA,KAAA,EAwBlB,WAxBkB,CAwBN,CAxBM,EAwBH,IAxBG,CAAA,CAAA,EAyBxB,CAzBwB;;;;;;;AAqB3B;;;;;;AAGqB,iBAeL,OAfK,CAAA,CAAA,EAAA,aAiBN,KAjBM,CAiBA,CAjBA,CAAA,EAAA,cAmBL,WAnBK,CAmBO,CAnBP,EAmBU,IAnBV,CAAA,CAAA,CAAA,IAAA,EAoBb,IApBa,EAAA,KAAA,EAoBA,KApBA,CAAA,EAAA,CAAA,IAAA,EAoBe,CApBf,EAAA,GAoBqB,CApBrB"}

package/dist/set-path-DpNQC1fV.js

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

package/dist/set-path-DpNQC1fV.js.map

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

package/dist/shuffle-BLhbIQQt.js

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

package/dist/shuffle-BLhbIQQt.js.map

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

package/dist/shuffle-BzeqMrKZ.d.ts

@@ -1,31 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { ReorderedArray } from "./reordered-array-BJtughHE.js";
-
-//#region src/shuffle.d.ts
-
-/**
- * Shuffles the input array, returning a new array with the same elements in a random order.
- *
- * @param items - The array to shuffle.
- * @signature
- *    P.shuffle(array)
- * @example
- *    P.shuffle([4, 2, 7, 5]) // => [7, 5, 4, 2]
- * @dataFirst
- * @category Array
- */
-declare function shuffle<T extends IterableContainer>(items: T): ReorderedArray<T>;
-/**
- * Shuffles the input array, returning a new array with the same elements in a random order.
- *
- * @signature
- *    P.shuffle()(array)
- * @example
- *    P.pipe([4, 2, 7, 5], P.shuffle()) // => [7, 5, 4, 2]
- * @dataLast
- * @category Array
- */
-declare function shuffle(): <T extends IterableContainer>(items: T) => ReorderedArray<T>;
-//#endregion
-export { shuffle };
-//# sourceMappingURL=shuffle-BzeqMrKZ.d.ts.map

package/dist/shuffle-BzeqMrKZ.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shuffle-BzeqMrKZ.d.ts","names":[],"sources":["../src/shuffle.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgBA;;;;;;;AAcA;;AAAsC,iBAdtB,OAcsB,CAAA,UAdJ,iBAcI,CAAA,CAAA,KAAA,EAb7B,CAa6B,CAAA,EAZnC,cAYmC,CAZpB,CAYoB,CAAA;;;;;;;;;;;iBAAtB,OAAA,CAAA,cAAsB,0BAC7B,MACJ,eAAe"}

package/dist/shuffle-CaSQtM8e.d.cts

@@ -1,31 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { ReorderedArray } from "./reordered-array-CNK-grX0.cjs";
-
-//#region src/shuffle.d.ts
-
-/**
- * Shuffles the input array, returning a new array with the same elements in a random order.
- *
- * @param items - The array to shuffle.
- * @signature
- *    P.shuffle(array)
- * @example
- *    P.shuffle([4, 2, 7, 5]) // => [7, 5, 4, 2]
- * @dataFirst
- * @category Array
- */
-declare function shuffle<T extends IterableContainer>(items: T): ReorderedArray<T>;
-/**
- * Shuffles the input array, returning a new array with the same elements in a random order.
- *
- * @signature
- *    P.shuffle()(array)
- * @example
- *    P.pipe([4, 2, 7, 5], P.shuffle()) // => [7, 5, 4, 2]
- * @dataLast
- * @category Array
- */
-declare function shuffle(): <T extends IterableContainer>(items: T) => ReorderedArray<T>;
-//#endregion
-export { shuffle };
-//# sourceMappingURL=shuffle-CaSQtM8e.d.cts.map

package/dist/shuffle-CaSQtM8e.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shuffle-CaSQtM8e.d.cts","names":[],"sources":["../src/shuffle.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgBA;;;;;;;AAcA;;AAAsC,iBAdtB,OAcsB,CAAA,UAdJ,iBAcI,CAAA,CAAA,KAAA,EAb7B,CAa6B,CAAA,EAZnC,cAYmC,CAZpB,CAYoB,CAAA;;;;;;;;;;;iBAAtB,OAAA,CAAA,cAAsB,0BAC7B,MACJ,eAAe"}

package/dist/sleep-BCki6kgY.d.cts

@@ -1,16 +0,0 @@
-//#region src/sleep.d.ts
-/**
- * Delay execution for a given number of milliseconds.
- *
- * @param timeout the number of milliseconds to wait
- *
- * @signature
- *  P.sleep(timeout)
- * @example
- *  P.sleep(1000); // => Promise<void>
- * @category Function
- */
-declare function sleep(timeout: number): Promise<void>;
-//#endregion
-export { sleep };
-//# sourceMappingURL=sleep-BCki6kgY.d.cts.map

package/dist/sleep-BCki6kgY.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sleep-BCki6kgY.d.cts","names":[],"sources":["../src/sleep.ts"],"sourcesContent":[],"mappings":";;AAWA;;;;;;;;;;iBAAgB,KAAA,mBAAwB"}

package/dist/sleep-BtY6g8Yq.d.ts

@@ -1,16 +0,0 @@
-//#region src/sleep.d.ts
-/**
- * Delay execution for a given number of milliseconds.
- *
- * @param timeout the number of milliseconds to wait
- *
- * @signature
- *  P.sleep(timeout)
- * @example
- *  P.sleep(1000); // => Promise<void>
- * @category Function
- */
-declare function sleep(timeout: number): Promise<void>;
-//#endregion
-export { sleep };
-//# sourceMappingURL=sleep-BtY6g8Yq.d.ts.map

package/dist/sleep-BtY6g8Yq.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sleep-BtY6g8Yq.d.ts","names":[],"sources":["../src/sleep.ts"],"sourcesContent":[],"mappings":";;AAWA;;;;;;;;;;iBAAgB,KAAA,mBAAwB"}

package/dist/slice-string-BwFQg4Yf.d.ts

@@ -1,41 +0,0 @@
-//#region src/slice-string.d.ts
-/**
- * Extracts a section of this string and returns it as a new string, without
- * modifying the original string. Equivalent to `String.prototype.slice`.
- *
- * @param data - The string to extract from.
- * @param indexStart - The index of the first character to include in the
- * returned substring.
- * @param indexEnd - The index of the first character to exclude from the
- * returned substring.
- * @returns A new string containing the extracted section of the string.
- * @signature
- *    P.sliceString(data, indexStart, indexEnd)
- * @example
- *    P.sliceString("abcdefghijkl", 1) // => `bcdefghijkl`
- *    P.sliceString("abcdefghijkl", 4, 7) // => `efg`
- * @dataLast
- * @category String
- */
-declare function sliceString(data: string, indexStart: number, indexEnd?: number): string;
-/**
- * Extracts a section of this string and returns it as a new string, without
- * modifying the original string. Equivalent to `String.prototype.slice`.
- *
- * @param indexStart - The index of the first character to include in the
- * returned substring.
- * @param indexEnd - The index of the first character to exclude from the
- * returned substring, or `undefined` for the rest of the string.
- * @returns A new string containing the extracted section of the string.
- * @signature
- *    P.sliceString(indexStart, indexEnd)(string)
- * @example
- *    P.sliceString(1)("abcdefghijkl") // => `bcdefghijkl`
- *    P.sliceString(4, 7)("abcdefghijkl") // => `efg`
- * @dataLast
- * @category String
- */
-declare function sliceString(indexStart: number, indexEnd?: number): (data: string) => string;
-//#endregion
-export { sliceString };
-//# sourceMappingURL=slice-string-BwFQg4Yf.d.ts.map

package/dist/slice-string-BwFQg4Yf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slice-string-BwFQg4Yf.d.ts","names":[],"sources":["../src/slice-string.ts"],"sourcesContent":[],"mappings":";;AAkBA;AAuBA;;;;;;;;;;;;;;;;iBAvBgB,WAAA;;;;;;;;;;;;;;;;;;iBAuBA,WAAA"}

package/dist/slice-string-DejPzRCB.js

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

package/dist/slice-string-DejPzRCB.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"slice-string-DejPzRCB.js","names":[],"sources":["../src/slice-string.ts"],"sourcesContent":["/**\n * Extracts a section of this string and returns it as a new string, without\n * modifying the original string. Equivalent to `String.prototype.slice`.\n *\n * @param data - The string to extract from.\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    P.sliceString(data, indexStart, indexEnd)\n * @example\n *    P.sliceString(\"abcdefghijkl\", 1) // => `bcdefghijkl`\n *    P.sliceString(\"abcdefghijkl\", 4, 7) // => `efg`\n * @dataLast\n * @category String\n */\nexport function sliceString(\n  data: string,\n  indexStart: number,\n  indexEnd?: number,\n): string;\n\n/**\n * Extracts a section of this string and returns it as a new string, without\n * modifying the original string. Equivalent to `String.prototype.slice`.\n *\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring, or `undefined` for the rest of the string.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    P.sliceString(indexStart, indexEnd)(string)\n * @example\n *    P.sliceString(1)(\"abcdefghijkl\") // => `bcdefghijkl`\n *    P.sliceString(4, 7)(\"abcdefghijkl\") // => `efg`\n * @dataLast\n * @category String\n */\nexport function sliceString(\n  indexStart: number,\n  indexEnd?: number,\n): (data: string) => string;\n\nexport function sliceString(\n  dataOrIndexStart: number | string,\n  indexStartOrIndexEnd?: number,\n  indexEnd?: number,\n): unknown {\n  return typeof dataOrIndexStart === 'string'\n    ? dataOrIndexStart.slice(indexStartOrIndexEnd, indexEnd)\n    : (data: string) => data.slice(dataOrIndexStart, indexStartOrIndexEnd);\n}\n"],"mappings":"AA8CA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,SAC/B,EAAiB,MAAM,EAAsB,EAAS,CACrD,GAAiB,EAAK,MAAM,EAAkB,EAAqB"}