@vinicunca/perkakas 1.8.0 → 1.9.0

package/dist/add-BSDYck57.d.ts

@@ -0,0 +1,34 @@
+//#region src/add.d.ts
+/**
+ * Adds two numbers.
+ *
+ * @param value - The number.
+ * @param addend - The number to add to the value.
+ * @signature
+ *    P.add(value, addend);
+ * @example
+ *    P.add(10, 5) // => 15
+ *    P.add(10, -5) // => 5
+ * @dataFirst
+ * @category Number
+ */
+declare function add(value: bigint, addend: bigint): bigint;
+declare function add(value: number, addend: number): number;
+/**
+ * Adds two numbers.
+ *
+ * @param addend - The number to add to the value.
+ * @signature
+ *    P.add(addend)(value);
+ * @example
+ *    P.add(5)(10) // => 15
+ *    P.add(-5)(10) // => 5
+ *    P.map([1, 2, 3, 4], P.add(1)) // => [2, 3, 4, 5]
+ * @dataLast
+ * @category Number
+ */
+declare function add(addend: bigint): (value: bigint) => bigint;
+declare function add(addend: number): (value: number) => number;
+//#endregion
+export { add };
+//# sourceMappingURL=add-BSDYck57.d.ts.map

package/dist/add-BSDYck57.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-BSDYck57.d.ts","names":[],"sources":["../src/add.ts"],"sourcesContent":[],"mappings":";;AAeA;AACA;AAeA;AACA;;;;;;;;;iBAjBgB,GAAA;iBACA,GAAA;;;;;;;;;;;;;;iBAeA,GAAA;iBACA,GAAA"}

package/dist/add-prop-C9l3pJs4.d.ts

@@ -0,0 +1,46 @@
+import { UpsertProp } from "./upsert-prop-s1QJNSeE.js";
+
+//#region src/add-prop.d.ts
+
+/**
+ * Add a new property to an object.
+ *
+ * The function doesn't do any checks on the input object. If the property
+ * already exists it will be overwritten, and the type of the new value is not
+ * checked against the previous type.
+ *
+ * Use `set` to override values explicitly with better protections.
+ *
+ * @param obj the target object
+ * @param prop the property name
+ * @param value the property value
+ * @signature
+ *  P.addProp(obj, prop, value)
+ * @example
+ *  P.addProp({ firstName: 'john' }, 'lastName', 'doe'); // => {firstName: 'john', lastName: 'doe'}
+ * @dataFirst
+ * @category Object
+ */
+declare function addProp<T, K extends PropertyKey, V>(obj: T, prop: K, value: V): UpsertProp<T, K, V>;
+/**
+ * Add a new property to an object.
+ *
+ * The function doesn't do any checks on the input object. If the property
+ * already exists it will be overwritten, and the type of the new value is not
+ * checked against the previous type.
+ *
+ * Use `set` to override values explicitly with better protections.
+ *
+ * @param prop the property name
+ * @param value the property value
+ * @signature
+ *  P.addProp(prop, value)(obj)
+ * @example
+ *  P.addProp('lastName', 'doe')({ firstName: 'john' }); // => {firstName: 'john', lastName: 'doe'}
+ * @dataLast
+ * @category Object
+ */
+declare function addProp<T, K extends PropertyKey, V>(prop: K, value: V): (obj: T) => UpsertProp<T, K, V>;
+//#endregion
+export { addProp };
+//# sourceMappingURL=add-prop-C9l3pJs4.d.ts.map

package/dist/add-prop-C9l3pJs4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-prop-C9l3pJs4.d.ts","names":[],"sources":["../src/add-prop.ts"],"sourcesContent":[],"mappings":";;;;;;AAsBA;;;;;;;;;;;AAwBA;;;;;;AAG0B,iBA3BV,OA2BU,CAAA,CAAA,EAAA,UA3BW,WA2BX,EAAA,CAAA,CAAA,CAAA,GAAA,EA1BnB,CA0BmB,EAAA,IAAA,EAzBlB,CAyBkB,EAAA,KAAA,EAxBjB,CAwBiB,CAAA,EAvBvB,UAuBuB,CAvBZ,CAuBY,EAvBT,CAuBS,EAvBN,CAuBM,CAAA;;;;;;;;;;;;;;;;;;;iBAHV,qBAAqB,sBAC7B,UACC,UACA,MAAM,WAAW,GAAG,GAAG"}

package/dist/add-prop.d.ts

@@ -1,4 +1,4 @@
-import "./is-union-CBVcM_uW.js";
-import "./upsert-prop-CE7fi_mP.js";
-import { addProp } from "./add-prop-CMZauInB.js";
+import "./is-union-J33UR5By.js";
+import "./upsert-prop-s1QJNSeE.js";
+import { addProp } from "./add-prop-C9l3pJs4.js";
 export { addProp };

package/dist/add.d.ts

@@ -1,2 +1,2 @@
-import { add } from "./add-im980AO9.js";
+import { add } from "./add-BSDYck57.js";
 export { add };

package/dist/all-pass-CbkTeBNa.d.ts

@@ -0,0 +1,37 @@
+//#region src/all-pass.d.ts
+/**
+ * Determines whether all predicates returns true for the input data.
+ *
+ * @param data - The input data for predicates.
+ * @param fns - The list of predicates.
+ * @signature
+ *    P.allPass(data, fns)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.allPass(12, fns) // => true
+ *    P.allPass(8, fns) // => false
+ * @dataFirst
+ * @category Array
+ */
+declare function allPass<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean;
+/**
+ * Determines whether all predicates returns true for the input data.
+ *
+ * @param fns - The list of predicates.
+ * @signature
+ *    P.allPass(fns)(data)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.allPass(fns)(12) // => true
+ *    P.allPass(fns)(8) // => false
+ * @dataLast
+ * @category Array
+ */
+declare function allPass<T>(fns: ReadonlyArray<(data: T) => boolean>): (data: T) => boolean;
+//#endregion
+export { allPass };
+//# sourceMappingURL=all-pass-CbkTeBNa.d.ts.map

package/dist/all-pass-CbkTeBNa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all-pass-CbkTeBNa.d.ts","names":[],"sources":["../src/all-pass.ts"],"sourcesContent":[],"mappings":";;AAkBA;;;;;;AAoBA;;;;;;;;;iBApBgB,iBACR,QACD,qBAAqB;;;;;;;;;;;;;;;;iBAkBZ,gBACT,qBAAqB,wBAClB"}

package/dist/all-pass.d.ts

@@ -1,2 +1,2 @@
-import { allPass } from "./all-pass-DXpE2AMI.js";
+import { allPass } from "./all-pass-CbkTeBNa.js";
 export { allPass };

package/dist/any-pass-BHpbzKfX.d.ts

@@ -0,0 +1,37 @@
+//#region src/any-pass.d.ts
+/**
+ * Determines whether any predicate returns true for the input data.
+ *
+ * @param data - The input data for predicates.
+ * @param fns - The list of predicates.
+ * @signature
+ *    P.anyPass(data, fns)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.anyPass(8, fns) // => true
+ *    P.anyPass(11, fns) // => false
+ * @dataFirst
+ * @category Array
+ */
+declare function anyPass<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean;
+/**
+ * Determines whether any predicate returns true for the input data.
+ *
+ * @param fns - The list of predicates.
+ * @signature
+ *    P.anyPass(fns)(data)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.anyPass(fns)(8) // => true
+ *    P.anyPass(fns)(11) // => false
+ * @dataLast
+ * @category Array
+ */
+declare function anyPass<T>(fns: ReadonlyArray<(data: T) => boolean>): (data: T) => boolean;
+//#endregion
+export { anyPass };
+//# sourceMappingURL=any-pass-BHpbzKfX.d.ts.map

package/dist/any-pass-BHpbzKfX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"any-pass-BHpbzKfX.d.ts","names":[],"sources":["../src/any-pass.ts"],"sourcesContent":[],"mappings":";;AAkBA;;;;;;AAoBA;;;;;;;;;iBApBgB,iBACR,QACD,qBAAqB;;;;;;;;;;;;;;;;iBAkBZ,gBACT,qBAAqB,wBAClB"}

package/dist/any-pass.d.ts

@@ -1,2 +1,2 @@
-import { anyPass } from "./any-pass-DODvFXfM.js";
+import { anyPass } from "./any-pass-BHpbzKfX.js";
 export { anyPass };

package/dist/array-required-prefix-BHFg-BKr.d.ts

@@ -0,0 +1,26 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+import { PerkakasTypeError } from "./perkakas-type-error-2yBU0Drj.js";
+import { TupleParts } from "./tuple-parts-Du2iVN8H.js";
+import { ClampedIntegerSubtract } from "./clamped-integer-subtract-Dh3vTnRH.js";
+import { CoercedArray } from "./coerced-array-Fezc8pIu.js";
+import { And, GreaterThan, IsEqual, IsLiteral, IsNever, ReadonlyTuple } from "type-fest";
+
+//#region src/internal/types/array-required-prefix.d.ts
+type ArrayRequiredPrefix<T extends IterableContainer, N extends number> = IsLiteral<N> extends true ? T extends unknown ? ClampedIntegerSubtract<N, [...TupleParts<T>['required'], ...TupleParts<T>['suffix']]['length']> extends infer Remainder extends number ? Remainder extends 0 ? T : And<GreaterThan<Remainder, TupleParts<T>['optional']['length']>, IsNever<TupleParts<T>['item']>> extends true ? PerkakasTypeError<'ArrayRequiredPrefix', 'The input tuple cannot satisfy the minimum', {
+  type: never;
+  metadata: [T, N];
+}> : WithSameReadonly<T, [...TupleParts<T>['required'], ...OptionalTupleRequiredPrefix<TupleParts<T>['optional'], Remainder>, ...ReadonlyTuple<TupleParts<T>['item'], ClampedIntegerSubtract<Remainder, TupleParts<T>['optional']['length']>>, ...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']]> : PerkakasTypeError<'ArrayRequiredPrefix', 'Remainder didn\'t compute to a number?!', {
+  type: never;
+  metadata: [T, N];
+}> : PerkakasTypeError<'ArrayRequiredPrefix', 'Failed to distribute union?!', {
+  type: never;
+  metadata: T;
+}> : PerkakasTypeError<'ArrayRequiredPrefix', 'Only literal minimums are supported!', {
+  type: never;
+  metadata: N;
+}>;
+type WithSameReadonly<Source, Destination> = IsEqual<Source, Readonly<Source>> extends true ? Readonly<Destination> : Destination;
+type OptionalTupleRequiredPrefix<T extends Array<unknown>, N, Prefix extends Array<unknown> = []> = Prefix['length'] extends N ? [...Prefix, ...Partial<T>] : T extends readonly [infer Head, ...infer Rest] ? OptionalTupleRequiredPrefix<Rest, N, [...Prefix, Head]> : Prefix;
+//#endregion
+export { ArrayRequiredPrefix };
+//# sourceMappingURL=array-required-prefix-BHFg-BKr.d.ts.map

package/dist/array-required-prefix-BHFg-BKr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-required-prefix-BHFg-BKr.d.ts","names":[],"sources":["../src/internal/types/array-required-prefix.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAcY,8BAA8B,uCACtC,UAAU,kBAER,oBACE,uBACA,OACI,WAAW,gBANX,GAM8B,UAN9B,CAMyC,CANzC,CAAA,CAAA,QAAmB,CAAA,CAAA,CAAA,QAAA,CAAA,CAAA,SAAA,KAAA,mBAAA,MAAA,GAQrB,SARqB,SAAA,CAAA,GAWnB,CAXmB,GAYnB,GAZmB,CAenB,WAfmB,CAeP,SAfO,EAeI,UAfJ,CAee,CAff,CAAA,CAAA,UAAA,CAAA,CAAA,QAAA,CAAA,CAAA,EAiBnB,OAjBmB,CAiBX,UAjBW,CAiBA,CAjBA,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,IAAA,GAmBjB,iBAnBiB,CAAA,qBAAA,EAAA,4CAAA,EAAA;MAAW,EAAA,KAAA;UAC5B,EAAA,CAuBa,CAvBb,EAuBgB,CAvBhB,CAAA;KA8BA,gBA9BV,CA+BU,CA/BV,EAAA,IAmCe,UAjCb,CAiCwB,CAjCxB,CAAA,CAAA,UAAA,CAAA,KAuCa,2BArCX,CAsCU,UAtCV,CAsCqB,CAtCrB,CAAA,CAAA,UAAA,CAAA,EAuCU,SAvCV,CAAA,KA6CW,aA5CI,CA6CL,UA7CK,CA6CM,CA7CN,CAAA,CAAA,MAAA,CAAA,EA8CL,sBA9CK,CA+CH,SA/CG,EAgDH,UAhDG,CAgDQ,CAhDR,CAAA,CAAA,UAAA,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,KAsDJ,YAtDP,CAsDoB,UAtDpB,CAsD+B,CAtD/B,CAAA,CAAA,MAAA,CAAA,CAAA,KAuDO,UAvDkC,CAuDvB,CAvDuB,CAAA,CAAA,QAAA,CAAA,KA0D3C,iBA1DgC,CAAA,qBAAA,EAAA,yCAAA,EAAA;MAFlC,EAAA,KAAA;UAIE,EAAA,CA6Da,CA7Db,EA6DgB,CA7DhB,CAAA;KAgEF,iBA7DI,CAAA,qBAAA,EAAA,8BAAA,EAAA;MAIY,EAAA,KAAA;UAAsB,EA8D1B,CA9D0B;KAiExC,iBAjE6B,CAAA,qBAAA,EAAA,sCAAA,EAAA;MAAvB,EAAA,KAAA;UAEmB,EAoEb,CApEa;;KA0E1B,gBA1EO,CAAA,MAAA,EAAA,WAAA,CAAA,GA2ER,OA3EQ,CA2EA,MA3EA,EA2EQ,QA3ER,CA2EiB,MA3EjB,CAAA,CAAA,SAAA,IAAA,GA4EN,QA5EM,CA4EG,WA5EH,CAAA,GA6EN,WA7EM;KAmFP,2BAxFO,CAAA,UAyFA,KAzFA,CAAA,OAAA,CAAA,EAAA,CAAA,EAAA,eA2FK,KA3FL,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GA4FR,MA5FQ,CAAA,QAAA,CAAA,SA4FiB,CA5FjB,GAAA,CAAA,GAiGJ,MAjGI,EAAA,GAiGO,OAjGP,CAiGe,CAjGf,CAAA,CAAA,GAkGR,CAlGQ,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAmGN,2BAnGM,CAmGsB,IAnGtB,EAmG4B,CAnG5B,EAAA,CAAA,GAmGmC,MAnGnC,EAmG2C,IAnG3C,CAAA,CAAA,GAuGN,MAvGM"}

package/dist/binary-search-cutoff-index-YVs_m4IY.js

@@ -0,0 +1,2 @@
+function e(e,t){let n=0,r=e.length;for(;n<r;){let i=n+r>>>1,a=e[i];t(a,i,e)?n=i+1:r=i}return r}export{e as binarySearchCutoffIndex};
+//# sourceMappingURL=binary-search-cutoff-index-YVs_m4IY.js.map

package/dist/binary-search-cutoff-index-YVs_m4IY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-search-cutoff-index-YVs_m4IY.js","names":[],"sources":["../src/internal/binary-search-cutoff-index.ts"],"sourcesContent":["/**\n * A binary search implementation that finds the index at which `predicate`\n * stops returning `true` and starts returning `false` (consistently) when run\n * on the items of the array. It **assumes** that mapping the array via the\n * predicate results in the shape `[...true[], ...false[]]`. *For any other case\n * the result is unpredictable*.\n *\n * This is the base implementation of the `sortedIndex` functions which define\n * the predicate for the user, for common use-cases.\n *\n * It is similar to `findIndex`, but runs at O(logN), whereas the latter is\n * general purpose function which runs on any array and predicate, but runs at\n * O(N) time.\n */\nexport function binarySearchCutoffIndex<T>(\n  array: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number {\n  let lowIndex = 0;\n  let highIndex = array.length;\n\n  while (lowIndex < highIndex) {\n    const pivotIndex = (lowIndex + highIndex) >>> 1;\n    const pivot = array[pivotIndex]!;\n\n    if (predicate(pivot, pivotIndex, array)) {\n      lowIndex = pivotIndex + 1;\n    } else {\n      highIndex = pivotIndex;\n    }\n  }\n\n  return highIndex;\n}\n"],"mappings":"AAcA,SAAgB,EACd,EACA,EACQ,CACR,IAAI,EAAW,EACX,EAAY,EAAM,OAEtB,KAAO,EAAW,GAAW,CAC3B,IAAM,EAAc,EAAW,IAAe,EACxC,EAAQ,EAAM,GAEhB,EAAU,EAAO,EAAY,EAAM,CACrC,EAAW,EAAa,EAExB,EAAY,EAIhB,OAAO"}

package/dist/bounded-partial-DfemQln9.d.ts

@@ -0,0 +1,17 @@
+import { IsBoundedRecord } from "./is-bounded-record-DEQ2a3_Y.js";
+
+//#region src/internal/types/bounded-partial.d.ts
+
+/**
+ * Records with an unbounded set of keys have different semantics to those with
+ * a bounded set of keys when using 'noUncheckedIndexedAccess', the former
+ * being implicitly `Partial` whereas the latter are implicitly `Required`.
+ *
+ * @example
+ *    BoundedPartial<{ a: number }>; //=> { a?: number }
+ *    BoundedPartial<Record<string, number>>; //=> Record<string, number>
+ */
+type BoundedPartial<T> = IsBoundedRecord<T> extends true ? Partial<T> : T;
+//#endregion
+export { BoundedPartial };
+//# sourceMappingURL=bounded-partial-DfemQln9.d.ts.map

package/dist/bounded-partial-DfemQln9.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-partial-DfemQln9.d.ts","names":[],"sources":["../src/internal/types/bounded-partial.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;AAAgF,KAApE,cAAoE,CAAA,CAAA,CAAA,GAAhD,eAAgD,CAAhC,CAAgC,CAAA,SAAA,IAAA,GAAd,OAAc,CAAN,CAAM,CAAA,GAAD,CAAC"}

package/dist/case.transform-DJYiGJG0.js

@@ -0,0 +1,2 @@
+const e=/([\p{Ll}\d])(\p{Lu})/gu,t=/(\p{Lu})(\p{Lu}\p{Ll})/gu,n=/(\d)\p{Ll}|(\p{L})\d/u,r=/[^\p{L}\d]+/giu,i=`$1\0$2`;function a(e,t={}){let n=t.splitFn??(t.separateNumbers?l:o),r=t.prefixCharacters??``,i=t.suffixCharacters??``,a=0,s=e.length;for(;a<e.length;){let t=e.charAt(a);if(!r.includes(t))break;a++}for(;s>a;){let t=s-1,n=e.charAt(t);if(!i.includes(n))break;s=t}return[e.slice(0,a),n(e.slice(a,s)),e.slice(s)]}function o(n){let a=n.trim();a=a.replace(e,i).replace(t,i),a=a.replace(r,`\0`);let o=0,s=a.length;for(;a.charAt(o)===`\0`;)o++;if(o===s)return[];for(;a.charAt(s-1)===`\0`;)s--;return a.slice(o,s).split(/\0/)}function s(){return e=>e[0].toUpperCase()+e.slice(1).toLowerCase()}function c(){return(e,t)=>{let n=e[0];return(t>0&&n>=`0`&&n<=`9`?`_${n}`:n.toUpperCase())+e.slice(1).toLowerCase()}}function l(e){let t=o(e);for(let e=0;e<t.length;e++){let r=t[e],i=n.exec(r);if(i){let n=i.index+(i[1]??i[2]).length;t.splice(e,1,r.slice(0,n),r.slice(n))}}return t}export{s as capitalCaseTransformFactory,c as pascalCaseTransformFactory,a as splitPrefixSuffix};
+//# sourceMappingURL=case.transform-DJYiGJG0.js.map

package/dist/case.transform-DJYiGJG0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"case.transform-DJYiGJG0.js","names":[],"sources":["../src/internal/case.transform.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './case.types';\n\n// Regexps involved with splitting words in various case formats.\nconst SPLIT_LOWER_UPPER_RE = /([\\p{Ll}\\d])(\\p{Lu})/gu;\nconst SPLIT_UPPER_UPPER_RE = /(\\p{Lu})(\\p{Lu}\\p{Ll})/gu;\n\n// Used to iterate over the initial split result and separate numbers.\nconst SPLIT_SEPARATE_NUMBER_RE = /(\\d)\\p{Ll}|(\\p{L})\\d/u;\n\n// Regexp involved with stripping non-word characters from the result.\nconst DEFAULT_STRIP_REGEXP = /[^\\p{L}\\d]+/giu;\n\n// The replacement value for splits.\nconst SPLIT_REPLACE_VALUE = '$1\\0$2';\n\n// The default characters to keep after transforming case.\nconst DEFAULT_PREFIX_SUFFIX_CHARACTERS = '';\n\nexport function splitPrefixSuffix(\n  input: string,\n  options: ChangeCaseOptions = {},\n): [string, Array<string>, string] {\n  const splitFn = options.splitFn ?? (\n    options.separateNumbers\n      ? splitSeparateNumbers\n      : splitImplementation\n  );\n  const prefixCharacters\n    = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;\n  const suffixCharacters\n    = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;\n  let prefixIndex = 0;\n  let suffixIndex = input.length;\n\n  while (prefixIndex < input.length) {\n    const char = input.charAt(prefixIndex);\n    if (!prefixCharacters.includes(char)) {\n      break;\n    }\n    prefixIndex++;\n  }\n\n  while (suffixIndex > prefixIndex) {\n    const index = suffixIndex - 1;\n    const char = input.charAt(index);\n    if (!suffixCharacters.includes(char)) {\n      break;\n    }\n    suffixIndex = index;\n  }\n\n  return [\n    input.slice(0, prefixIndex),\n    splitFn(input.slice(prefixIndex, suffixIndex)),\n    input.slice(suffixIndex),\n  ];\n}\n\n/**\n * Split any cased input strings into an array of words.\n */\nexport function splitImplementation(value: string): Array<string> {\n  let result = value.trim();\n\n  result = result\n    .replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE)\n    .replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);\n\n  result = result.replace(DEFAULT_STRIP_REGEXP, '\\0');\n\n  let start = 0;\n  let end = result.length;\n\n  // Trim the delimiter from around the output string.\n  while (result.charAt(start) === '\\0') {\n    start++;\n  }\n\n  if (start === end) {\n    return [];\n  }\n\n  while (result.charAt(end - 1) === '\\0') {\n    end--;\n  }\n\n  return result.slice(start, end).split(/\\0/);\n}\n\nexport function capitalCaseTransformFactory() {\n  return (word: string): string => word[0]!.toUpperCase() + word.slice(1).toLowerCase();\n}\n\nexport function pascalCaseTransformFactory() {\n  return (word: string, index: number): string => {\n    const char0 = word[0]!;\n    const initial = index > 0 && char0 >= '0' && char0 <= '9'\n      ? `_${char0}`\n      : char0.toUpperCase();\n    return initial + word.slice(1).toLowerCase();\n  };\n}\n\n/**\n * Split the input string into an array of words, separating numbers.\n */\nexport function splitSeparateNumbers(value: string): Array<string> {\n  const words = splitImplementation(value);\n  for (let i = 0; i < words.length; i++) {\n    const word = words[i]!;\n    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);\n    if (match) {\n      const offset = match.index + (match[1] ?? match[2])!.length;\n      words.splice(i, 1, word.slice(0, offset), word.slice(offset));\n    }\n  }\n  return words;\n}\n"],"mappings":"AAGA,MAAM,EAAuB,yBACvB,EAAuB,2BAGvB,EAA2B,wBAG3B,EAAuB,iBAGvB,EAAsB,SAK5B,SAAgB,EACd,EACA,EAA6B,EAAE,CACE,CACjC,IAAM,EAAU,EAAQ,UACtB,EAAQ,gBACJ,EACA,GAEA,EACF,EAAQ,kBAAoB,GAC1B,EACF,EAAQ,kBAAoB,GAC5B,EAAc,EACd,EAAc,EAAM,OAExB,KAAO,EAAc,EAAM,QAAQ,CACjC,IAAM,EAAO,EAAM,OAAO,EAAY,CACtC,GAAI,CAAC,EAAiB,SAAS,EAAK,CAClC,MAEF,IAGF,KAAO,EAAc,GAAa,CAChC,IAAM,EAAQ,EAAc,EACtB,EAAO,EAAM,OAAO,EAAM,CAChC,GAAI,CAAC,EAAiB,SAAS,EAAK,CAClC,MAEF,EAAc,EAGhB,MAAO,CACL,EAAM,MAAM,EAAG,EAAY,CAC3B,EAAQ,EAAM,MAAM,EAAa,EAAY,CAAC,CAC9C,EAAM,MAAM,EAAY,CACzB,CAMH,SAAgB,EAAoB,EAA8B,CAChE,IAAI,EAAS,EAAM,MAAM,CAEzB,EAAS,EACN,QAAQ,EAAsB,EAAoB,CAClD,QAAQ,EAAsB,EAAoB,CAErD,EAAS,EAAO,QAAQ,EAAsB,KAAK,CAEnD,IAAI,EAAQ,EACR,EAAM,EAAO,OAGjB,KAAO,EAAO,OAAO,EAAM,GAAK,MAC9B,IAGF,GAAI,IAAU,EACZ,MAAO,EAAE,CAGX,KAAO,EAAO,OAAO,EAAM,EAAE,GAAK,MAChC,IAGF,OAAO,EAAO,MAAM,EAAO,EAAI,CAAC,MAAM,KAAK,CAG7C,SAAgB,GAA8B,CAC5C,MAAQ,IAAyB,EAAK,GAAI,aAAa,CAAG,EAAK,MAAM,EAAE,CAAC,aAAa,CAGvF,SAAgB,GAA6B,CAC3C,OAAQ,EAAc,IAA0B,CAC9C,IAAM,EAAQ,EAAK,GAInB,OAHgB,EAAQ,GAAK,GAAS,KAAO,GAAS,IAClD,IAAI,IACJ,EAAM,aAAa,EACN,EAAK,MAAM,EAAE,CAAC,aAAa,EAOhD,SAAgB,EAAqB,EAA8B,CACjE,IAAM,EAAQ,EAAoB,EAAM,CACxC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,IAAK,CACrC,IAAM,EAAO,EAAM,GACb,EAAQ,EAAyB,KAAK,EAAK,CACjD,GAAI,EAAO,CACT,IAAM,EAAS,EAAM,OAAS,EAAM,IAAM,EAAM,IAAK,OACrD,EAAM,OAAO,EAAG,EAAG,EAAK,MAAM,EAAG,EAAO,CAAE,EAAK,MAAM,EAAO,CAAC,EAGjE,OAAO"}

package/dist/case.types-D-4qwVN-.d.cts

@@ -0,0 +1,19 @@
+//#region src/internal/case.types.d.ts
+
+/**
+ * Options used for converting strings to any case.
+ */
+interface ChangeCaseOptions {
+  delimiter?: string;
+  /**
+   * Options used for converting strings to pascal/camel case.
+   */
+  mergeAmbiguousCharacters?: boolean;
+  prefixCharacters?: string;
+  separateNumbers?: boolean;
+  splitFn?: (value: string) => Array<string>;
+  suffixCharacters?: string;
+}
+//#endregion
+export { ChangeCaseOptions };
+//# sourceMappingURL=case.types-D-4qwVN-.d.cts.map

package/dist/case.types-D-4qwVN-.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"case.types-D-4qwVN-.d.cts","names":[],"sources":["../src/internal/case.types.ts"],"sourcesContent":[],"mappings":";;;;;UAUiB,iBAAA;;;;;;;;+BAQc"}

package/dist/case.types-D5NB5m6p.d.ts

@@ -0,0 +1,19 @@
+//#region src/internal/case.types.d.ts
+
+/**
+ * Options used for converting strings to any case.
+ */
+interface ChangeCaseOptions {
+  delimiter?: string;
+  /**
+   * Options used for converting strings to pascal/camel case.
+   */
+  mergeAmbiguousCharacters?: boolean;
+  prefixCharacters?: string;
+  separateNumbers?: boolean;
+  splitFn?: (value: string) => Array<string>;
+  suffixCharacters?: string;
+}
+//#endregion
+export { ChangeCaseOptions };
+//# sourceMappingURL=case.types-D5NB5m6p.d.ts.map

package/dist/case.types-D5NB5m6p.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"case.types-D5NB5m6p.d.ts","names":[],"sources":["../src/internal/case.types.ts"],"sourcesContent":[],"mappings":";;;;;UAUiB,iBAAA;;;;;;;;+BAQc"}

package/dist/ceil-t6jtFzmr.d.ts

@@ -0,0 +1,39 @@
+//#region src/ceil.d.ts
+/**
+ * Rounds up a given number to a specific precision.
+ * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.ceil` instead, as it won't incur the additional library overhead.
+ *
+ * @param value - The number to round up.
+ * @param precision - The precision to round up to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.ceil(value, precision);
+ * @example
+ *    P.ceil(123.9876, 3) // => 123.988
+ *    P.ceil(483.22243, 1) // => 483.3
+ *    P.ceil(8541, -1) // => 8550
+ *    P.ceil(456789, -3) // => 457000
+ * @dataFirst
+ * @category Number
+ */
+declare function ceil(value: number, precision: number): number;
+/**
+ * Rounds up a given number to a specific precision.
+ * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.ceil` instead, as it won't incur the additional library overhead.
+ *
+ * @param precision - The precision to round up to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.ceil(precision)(value);
+ * @example
+ *    P.ceil(3)(123.9876) // => 123.988
+ *    P.ceil(1)(483.22243) // => 483.3
+ *    P.ceil(-1)(8541) // => 8550
+ *    P.ceil(-3)(456789) // => 457000
+ * @dataLast
+ * @category Number
+ */
+declare function ceil(precision: number): (value: number) => number;
+//#endregion
+export { ceil };
+//# sourceMappingURL=ceil-t6jtFzmr.d.ts.map

package/dist/ceil-t6jtFzmr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceil-t6jtFzmr.d.ts","names":[],"sources":["../src/ceil.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,IAAA;;;;;;;;;;;;;;;;;iBAkBA,IAAA"}

package/dist/ceil.d.ts

@@ -1,2 +1,2 @@
-import { ceil } from "./ceil-3wC2QOvT.js";
+import { ceil } from "./ceil-t6jtFzmr.js";
 export { ceil };

package/dist/chunk-Hsv7c06B.d.ts

@@ -0,0 +1,76 @@
+import { IntRangeInclusive } from "./int-range-inclusive-DzLDwln0.js";
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+import { NTuple } from "./n-tuple-CU6777y4.js";
+import { NonEmptyArray } from "./non-empty-array-BfTfvDYg.js";
+import { PartialArray } from "./partial-array-DSctnYXY.js";
+import { TupleParts } from "./tuple-parts-Du2iVN8H.js";
+import { IntRange, IsNever, IsNumericLiteral, LessThan, Subtract, ValueOf } from "type-fest";
+
+//#region src/chunk.d.ts
+
+/**
+ * This prevents typescript from failing on complex arrays and large chunks.
+ * It allows the typing to remain useful even when very large chunks are needed,
+ * without loosing fidelity on smaller ones. It was chosen by trial-and-error,
+ * and given some more wiggle room because the complexity of the array also
+ * plays a role in when typescript fails to recurse.
+ * See the type tests for an example.
+ */
+type MAX_LITERAL_SIZE = 350;
+type Chunk<T extends IterableContainer, N extends number> = T extends readonly [] ? [] : IsNumericLiteral<N> extends true ? LessThan<N, 1> extends true ? never : LessThan<N, MAX_LITERAL_SIZE> extends true ? [...LiteralChunk<T, N>] : GenericChunk<T> : GenericChunk<T>;
+type LiteralChunk<T extends IterableContainer, N extends number> = ChunkRestElement<ChunkFixedTuple<TuplePrefix<T>, N>, TupleParts<T>['item'], TupleParts<T>['suffix'], N> | ([...TuplePrefix<T>, ...TupleParts<T>['suffix']] extends readonly [] ? [] : never);
+/**
+ * This type **only** works if the input array `T` is a fixed tuple. For these
+ * inputs the chunked output could be computed as literal finite tuples too.
+ */
+type ChunkFixedTuple<T, N extends number, Result = []> = T extends readonly [infer Head, ...infer Rest] ? ChunkFixedTuple<Rest, N, Result extends [...infer Previous extends Array<Array<unknown>>, infer Current extends Array<unknown>] ? Current['length'] extends N ? [...Previous, Current, [Head]] : [...Previous, [...Current, Head]] : [[Head]]> : Result;
+/**
+ * Here lies the main complexity of building the chunk type. It takes the prefix
+ * chunks, the rest param item type, and the suffix (not chunked!) and it
+ * creates all possible combinations of adding items to the prefix and suffix
+ * for all possible scenarios for how many items the rest param "represents".
+ */
+type ChunkRestElement<PrefixChunks, Item, Suffix extends Array<unknown>, N extends number> = IsNever<Item> extends true ? PrefixChunks : PrefixChunks extends [...infer PrefixFullChunks extends Array<Array<unknown>>, infer LastPrefixChunk extends Array<unknown>] ? ValueOf<{ [Padding in IntRangeInclusive<0, Subtract<N, LastPrefixChunk['length']>>]: [...PrefixFullChunks, ...ChunkFixedTuple<[...LastPrefixChunk, ...NTuple<Item, Padding>, ...Suffix], N>] }> | [...PrefixFullChunks, [...LastPrefixChunk, ...NTuple<Item, Subtract<N, LastPrefixChunk['length']>>], ...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>] : [...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>];
+/**
+ * This type assumes it takes a finite tuple that represents the suffix of our
+ * input array. It builds all possible combinations of adding items to the
+ * **head** of the suffix in order to pad the suffix until the last chunk is
+ * full.
+ */
+type SuffixChunk<T extends Array<unknown>, Item, N extends number> = T extends readonly [] ? [ValueOf<{ [K in IntRangeInclusive<1, N>]: NTuple<Item, K> }>] : ValueOf<{ [Padding in IntRange<0, N>]: ChunkFixedTuple<[...NTuple<Item, Padding>, ...T], N> }>;
+/**
+ * This is the legacy type used when we don't know what N is. We can only adjust
+ * our output based on if we know for sure that the array is empty or not.
+ */
+type GenericChunk<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown] | readonly [unknown, ...Array<unknown>] ? NonEmptyArray<NonEmptyArray<T[number]>> : Array<NonEmptyArray<T[number]>>;
+type TuplePrefix<T extends IterableContainer> = [...TupleParts<T>['required'], ...PartialArray<TupleParts<T>['optional']>];
+/**
+ * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.
+ *
+ * @param array - The array.
+ * @param size - The length of the chunk.
+ * @signature
+ *    P.chunk(array, size)
+ * @example
+ *    P.chunk(['a', 'b', 'c', 'd'], 2) // => [['a', 'b'], ['c', 'd']]
+ *    P.chunk(['a', 'b', 'c', 'd'], 3) // => [['a', 'b', 'c'], ['d']]
+ * @dataFirst
+ * @category Array
+ */
+declare function chunk<T extends IterableContainer, N extends number>(array: T, size: N): Chunk<T, N>;
+/**
+ * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.
+ *
+ * @param size - The length of the chunk.
+ * @signature
+ *    P.chunk(size)(array)
+ * @example
+ *    P.chunk(2)(['a', 'b', 'c', 'd']) // => [['a', 'b'], ['c', 'd']]
+ *    P.chunk(3)(['a', 'b', 'c', 'd']) // => [['a', 'b', 'c'], ['d']]
+ * @dataLast
+ * @category Array
+ */
+declare function chunk<N extends number>(size: N): <T extends IterableContainer>(array: T) => Chunk<T, N>;
+//#endregion
+export { chunk };
+//# sourceMappingURL=chunk-Hsv7c06B.d.ts.map

package/dist/chunk-Hsv7c06B.d.ts.map

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

package/dist/chunk.d.ts

@@ -1,9 +1,9 @@
-import "./int-range-inclusive-BSXuRjMO.js";
-import "./iterable-container-wtkYslN_.js";
-import "./n-tuple-BELi5yRe.js";
-import "./non-empty-array-D3HWDPMt.js";
-import "./partial-array-IoGI5gCo.js";
-import "./perkakas-type-error-Da3ni385.js";
-import "./tuple-parts-BxpZLJ7r.js";
-import { chunk } from "./chunk-21HuGLAn.js";
+import "./int-range-inclusive-DzLDwln0.js";
+import "./iterable-container-F9CDF7ym.js";
+import "./n-tuple-CU6777y4.js";
+import "./non-empty-array-BfTfvDYg.js";
+import "./partial-array-DSctnYXY.js";
+import "./perkakas-type-error-2yBU0Drj.js";
+import "./tuple-parts-Du2iVN8H.js";
+import { chunk } from "./chunk-Hsv7c06B.js";
 export { chunk };

package/dist/clamp-D_5sgYkv.d.ts

@@ -0,0 +1,37 @@
+//#region src/clamp.d.ts
+interface Limits {
+  readonly max?: number;
+  readonly min?: number;
+}
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ *
+ * @param value - The number.
+ * @param limits - The bounds limits.
+ * @signature
+ *    P.clamp(value, { min, max });
+ * @example
+ *    clamp(10, { min: 20 }) // => 20
+ *    clamp(10, { max: 5 }) // => 5
+ *    clamp(10, { max: 20, min: 5 }) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function clamp(value: number, limits: Limits): number;
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ *
+ * @param limits - The bounds limits.
+ * @signature
+ *    P.clamp({ min, max })(value);
+ * @example
+ *    clamp({ min: 20 })(10) // => 20
+ *    clamp({ max: 5 })(10) // => 5
+ *    clamp({ max: 20, min: 5 })(10) // => 10
+ * @dataLast
+ * @category Number
+ */
+declare function clamp(limits: Limits): (value: number) => number;
+//#endregion
+export { clamp };
+//# sourceMappingURL=clamp-D_5sgYkv.d.ts.map

package/dist/clamp-D_5sgYkv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp-D_5sgYkv.d.ts","names":[],"sources":["../src/clamp.ts"],"sourcesContent":[],"mappings":";UAEU,MAAA;EAAA,SAAM,GAAA,CAAA,EAAA,MAAA;EAmBA,SAAK,GAAA,CAAA,EAAA,MAAwB;AAe7C;;;;;;;;;;;;;;;iBAfgB,KAAA,wBAA6B;;;;;;;;;;;;;;iBAe7B,KAAA,SAAc"}

package/dist/clamp.d.ts

@@ -1,2 +1,2 @@
-import { clamp } from "./clamp-V39NgixZ.js";
+import { clamp } from "./clamp-D_5sgYkv.js";
 export { clamp };

package/dist/clamped-integer-subtract-Dh3vTnRH.d.ts

@@ -0,0 +1,11 @@
+//#region src/internal/types/clamped-integer-subtract.d.ts
+/**
+ * We built our own version of Subtract instead of using type-fest's one
+ * because we needed a simpler implementation that isn't as prone to excessive
+ * recursion issues and that is clamped at 0 so that we don't need to handle
+ * negative values using even more utilities.
+ */
+type ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag extends Array<unknown> = [], ResultBag extends Array<unknown> = []> = [...SubtrahendBag, ...ResultBag]['length'] extends Minuend ? ResultBag['length'] : SubtrahendBag['length'] extends Subtrahend ? ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag, [...ResultBag, unknown]> : ClampedIntegerSubtract<Minuend, Subtrahend, [...SubtrahendBag, unknown], ResultBag>;
+//#endregion
+export { ClampedIntegerSubtract };
+//# sourceMappingURL=clamped-integer-subtract-Dh3vTnRH.d.ts.map

package/dist/clamped-integer-subtract-Dh3vTnRH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamped-integer-subtract-Dh3vTnRH.d.ts","names":[],"sources":["../src/internal/types/clamped-integer-subtract.ts"],"sourcesContent":[],"mappings":";;AAMA;;;;;AAK0B,KALd,sBAKc,CAAA,OAAA,EAAA,UAAA,EAAA,sBAFF,KAEE,CAAA,OAAA,CAAA,GAAA,EAAA,EAAA,kBADN,KACM,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAA,CAAA,GAAlB,aAAkB,EAAA,GAAA,SAAA,CAAA,CAAA,QAAA,CAAA,SAA6B,OAA7B,GAEtB,SAFsB,CAAA,QAAA,CAAA,GAGtB,aAHsB,CAAA,QAAA,CAAA,SAGU,UAHV,GAMpB,sBANoB,CAOpB,OAPoB,EAQpB,UARoB,EASpB,aAToB,EAAA,IAUhB,SAV6C,SAEnD,KAWE,sBAVF,CAWE,OAXF,EAYE,UAZF,EAAA,IAaM,aAb0B,SAI9B,GAUA,SATA,CAAA"}

package/dist/clone-CY68Bkn3.d.ts

@@ -0,0 +1,35 @@
+//#region src/clone.d.ts
+/**
+ * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
+ * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
+ * assigned by reference rather than copied. Class instances or any other
+ * built-in type that isn't mentioned above are not supported (but might
+ * work).
+ *
+ * @param data - The object to clone.
+ * @signature
+ *   P.clone(data)
+ * @example
+ *   P.clone({foo: 'bar'}) // {foo: 'bar'}
+ * @dataFirst
+ * @category Object
+ */
+declare function clone<T>(data: T): T;
+/**
+ * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
+ * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
+ * assigned by reference rather than copied. Class instances or any other
+ * built-in type that isn't mentioned above are not supported (but might
+ * work).
+ *
+ * @signature
+ *   P.clone()(data)
+ * @example
+ *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}
+ * @dataLast
+ * @category Object
+ */
+declare function clone(): <T>(data: T) => T;
+//#endregion
+export { clone };
+//# sourceMappingURL=clone-CY68Bkn3.d.ts.map

package/dist/clone-CY68Bkn3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-CY68Bkn3.d.ts","names":[],"sources":["../src/clone.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;AAgBA;;;;;;;;;iBAhBgB,eAAe,IAAI;;;;;;;;;;;;;;;iBAgBnB,KAAA,CAAA,aAAmB,MAAM"}

package/dist/clone.d.ts

@@ -1,2 +1,2 @@
-import { clone } from "./clone-UasIry83.js";
+import { clone } from "./clone-CY68Bkn3.js";
 export { clone };

package/dist/coerced-array-Fezc8pIu.d.ts

@@ -0,0 +1,17 @@
+import { IsNever } from "type-fest";
+
+//#region src/internal/types/coerced-array.d.ts
+
+/**
+ * `never[]` and `[]` are not the same type, and in some cases they aren't
+ * interchangeable.
+ *
+ * This type makes it easier to use the result of TupleParts when the input is a
+ * fixed-length tuple but we still want to spread the rest of the array. e.g.
+ * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
+ *
+ */
+type CoercedArray<T> = IsNever<T> extends true ? [] : Array<T>;
+//#endregion
+export { CoercedArray };
+//# sourceMappingURL=coerced-array-Fezc8pIu.d.ts.map

package/dist/coerced-array-Fezc8pIu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerced-array-Fezc8pIu.d.ts","names":[],"sources":["../src/internal/types/coerced-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;KAAY,kBAAkB,QAAQ,uBAAuB,MAAM"}