@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/with-precision-BoiuafbM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-precision-BoiuafbM.js","names":[],"sources":["../src/internal/with-precision.ts"],"sourcesContent":["/**\n * ECMAScript doesn't support more decimal places than 15,\n * so supporting higher values doesn't make a lot of sense.\n * Considering Number.MAX_SAFE_INTEGER < 10**16\n * we can also use -15 for the negative precision limit.\n */\nconst MAX_PRECISION = 15;\n\nconst RADIX = 10;\n\nexport function withPrecision(roundingFn: (value: number) => number) {\n  return (value: number, precision: number): number => {\n    if (precision === 0) {\n      return roundingFn(value);\n    }\n\n    if (!Number.isInteger(precision)) {\n      throw new TypeError(\n        `precision must be an integer: ${precision.toString()}`,\n      );\n    }\n\n    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {\n      throw new RangeError('precision must be between -15 and 15');\n    }\n\n    if (Number.isNaN(value) || !Number.isFinite(value)) {\n      return roundingFn(value);\n    }\n\n    if (precision > 0) {\n      const multiplier = RADIX ** precision;\n      return roundingFn(value * multiplier) / multiplier;\n    }\n\n    // Avoid losing precision by dividing first.\n    const divisor = RADIX ** -precision;\n    return roundingFn(value / divisor) * divisor;\n  };\n}\n"],"mappings":"AAUA,SAAgB,EAAc,EAAuC,CACnE,OAAQ,EAAe,IAA8B,CACnD,GAAI,IAAc,EAChB,OAAO,EAAW,EAAM,CAG1B,GAAI,CAAC,OAAO,UAAU,EAAU,CAC9B,MAAU,UACR,iCAAiC,EAAU,UAAU,GACtD,CAGH,GAAI,EAAY,IAAiB,EAAY,IAC3C,MAAU,WAAW,uCAAuC,CAG9D,GAAI,OAAO,MAAM,EAAM,EAAI,CAAC,OAAO,SAAS,EAAM,CAChD,OAAO,EAAW,EAAM,CAG1B,GAAI,EAAY,EAAG,CACjB,IAAM,EAAa,IAAS,EAC5B,OAAO,EAAW,EAAQ,EAAW,CAAG,EAI1C,IAAM,EAAU,IAAS,CAAC,EAC1B,OAAO,EAAW,EAAQ,EAAQ,CAAG"}

package/dist/zip-Bx1gp9g8.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t,r)}function n(e,t){return e.length<t.length?e.map((e,n)=>[e,t[n]]):t.map((t,n)=>[e[n],t])}function r(e){return(t,n)=>({done:n>=e.length-1,hasNext:!0,next:[t,e[n]]})}export{t as zip};
+//# sourceMappingURL=zip-Bx1gp9g8.js.map

package/dist/zip-Bx1gp9g8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-Bx1gp9g8.js","names":[],"sources":["../src/zip.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curry } from './curry';\n\ntype Zipped<Left extends IterableContainer, Right extends IterableContainer>\n  // If the array is empty the output is empty, no surprises\n  = Left extends readonly []\n    ? []\n    : Right extends readonly []\n      ? []\n      : // Are the two inputs both tuples with a non-rest first item?\n      Left extends readonly [infer LeftHead, ...infer LeftRest]\n        ? Right extends readonly [infer RightHead, ...infer RightRest]\n          ? // ...Then take that first item from both and recurse\n            [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>]\n          : // Is only one of the inputs a tuple (with a non-rest first item)?\n            // Then take that item, and match it with whatever the type of the other *array's* items are.\n            [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>]\n        : Right extends readonly [infer RightHead, ...infer RightRest]\n          ? [[Left[number], RightHead], ...Zipped<Left, RightRest>]\n          : // Both inputs are not tuples (with a non-rest first item, they might be tuples with non-rest last item(s))\n        // So the output is just the \"trivial\" zip result.\n          Array<[Left[number], Right[number]]>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @signature\n *   P.zip(first, second)\n * @example\n *   P.zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zip<F extends IterableContainer, S extends IterableContainer>(\n  first: F,\n  second: S,\n): Zipped<F, S>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param second - The second input list.\n * @signature\n *   P.zip(second)(first)\n * @example\n *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zip<S extends IterableContainer>(\n  second: S,\n): <F extends IterableContainer>(first: F) => Zipped<F, S>;\n\nexport function zip(...args: ReadonlyArray<unknown>): unknown {\n  return curry(zipImplementation, args, lazyImplementation);\n}\n\nfunction zipImplementation<\n  F extends IterableContainer,\n  S extends IterableContainer,\n>(\n  first: F,\n  second: S,\n): Zipped<F, S> {\n  return (first.length < second.length\n    ? first.map((item, index) => [item, second[index]])\n    : second.map((item, index) => [first[index], item])) as Zipped<F, S>;\n}\n\nfunction lazyImplementation<F extends IterableContainer, S extends IterableContainer>(\n  second: S,\n): LazyEvaluator<F[number], [F[number], S[number]]> {\n  return (value, index) => ({\n    done: index >= second.length - 1,\n    hasNext: true,\n    next: [value, second[index]],\n  });\n}\n"],"mappings":"4CA+DA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAM,EAAmB,CAG3D,SAAS,EAIP,EACA,EACc,CACd,OAAQ,EAAM,OAAS,EAAO,OAC1B,EAAM,KAAK,EAAM,IAAU,CAAC,EAAM,EAAO,GAAO,CAAC,CACjD,EAAO,KAAK,EAAM,IAAU,CAAC,EAAM,GAAQ,EAAK,CAAC,CAGvD,SAAS,EACP,EACkD,CAClD,OAAQ,EAAO,KAAW,CACxB,KAAM,GAAS,EAAO,OAAS,EAC/B,QAAS,GACT,KAAM,CAAC,EAAO,EAAO,GAAO,CAC7B"}

package/dist/zip-CItdS_iZ.d.ts

@@ -0,0 +1,38 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+
+//#region src/zip.d.ts
+type Zipped<Left extends IterableContainer, Right extends IterableContainer> = Left extends readonly [] ? [] : Right extends readonly [] ? [] : Left extends readonly [infer LeftHead, ...infer LeftRest] ? Right extends readonly [infer RightHead, ...infer RightRest] ? [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>] : [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zipped<Left, RightRest>] : Array<[Left[number], Right[number]]>;
+/**
+ * Creates a new list from two supplied lists by pairing up equally-positioned
+ * items. The length of the returned list will match the shortest of the two
+ * inputs.
+ *
+ * @param first - The first input list.
+ * @param second - The second input list.
+ * @signature
+ *   P.zip(first, second)
+ * @example
+ *   P.zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function zip<F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zipped<F, S>;
+/**
+ * Creates a new list from two supplied lists by pairing up equally-positioned
+ * items. The length of the returned list will match the shortest of the two
+ * inputs.
+ *
+ * @param second - The second input list.
+ * @signature
+ *   P.zip(second)(first)
+ * @example
+ *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function zip<S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zipped<F, S>;
+//#endregion
+export { zip };
+//# sourceMappingURL=zip-CItdS_iZ.d.ts.map

package/dist/zip-CItdS_iZ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-CItdS_iZ.d.ts","names":[],"sources":["../src/zip.ts"],"sourcesContent":[],"mappings":";;;KAKK,oBAAoB,iCAAiC,qBAEtD,gCAEE,iCAGA,4DACI,iEAEI,UAAU,YAVnB,GAUkC,MAV5B,CAUmC,QAVnC,EAU6C,SAV7C,CAAA,CAAA,GAAA,EAaG,QAbW,EAaD,KAbC,CAAA,MAAA,CAAA,CAAA,KAakB,MAbe,CAaR,QAbQ,EAaE,KAbF,CAAA,IAchD,KAZN,SAAA,SAAA,CAAA,KAAA,UAAA,EAAA,GAAA,KAAA,UAAA,CAAA,GAAA,CAAA,CAaU,IAbV,CAAA,MAAA,CAAA,EAawB,SAbxB,CAAA,EAAA,GAauC,MAbvC,CAa8C,IAb9C,EAaoD,SAbpD,CAAA,CAAA,GAgBM,KAhBN,CAAA,CAgBa,IAhBb,CAAA,MAAA,CAAA,EAgB2B,KAhB3B,CAAA,MAAA,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;AAawB,iBAoBZ,GApBY,CAAA,UAoBE,iBApBF,EAAA,UAoB+B,iBApB/B,CAAA,CAAA,KAAA,EAqBnB,CArBmB,EAAA,MAAA,EAsBlB,CAtBkB,CAAA,EAuBzB,MAvByB,CAuBlB,CAvBkB,EAuBf,CAvBe,CAAA;;;;;;;;AAoB5B;;;;;;;AAGa,iBAgBG,GAhBH,CAAA,UAgBiB,iBAhBjB,CAAA,CAAA,MAAA,EAiBH,CAjBG,CAAA,EAAA,CAAA,UAkBC,iBAlBD,CAAA,CAAA,KAAA,EAkB2B,CAlB3B,EAAA,GAkBiC,MAlBjC,CAkBwC,CAlBxC,EAkB2C,CAlB3C,CAAA"}

package/dist/zip-CSvsKjDN.d.cts

@@ -0,0 +1,38 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+
+//#region src/zip.d.ts
+type Zipped<Left extends IterableContainer, Right extends IterableContainer> = Left extends readonly [] ? [] : Right extends readonly [] ? [] : Left extends readonly [infer LeftHead, ...infer LeftRest] ? Right extends readonly [infer RightHead, ...infer RightRest] ? [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>] : [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zipped<Left, RightRest>] : Array<[Left[number], Right[number]]>;
+/**
+ * Creates a new list from two supplied lists by pairing up equally-positioned
+ * items. The length of the returned list will match the shortest of the two
+ * inputs.
+ *
+ * @param first - The first input list.
+ * @param second - The second input list.
+ * @signature
+ *   P.zip(first, second)
+ * @example
+ *   P.zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function zip<F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zipped<F, S>;
+/**
+ * Creates a new list from two supplied lists by pairing up equally-positioned
+ * items. The length of the returned list will match the shortest of the two
+ * inputs.
+ *
+ * @param second - The second input list.
+ * @signature
+ *   P.zip(second)(first)
+ * @example
+ *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function zip<S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zipped<F, S>;
+//#endregion
+export { zip };
+//# sourceMappingURL=zip-CSvsKjDN.d.cts.map

package/dist/zip-CSvsKjDN.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-CSvsKjDN.d.cts","names":[],"sources":["../src/zip.ts"],"sourcesContent":[],"mappings":";;;KAKK,oBAAoB,iCAAiC,qBAEtD,gCAEE,iCAGA,4DACI,iEAEI,UAAU,YAVnB,GAUkC,MAV5B,CAUmC,QAVnC,EAU6C,SAV7C,CAAA,CAAA,GAAA,EAaG,QAbW,EAaD,KAbC,CAAA,MAAA,CAAA,CAAA,KAakB,MAbe,CAaR,QAbQ,EAaE,KAbF,CAAA,IAchD,KAZN,SAAA,SAAA,CAAA,KAAA,UAAA,EAAA,GAAA,KAAA,UAAA,CAAA,GAAA,CAAA,CAaU,IAbV,CAAA,MAAA,CAAA,EAawB,SAbxB,CAAA,EAAA,GAauC,MAbvC,CAa8C,IAb9C,EAaoD,SAbpD,CAAA,CAAA,GAgBM,KAhBN,CAAA,CAgBa,IAhBb,CAAA,MAAA,CAAA,EAgB2B,KAhB3B,CAAA,MAAA,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;AAawB,iBAoBZ,GApBY,CAAA,UAoBE,iBApBF,EAAA,UAoB+B,iBApB/B,CAAA,CAAA,KAAA,EAqBnB,CArBmB,EAAA,MAAA,EAsBlB,CAtBkB,CAAA,EAuBzB,MAvByB,CAuBlB,CAvBkB,EAuBf,CAvBe,CAAA;;;;;;;;AAoB5B;;;;;;;AAGa,iBAgBG,GAhBH,CAAA,UAgBiB,iBAhBjB,CAAA,CAAA,MAAA,EAiBH,CAjBG,CAAA,EAAA,CAAA,UAkBC,iBAlBD,CAAA,CAAA,KAAA,EAkB2B,CAlB3B,EAAA,GAkBiC,MAlBjC,CAkBwC,CAlBxC,EAkB2C,CAlB3C,CAAA"}

package/dist/zip-DoQHstmA.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t,r)}function n(e,t){return e.length<t.length?e.map((e,n)=>[e,t[n]]):t.map((t,n)=>[e[n],t])}function r(e){return(t,n)=>({done:n>=e.length-1,hasNext:!0,next:[t,e[n]]})}Object.defineProperty(exports,`zip`,{enumerable:!0,get:function(){return t}});

package/dist/zip-with-BEpLRmfK.d.ts

@@ -0,0 +1,50 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+
+//#region src/zip-with.d.ts
+type ZippingFunction<T1 extends IterableContainer = IterableContainer, T2 extends IterableContainer = IterableContainer, Value = unknown> = (first: T1[number], second: T2[number], index: number, data: readonly [first: T1, second: T2]) => Value;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ *
+ * @param fn - The function applied to each position of the list.
+ * @signature
+ *   P.zipWith(fn)(first, second)
+ * @example
+ *   P.zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']
+ * @category Array
+ */
+declare function zipWith<TItem1, TItem2, Value>(fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>): <T1 extends IterableContainer<TItem1>, T2 extends IterableContainer<TItem2>>(first: T1, second: T2) => Array<Value>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ *
+ * @param second - The second input list.
+ * @param fn - The function applied to each position of the list.
+ * @signature
+ *   P.zipWith(second, fn)(first)
+ * @example
+ *   P.pipe(['1', '2', '3'], P.zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ *
+ * @param first - The first input list.
+ * @param second - The second input list.
+ * @param fn - The function applied to each position of the list.
+ * @signature
+ *   P.zipWith(first, second, fn)
+ * @example
+ *   P.zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;
+//#endregion
+export { zipWith };
+//# sourceMappingURL=zip-with-BEpLRmfK.d.ts.map

package/dist/zip-with-BEpLRmfK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-with-BEpLRmfK.d.ts","names":[],"sources":["../src/zip-with.ts"],"sourcesContent":[],"mappings":";;;KAIK,2BACQ,oBAAoB,8BACpB,oBAAoB,8CAGxB,oBACC,kDAEe,YAAY,QAChC;;AAbwE;;;;;;;;;;AAaxE,iBAaW,OAbX,CAAA,MAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA,EAAA,EAcC,eAdD,CAciB,aAdjB,CAc+B,MAd/B,CAAA,EAcwC,aAdxC,CAcsD,MAdtD,CAAA,EAc+D,KAd/D,CAAA,CAAA,EAAA,CAAA,WAeU,iBAfV,CAe4B,MAf5B,CAAA,EAAA,WAegD,iBAfhD,CAekE,MAflE,CAAA,CAAA,CAAA,KAAA,EAgBI,EAhBJ,EAAA,MAAA,EAiBK,EAjBL,EAAA,GAkBA,KAlBA,CAkBM,KAlBN,CAAA;;AAaL;;;;;;;;;;;;;AAIU,iBAiBM,OAjBN,CAAA,WAkBG,iBAlBH,EAAA,WAmBG,iBAnBH,EAAA,KAAA,CAAA,CAAA,MAAA,EAqBA,EArBA,EAAA,EAAA,EAqBQ,eArBR,CAqBwB,EArBxB,EAqB4B,EArB5B,EAqBgC,KArBhC,CAAA,CAAA,EAAA,CAAA,KAAA,EAqBiD,EArBjD,EAAA,GAqBwD,KArBxD,CAqB8D,KArB9D,CAAA;;;;AAiBV;;;;;;;;;;;;AAIuE,iBAiBvD,OAjBuD,CAAA,WAkB1D,iBAlB0D,EAAA,WAmB1D,iBAnB0D,EAAA,KAAA,CAAA,CAAA,KAAA,EAqB9D,EArB8D,EAAA,MAAA,EAqBlD,EArBkD,EAAA,EAAA,EAqB1C,eArB0C,CAqB1B,EArB0B,EAqBtB,EArBsB,EAqBlB,KArBkB,CAAA,CAAA,EAqBT,KArBS,CAqBH,KArBG,CAAA"}

package/dist/zip-with-CYcCKziW.d.cts

@@ -0,0 +1,50 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+
+//#region src/zip-with.d.ts
+type ZippingFunction<T1 extends IterableContainer = IterableContainer, T2 extends IterableContainer = IterableContainer, Value = unknown> = (first: T1[number], second: T2[number], index: number, data: readonly [first: T1, second: T2]) => Value;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ *
+ * @param fn - The function applied to each position of the list.
+ * @signature
+ *   P.zipWith(fn)(first, second)
+ * @example
+ *   P.zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']
+ * @category Array
+ */
+declare function zipWith<TItem1, TItem2, Value>(fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>): <T1 extends IterableContainer<TItem1>, T2 extends IterableContainer<TItem2>>(first: T1, second: T2) => Array<Value>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ *
+ * @param second - The second input list.
+ * @param fn - The function applied to each position of the list.
+ * @signature
+ *   P.zipWith(second, fn)(first)
+ * @example
+ *   P.pipe(['1', '2', '3'], P.zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ *
+ * @param first - The first input list.
+ * @param second - The second input list.
+ * @param fn - The function applied to each position of the list.
+ * @signature
+ *   P.zipWith(first, second, fn)
+ * @example
+ *   P.zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;
+//#endregion
+export { zipWith };
+//# sourceMappingURL=zip-with-CYcCKziW.d.cts.map

package/dist/zip-with-CYcCKziW.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-with-CYcCKziW.d.cts","names":[],"sources":["../src/zip-with.ts"],"sourcesContent":[],"mappings":";;;KAIK,2BACQ,oBAAoB,8BACpB,oBAAoB,8CAGxB,oBACC,kDAEe,YAAY,QAChC;;AAbwE;;;;;;;;;;AAaxE,iBAaW,OAbX,CAAA,MAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA,EAAA,EAcC,eAdD,CAciB,aAdjB,CAc+B,MAd/B,CAAA,EAcwC,aAdxC,CAcsD,MAdtD,CAAA,EAc+D,KAd/D,CAAA,CAAA,EAAA,CAAA,WAeU,iBAfV,CAe4B,MAf5B,CAAA,EAAA,WAegD,iBAfhD,CAekE,MAflE,CAAA,CAAA,CAAA,KAAA,EAgBI,EAhBJ,EAAA,MAAA,EAiBK,EAjBL,EAAA,GAkBA,KAlBA,CAkBM,KAlBN,CAAA;;AAaL;;;;;;;;;;;;;AAIU,iBAiBM,OAjBN,CAAA,WAkBG,iBAlBH,EAAA,WAmBG,iBAnBH,EAAA,KAAA,CAAA,CAAA,MAAA,EAqBA,EArBA,EAAA,EAAA,EAqBQ,eArBR,CAqBwB,EArBxB,EAqB4B,EArB5B,EAqBgC,KArBhC,CAAA,CAAA,EAAA,CAAA,KAAA,EAqBiD,EArBjD,EAAA,GAqBwD,KArBxD,CAqB8D,KArB9D,CAAA;;;;AAiBV;;;;;;;;;;;;AAIuE,iBAiBvD,OAjBuD,CAAA,WAkB1D,iBAlB0D,EAAA,WAmB1D,iBAnB0D,EAAA,KAAA,CAAA,CAAA,KAAA,EAqB9D,EArB8D,EAAA,MAAA,EAqBlD,EArBkD,EAAA,EAAA,EAqB1C,eArB0C,CAqB1B,EArB0B,EAqBtB,EArBsB,EAqBlB,KArBkB,CAAA,CAAA,EAqBT,KArBS,CAqBH,KArBG,CAAA"}

package/dist/zip-with-CxR_nx2Y.cjs

@@ -0,0 +1 @@
+const e=require(`./lazy-data-last-impl-3PAFkslW.cjs`);function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e.lazyDataLastImpl(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}Object.defineProperty(exports,`zipWith`,{enumerable:!0,get:function(){return t}});

package/dist/zip-with-cxqqhe-S.js

@@ -0,0 +1,2 @@
+import{lazyDataLastImpl as e}from"./lazy-data-last-impl-7QfM1xXg.js";function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}export{t as zipWith};
+//# sourceMappingURL=zip-with-cxqqhe-S.js.map

package/dist/zip-with-cxqqhe-S.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-with-cxqqhe-S.js","names":[],"sources":["../src/zip-with.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\ntype ZippingFunction<\n  T1 extends IterableContainer = IterableContainer,\n  T2 extends IterableContainer = IterableContainer,\n  Value = unknown,\n> = (\n  first: T1[number],\n  second: T2[number],\n  index: number,\n  data: readonly [first: T1, second: T2],\n) => Value;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param fn - The function applied to each position of the list.\n * @signature\n *   P.zipWith(fn)(first, second)\n * @example\n *   P.zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']\n * @category Array\n */\nexport function zipWith<TItem1, TItem2, Value>(\n  fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>,\n): <T1 extends IterableContainer<TItem1>, T2 extends IterableContainer<TItem2>>(\n  first: T1,\n  second: T2,\n) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   P.zipWith(second, fn)(first)\n * @example\n *   P.pipe(['1', '2', '3'], P.zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   P.zipWith(first, second, fn)\n * @example\n *   P.zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;\n\nexport function zipWith(\n  arg0: IterableContainer | ZippingFunction,\n  arg1?: IterableContainer | ZippingFunction,\n  arg2?: ZippingFunction,\n): unknown {\n  if (typeof arg0 === 'function') {\n    // Both datum's last\n    return (data1: IterableContainer, data2: IterableContainer) =>\n      zipWithImplementation(data1, data2, arg0);\n  }\n\n  if (typeof arg1 === 'function') {\n    // dataLast\n    return lazyDataLastImpl(\n      zipWithImplementation,\n      [arg0, arg1],\n      lazyImplementation,\n    );\n  }\n\n  // dataFirst. Notice that we assert that the arguments are defined to reduce\n  // the number of runtime checks that would otherwise be needed to make\n  // TypeScript happy here. Because this is an internal implementation and we\n  // are protected by the function typing itself this is fine!\n  return zipWithImplementation(arg0, arg1!, arg2!);\n}\n\nfunction zipWithImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value> {\n  const datum = [first, second] as const;\n  return first.length < second.length\n    ? first.map((item, index) => fn(item, second[index], index, datum))\n    : second.map((item, index) => fn(first[index], item, index, datum));\n}\n\nfunction lazyImplementation<T1, T2 extends IterableContainer, Value>(\n  second: T2,\n  fn: ZippingFunction<ReadonlyArray<T1>, T2, Value>,\n): LazyEvaluator<T1, Value> {\n  return (value, index, data) => ({\n    next: fn(value, second[index], index, [data, second]),\n    hasNext: true,\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"qEA0EA,SAAgB,EACd,EACA,EACA,EACS,CAoBT,OAnBI,OAAO,GAAS,YAEV,EAA0B,IAChC,EAAsB,EAAO,EAAO,EAAK,CAGzC,OAAO,GAAS,WAEX,EACL,EACA,CAAC,EAAM,EAAK,CACZ,EACD,CAOI,EAAsB,EAAM,EAAO,EAAM,CAGlD,SAAS,EAIP,EAAW,EAAY,EAAkD,CACzE,IAAM,EAAQ,CAAC,EAAO,EAAO,CAC7B,OAAO,EAAM,OAAS,EAAO,OACzB,EAAM,KAAK,EAAM,IAAU,EAAG,EAAM,EAAO,GAAQ,EAAO,EAAM,CAAC,CACjE,EAAO,KAAK,EAAM,IAAU,EAAG,EAAM,GAAQ,EAAM,EAAO,EAAM,CAAC,CAGvE,SAAS,EACP,EACA,EAC0B,CAC1B,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,EAAG,EAAO,EAAO,GAAQ,EAAO,CAAC,EAAM,EAAO,CAAC,CACrD,QAAS,GACT,KAAM,GAAS,EAAO,OAAS,EAChC"}

package/dist/zip-with.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBUOTA64Pcjs = require('./chunk-BUOTA64P.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.zipWith = _chunkBUOTA64Pcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`);const e=require(`./zip-with-CxR_nx2Y.cjs`);exports.zipWith=e.zipWith;

package/dist/zip-with.d.cts

@@ -1,48 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-
-type ZippingFunction<T1 extends IterableContainer = IterableContainer, T2 extends IterableContainer = IterableContainer, Value = unknown> = (first: T1[number], second: T2[number], index: number, data: readonly [first: T1, second: T2]) => Value;
-/**
- * Creates a new list from two supplied lists by calling the supplied function
- * with the same-positioned element from each list.
- *
- * @param fn - The function applied to each position of the list.
- * @signature
- *   P.zipWith(fn)(first, second)
- * @example
- *   P.zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']
- * @category Array
- */
-declare function zipWith<TItem1, TItem2, Value>(fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>): <T1 extends IterableContainer<TItem1>, T2 extends IterableContainer<TItem2>>(first: T1, second: T2) => Array<Value>;
-/**
- * Creates a new list from two supplied lists by calling the supplied function
- * with the same-positioned element from each list.
- *
- * @param second - The second input list.
- * @param fn - The function applied to each position of the list.
- * @signature
- *   P.zipWith(second, fn)(first)
- * @example
- *   P.pipe(['1', '2', '3'], P.zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;
-/**
- * Creates a new list from two supplied lists by calling the supplied function
- * with the same-positioned element from each list.
- *
- * @param first - The first input list.
- * @param second - The second input list.
- * @param fn - The function applied to each position of the list.
- * @signature
- *   P.zipWith(first, second, fn)
- * @example
- *   P.zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;
-
-export { zipWith };
+import "./iterable-container-V5sa0V_H.cjs";
+import { zipWith } from "./zip-with-CYcCKziW.cjs";
+export { zipWith };

package/dist/zip-with.d.ts

@@ -1,48 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-
-type ZippingFunction<T1 extends IterableContainer = IterableContainer, T2 extends IterableContainer = IterableContainer, Value = unknown> = (first: T1[number], second: T2[number], index: number, data: readonly [first: T1, second: T2]) => Value;
-/**
- * Creates a new list from two supplied lists by calling the supplied function
- * with the same-positioned element from each list.
- *
- * @param fn - The function applied to each position of the list.
- * @signature
- *   P.zipWith(fn)(first, second)
- * @example
- *   P.zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']
- * @category Array
- */
-declare function zipWith<TItem1, TItem2, Value>(fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>): <T1 extends IterableContainer<TItem1>, T2 extends IterableContainer<TItem2>>(first: T1, second: T2) => Array<Value>;
-/**
- * Creates a new list from two supplied lists by calling the supplied function
- * with the same-positioned element from each list.
- *
- * @param second - The second input list.
- * @param fn - The function applied to each position of the list.
- * @signature
- *   P.zipWith(second, fn)(first)
- * @example
- *   P.pipe(['1', '2', '3'], P.zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;
-/**
- * Creates a new list from two supplied lists by calling the supplied function
- * with the same-positioned element from each list.
- *
- * @param first - The first input list.
- * @param second - The second input list.
- * @param fn - The function applied to each position of the list.
- * @signature
- *   P.zipWith(first, second, fn)
- * @example
- *   P.zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function zipWith<T1 extends IterableContainer, T2 extends IterableContainer, Value>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;
-
-export { zipWith };
+import "./iterable-container-F9CDF7ym.js";
+import { zipWith } from "./zip-with-BEpLRmfK.js";
+export { zipWith };

package/dist/zip-with.js

@@ -1 +1 @@
-import{a}from"./chunk-Z7DYKN6W.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as zipWith};
+import"./lazy-data-last-impl-7QfM1xXg.js";import{zipWith as e}from"./zip-with-cxqqhe-S.js";export{e as zipWith};

package/dist/zip.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkKGWDTRVRcjs = require('./chunk-KGWDTRVR.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.zip = _chunkKGWDTRVRcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./zip-DoQHstmA.cjs`);exports.zip=e.zip;

package/dist/zip.d.cts

@@ -1,42 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-
-type Zipped<Left extends IterableContainer, Right extends IterableContainer> = Left extends readonly [] ? [] : Right extends readonly [] ? [] : Left extends readonly [infer LeftHead, ...infer LeftRest] ? Right extends readonly [infer RightHead, ...infer RightRest] ? [
-    [LeftHead, RightHead],
-    ...Zipped<LeftRest, RightRest>
-] : [
-    [LeftHead, Right[number]],
-    ...Zipped<LeftRest, Right>
-] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zipped<Left, RightRest>] : Array<[Left[number], Right[number]]>;
-/**
- * Creates a new list from two supplied lists by pairing up equally-positioned
- * items. The length of the returned list will match the shortest of the two
- * inputs.
- *
- * @param first - The first input list.
- * @param second - The second input list.
- * @signature
- *   P.zip(first, second)
- * @example
- *   P.zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function zip<F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zipped<F, S>;
-/**
- * Creates a new list from two supplied lists by pairing up equally-positioned
- * items. The length of the returned list will match the shortest of the two
- * inputs.
- *
- * @param second - The second input list.
- * @signature
- *   P.zip(second)(first)
- * @example
- *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function zip<S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zipped<F, S>;
-
-export { zip };
+import "./iterable-container-V5sa0V_H.cjs";
+import { zip } from "./zip-CSvsKjDN.cjs";
+export { zip };

package/dist/zip.d.ts

@@ -1,42 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-
-type Zipped<Left extends IterableContainer, Right extends IterableContainer> = Left extends readonly [] ? [] : Right extends readonly [] ? [] : Left extends readonly [infer LeftHead, ...infer LeftRest] ? Right extends readonly [infer RightHead, ...infer RightRest] ? [
-    [LeftHead, RightHead],
-    ...Zipped<LeftRest, RightRest>
-] : [
-    [LeftHead, Right[number]],
-    ...Zipped<LeftRest, Right>
-] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zipped<Left, RightRest>] : Array<[Left[number], Right[number]]>;
-/**
- * Creates a new list from two supplied lists by pairing up equally-positioned
- * items. The length of the returned list will match the shortest of the two
- * inputs.
- *
- * @param first - The first input list.
- * @param second - The second input list.
- * @signature
- *   P.zip(first, second)
- * @example
- *   P.zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function zip<F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zipped<F, S>;
-/**
- * Creates a new list from two supplied lists by pairing up equally-positioned
- * items. The length of the returned list will match the shortest of the two
- * inputs.
- *
- * @param second - The second input list.
- * @signature
- *   P.zip(second)(first)
- * @example
- *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function zip<S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zipped<F, S>;
-
-export { zip };
+import "./iterable-container-F9CDF7ym.js";
+import { zip } from "./zip-CItdS_iZ.js";
+export { zip };

package/dist/zip.js

@@ -1 +1 @@
-import{a}from"./chunk-K7T2WOD7.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as zip};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{zip as e}from"./zip-Bx1gp9g8.js";export{e as zip};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vinicunca/perkakas",
   "type": "module",
-  "version": "1.7.1",
+  "version": "1.9.0",
   "description": "Utility for JavaScript and Typescript.",
   "author": "praburangki<https://github.com/praburangki>",
   "license": "MIT",
@@ -40,25 +40,28 @@
     "type-fest": "^4.41.0"
   },
   "devDependencies": {
+    "@arethetypeswrong/core": "^0.18.2",
     "@types/node": "^22.17.0",
-    "@vinicunca/eslint-config": "^3.20.0",
+    "@vinicunca/eslint-config": "^3.28.0",
     "@vitest/coverage-v8": "^3.2.4",
-    "bumpp": "^10.2.2",
-    "eslint": "^9.32.0",
+    "bumpp": "^10.3.1",
+    "eslint": "^9.37.0",
     "prettier": "^3.6.2",
-    "taze": "^19.1.0",
+    "publint": "^0.3.14",
+    "taze": "^19.7.0",
+    "tsdown": "^0.15.7",
     "tsup": "^8.5.0",
-    "typescript": "^5.9.2",
+    "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "prepublish": "pnpm run build",
     "dev": "pnpm build --watch",
     "lint": "eslint . --fix",
     "publish:ci": "pnpm publish --access public --no-git-checks",
     "release": "bumpp package.json",
-    "taze": "taze major -wIr",
+    "taze": "taze major -wIrl",
     "test": "tsc --project tsconfig.tests.json && vitest --typecheck.enabled --typecheck.ignoreSourceErrors",
     "test:runtime": "tsc --project tsconfig.tests.json && vitest",
     "test:typing": "vitest --typecheck.only --typecheck.ignoreSourceErrors",

package/dist/array-required-prefix-Ck4lHkbA.d.cts

@@ -1,33 +0,0 @@
-import { IsLiteral, And, GreaterThan, IsNever, IsEqual, ReadonlyTuple } from 'type-fest';
-import { C as ClampedIntegerSubtract } from './clamped-integer-subtract-DZ7rsJE4.cjs';
-import { C as CoercedArray } from './coerced-array-DRz3tqda.cjs';
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-import { P as PerkakasTypeError } from './perkakas-type-error-8wPb8T2y.cjs';
-import { T as TupleParts } from './tuple-parts-v6av7LMU.cjs';
-
-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;
-
-export type { ArrayRequiredPrefix as A };

package/dist/array-required-prefix-DXv_WnmG.d.ts

@@ -1,33 +0,0 @@
-import { IsLiteral, And, GreaterThan, IsNever, IsEqual, ReadonlyTuple } from 'type-fest';
-import { C as ClampedIntegerSubtract } from './clamped-integer-subtract-DZ7rsJE4.js';
-import { C as CoercedArray } from './coerced-array-DRz3tqda.js';
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-import { P as PerkakasTypeError } from './perkakas-type-error-8wPb8T2y.js';
-import { T as TupleParts } from './tuple-parts-BTivqbtT.js';
-
-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;
-
-export type { ArrayRequiredPrefix as A };

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

@@ -1,14 +0,0 @@
-import { I as IsBoundedRecord } from './is-bounded-record-C9WAwfA8.js';
-
-/**
- * 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;
-
-export type { BoundedPartial as B };

package/dist/bounded-partial-BhnecV3P.d.cts

@@ -1,14 +0,0 @@
-import { I as IsBoundedRecord } from './is-bounded-record-C9WAwfA8.cjs';
-
-/**
- * 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;
-
-export type { BoundedPartial as B };

package/dist/case.types-C6kHRY4f.d.cts

@@ -1,16 +0,0 @@
-/**
- * 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;
-}
-
-export type { ChangeCaseOptions as C };