@vinicunca/perkakas 0.5.4 → 1.0.0

package/dist/pipe.d.ts

@@ -0,0 +1,60 @@
+type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: ReadonlyArray<T>) => LazyResult<R>;
+type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
+interface LazyEmpty {
+    done: boolean;
+    hasMany?: false | undefined;
+    hasNext: false;
+    next?: undefined;
+}
+interface LazyNext<T> {
+    done: boolean;
+    hasMany?: false | undefined;
+    hasNext: true;
+    next: T;
+}
+interface LazyMany<T> {
+    done: boolean;
+    hasMany: true;
+    hasNext: true;
+    next: ReadonlyArray<T>;
+}
+type LazyFn = (value: unknown, index: number, items: ReadonlyArray<unknown>) => LazyResult<unknown>;
+interface LazyMeta {
+    readonly single?: boolean;
+}
+interface LazyDefinition {
+    readonly lazy: LazyMeta & ((...args: any) => LazyFn);
+    readonly lazyArgs: ReadonlyArray<unknown>;
+}
+/**
+ * Perform left-to-right function composition.
+ *
+ * @param value - The initial value.
+ * @param operations - The list of operations to apply.
+ * @signature P.pipe(data, op1, op2, op3)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 3, 4],
+ *      P.map(x => x * 2),
+ *      arr => [arr[0] + arr[1], arr[2] + arr[3]],
+ *    ) // => [6, 14]
+ * @dataFirst
+ * @category Function
+ */
+declare function pipe<A, B>(value: A, op1: (input: A) => B): B;
+declare function pipe<A, B, C>(value: A, op1: (input: A) => B, op2: (input: B) => C): C;
+declare function pipe<A, B, C, D>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): D;
+declare function pipe<A, B, C, D, E>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): E;
+declare function pipe<A, B, C, D, E, F>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F): F;
+declare function pipe<A, B, C, D, E, F, G>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G): G;
+declare function pipe<A, B, C, D, E, F, G, H>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H): H;
+declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H, op8: (input: H) => I): I;
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H, op8: (input: H) => I, op9: (input: I) => J): J;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K): K;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L): L;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M): M;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N): N;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N, op14: (input: N) => O): O;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N, op14: (input: N) => O, op15: (input: O) => P): P;
+
+export { type LazyDefinition, type LazyEvaluator, type LazyResult, pipe };

package/dist/pipe.js

@@ -0,0 +1 @@
+import{a}from"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";export{a as pipe};

package/dist/piped.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkGNPFJJSCcjs = require('./chunk-GNPFJJSC.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');exports.piped = _chunkGNPFJJSCcjs.a;

package/dist/piped.d.cts

@@ -0,0 +1,29 @@
+/**
+ * A dataLast version of `pipe` that could be used to provide more complex
+ * computations to functions that accept a function as a param (like `map`,
+ * `filter`, `groupBy`, etc.).
+ *
+ * The first function must be always annotated. Other functions are
+ * automatically inferred.
+ *
+ * @signature
+ *    P.piped(...ops)(data);
+ * @example
+ *    P.filter(
+ *      [{ a: 1 }, { a: 2 }, { a: 3 }],
+ *      P.piped(
+ *        P.prop('a'),
+ *        (x) => x % 2 === 0,
+ *      ),
+ *    ); // => [{ a: 2 }]
+ * @category Function
+ */
+declare function piped<A, B>(op1: (input: A) => B): (value: A) => B;
+declare function piped<A, B, C>(op1: (input: A) => B, op2: (input: B) => C): (value: A) => C;
+declare function piped<A, B, C, D>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): (value: A) => D;
+declare function piped<A, B, C, D, E>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): (value: A) => E;
+declare function piped<A, B, C, D, E, F>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F): (value: A) => F;
+declare function piped<A, B, C, D, E, F, G>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G): (value: A) => G;
+declare function piped<A, B, C, D, E, F, G, H>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H): (value: A) => H;
+
+export { piped };

package/dist/piped.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A dataLast version of `pipe` that could be used to provide more complex
+ * computations to functions that accept a function as a param (like `map`,
+ * `filter`, `groupBy`, etc.).
+ *
+ * The first function must be always annotated. Other functions are
+ * automatically inferred.
+ *
+ * @signature
+ *    P.piped(...ops)(data);
+ * @example
+ *    P.filter(
+ *      [{ a: 1 }, { a: 2 }, { a: 3 }],
+ *      P.piped(
+ *        P.prop('a'),
+ *        (x) => x % 2 === 0,
+ *      ),
+ *    ); // => [{ a: 2 }]
+ * @category Function
+ */
+declare function piped<A, B>(op1: (input: A) => B): (value: A) => B;
+declare function piped<A, B, C>(op1: (input: A) => B, op2: (input: B) => C): (value: A) => C;
+declare function piped<A, B, C, D>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): (value: A) => D;
+declare function piped<A, B, C, D, E>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): (value: A) => E;
+declare function piped<A, B, C, D, E, F>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F): (value: A) => F;
+declare function piped<A, B, C, D, E, F, G>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G): (value: A) => G;
+declare function piped<A, B, C, D, E, F, G, H>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H): (value: A) => H;
+
+export { piped };

package/dist/piped.js

@@ -0,0 +1 @@
+import{a}from"./chunk-JLRJ44YR.js";import"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";export{a as piped};

package/dist/product.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkS2HXZ3NZcjs = require('./chunk-S2HXZ3NZ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.product = _chunkS2HXZ3NZcjs.a;

package/dist/product.d.cts

@@ -0,0 +1,34 @@
+import { N as NonEmptyArray } from './types-DCY4LHuA.cjs';
+import 'type-fest';
+
+/**
+ * Compute the product of the numbers in the array, or return 1 for an empty
+ * array.
+ *
+ * @param data - The array of numbers.
+ * @signature
+ *   P.product(data);
+ * @example
+ *   P.product([1, 2, 3]); // => 6
+ *   P.product([]); // => 1
+ * @dataFirst
+ * @category Number
+ */
+declare function product(data: ReadonlyArray<number>): number;
+declare function product(data: Readonly<NonEmptyArray<bigint>>): bigint;
+/**
+ * Compute the product of the numbers in the array, or return 1 for an empty
+ * array.
+ *
+ * @signature
+ *   P.product()(data);
+ * @example
+ *   P.pipe([1, 2, 3], P.product()); // => 6
+ *   P.pipe([], P.product()); // => 1
+ * @dataLast
+ * @category Number
+ */
+declare function product(): (data: ReadonlyArray<number>) => number;
+declare function product(): (data: Readonly<NonEmptyArray<bigint>>) => bigint;
+
+export { product };

package/dist/product.d.ts

@@ -0,0 +1,34 @@
+import { N as NonEmptyArray } from './types-DCY4LHuA.js';
+import 'type-fest';
+
+/**
+ * Compute the product of the numbers in the array, or return 1 for an empty
+ * array.
+ *
+ * @param data - The array of numbers.
+ * @signature
+ *   P.product(data);
+ * @example
+ *   P.product([1, 2, 3]); // => 6
+ *   P.product([]); // => 1
+ * @dataFirst
+ * @category Number
+ */
+declare function product(data: ReadonlyArray<number>): number;
+declare function product(data: Readonly<NonEmptyArray<bigint>>): bigint;
+/**
+ * Compute the product of the numbers in the array, or return 1 for an empty
+ * array.
+ *
+ * @signature
+ *   P.product()(data);
+ * @example
+ *   P.pipe([1, 2, 3], P.product()); // => 6
+ *   P.pipe([], P.product()); // => 1
+ * @dataLast
+ * @category Number
+ */
+declare function product(): (data: ReadonlyArray<number>) => number;
+declare function product(): (data: Readonly<NonEmptyArray<bigint>>) => bigint;
+
+export { product };

package/dist/product.js

@@ -0,0 +1 @@
+import{a}from"./chunk-BH4FVL5M.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as product};

package/dist/prop.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkSXTSJOEEcjs = require('./chunk-SXTSJOEE.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.prop = _chunkSXTSJOEEcjs.a; exports.propImplementation = _chunkSXTSJOEEcjs.b;

package/dist/prop.d.cts

@@ -0,0 +1,28 @@
+/**
+ * Gets the value of the given property.
+ *
+ * @param data - The object to extract the prop from.
+ * @param key - The key of the property to extract.
+ * @signature
+ *   P.prop(data, key);
+ * @example
+ *   P.prop({ foo: 'bar' }, 'foo'); // => 'bar'
+ * @dataFirst
+ * @category Object
+ */
+declare function prop<T, K extends keyof T>(data: T, key: K): T[K];
+/**
+ * Gets the value of the given property.
+ *
+ * @param key - The key of the property to extract.
+ * @signature
+ *   P.prop(key)(data);
+ * @example
+ *    P.pipe({foo: 'bar'}, P.prop('foo')) // => 'bar'
+ * @dataLast
+ * @category Object
+ */
+declare function prop<T, K extends keyof T>(key: K): (data: T) => T[K];
+declare function propImplementation<T, K extends keyof T>(data: T, key: K): T[K];
+
+export { prop, propImplementation };

package/dist/prop.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Gets the value of the given property.
+ *
+ * @param data - The object to extract the prop from.
+ * @param key - The key of the property to extract.
+ * @signature
+ *   P.prop(data, key);
+ * @example
+ *   P.prop({ foo: 'bar' }, 'foo'); // => 'bar'
+ * @dataFirst
+ * @category Object
+ */
+declare function prop<T, K extends keyof T>(data: T, key: K): T[K];
+/**
+ * Gets the value of the given property.
+ *
+ * @param key - The key of the property to extract.
+ * @signature
+ *   P.prop(key)(data);
+ * @example
+ *    P.pipe({foo: 'bar'}, P.prop('foo')) // => 'bar'
+ * @dataLast
+ * @category Object
+ */
+declare function prop<T, K extends keyof T>(key: K): (data: T) => T[K];
+declare function propImplementation<T, K extends keyof T>(data: T, key: K): T[K];
+
+export { prop, propImplementation };

package/dist/prop.js

@@ -0,0 +1 @@
+import{a,b}from"./chunk-USNHLUEU.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as prop,b as propImplementation};

package/dist/pull-object.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkLNPZR2QMcjs = require('./chunk-LNPZR2QM.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.pullObject = _chunkLNPZR2QMcjs.a;

package/dist/pull-object.d.cts

@@ -0,0 +1,67 @@
+import { I as IterableContainer } from './types-DCY4LHuA.cjs';
+import 'type-fest';
+
+/**
+ * Creates an object that maps the result of `valueExtractor` with a key
+ * resulting from running `keyExtractor` on each item in `data`. Duplicate keys
+ * are overwritten, guaranteeing that the extractor functions are run on each
+ * item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `fromEntries` - Builds an object from an array of key-value pairs.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @param data - The items used to pull/extract the keys and values from.
+ * @param keyExtractor - Computes the key for item.
+ * @param valueExtractor - Computes the value for the item.
+ * @signature
+ *   P.pullObject(data, keyExtractor, valueExtractor);
+ * @example
+ *   P.pullObject(
+ *     [
+ *       { name: "john", email: "john@bebedag.com" },
+ *       { name: "jane", email: "jane@bebedag.com" }
+ *     ],
+ *     P.prop("name"),
+ *     P.prop("email"),
+ *   ); // => { john: "john@bebedag.com", jane: "jane@bebedag.com" }
+ * @dataFirst
+ * @category Object
+ */
+declare function pullObject<T extends IterableContainer, K extends PropertyKey, V>(data: T, keyExtractor: (item: T[number], index: number, data: T) => K, valueExtractor: (item: T[number], index: number, data: T) => V): Partial<Record<K, V>>;
+/**
+ * Creates an object that maps the result of `valueExtractor` with a key
+ * resulting from running `keyExtractor` on each item in `data`. Duplicate keys
+ * are overwritten, guaranteeing that the extractor functions are run on each
+ * item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `fromEntries` - Builds an object from an array of key-value pairs.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @param keyExtractor - Computes the key for item.
+ * @param valueExtractor - Computes the value for the item.
+ * @signature
+ *   P.pullObject(keyExtractor, valueExtractor)(data);
+ * @example
+ *   P.pipe(
+ *     [
+ *       { name: "john", email: "john@bebedag.com" },
+ *       { name: "jane", email: "jane@bebedag.com" }
+ *     ],
+ *     P.pullObject(P.prop("email"), P.prop("name")),
+ *   ); // => { john: "john@bebedag.com", jane: "jane@bebedag.com" }
+ * @dataLast
+ * @category Object
+ */
+declare function pullObject<T extends IterableContainer, K extends PropertyKey, V>(keyExtractor: (item: T[number], index: number, data: T) => K, valueExtractor: (item: T[number], index: number, data: T) => V): (data: T) => Partial<Record<K, V>>;
+
+export { pullObject };

package/dist/pull-object.d.ts

@@ -0,0 +1,67 @@
+import { I as IterableContainer } from './types-DCY4LHuA.js';
+import 'type-fest';
+
+/**
+ * Creates an object that maps the result of `valueExtractor` with a key
+ * resulting from running `keyExtractor` on each item in `data`. Duplicate keys
+ * are overwritten, guaranteeing that the extractor functions are run on each
+ * item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `fromEntries` - Builds an object from an array of key-value pairs.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @param data - The items used to pull/extract the keys and values from.
+ * @param keyExtractor - Computes the key for item.
+ * @param valueExtractor - Computes the value for the item.
+ * @signature
+ *   P.pullObject(data, keyExtractor, valueExtractor);
+ * @example
+ *   P.pullObject(
+ *     [
+ *       { name: "john", email: "john@bebedag.com" },
+ *       { name: "jane", email: "jane@bebedag.com" }
+ *     ],
+ *     P.prop("name"),
+ *     P.prop("email"),
+ *   ); // => { john: "john@bebedag.com", jane: "jane@bebedag.com" }
+ * @dataFirst
+ * @category Object
+ */
+declare function pullObject<T extends IterableContainer, K extends PropertyKey, V>(data: T, keyExtractor: (item: T[number], index: number, data: T) => K, valueExtractor: (item: T[number], index: number, data: T) => V): Partial<Record<K, V>>;
+/**
+ * Creates an object that maps the result of `valueExtractor` with a key
+ * resulting from running `keyExtractor` on each item in `data`. Duplicate keys
+ * are overwritten, guaranteeing that the extractor functions are run on each
+ * item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `fromEntries` - Builds an object from an array of key-value pairs.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @param keyExtractor - Computes the key for item.
+ * @param valueExtractor - Computes the value for the item.
+ * @signature
+ *   P.pullObject(keyExtractor, valueExtractor)(data);
+ * @example
+ *   P.pipe(
+ *     [
+ *       { name: "john", email: "john@bebedag.com" },
+ *       { name: "jane", email: "jane@bebedag.com" }
+ *     ],
+ *     P.pullObject(P.prop("email"), P.prop("name")),
+ *   ); // => { john: "john@bebedag.com", jane: "jane@bebedag.com" }
+ * @dataLast
+ * @category Object
+ */
+declare function pullObject<T extends IterableContainer, K extends PropertyKey, V>(keyExtractor: (item: T[number], index: number, data: T) => K, valueExtractor: (item: T[number], index: number, data: T) => V): (data: T) => Partial<Record<K, V>>;
+
+export { pullObject };

package/dist/pull-object.js

@@ -0,0 +1 @@
+import{a}from"./chunk-775ZQ6M4.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as pullObject};

package/dist/random-string.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkQWQ2V7HJcjs = require('./chunk-QWQ2V7HJ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.randomString = _chunkQWQ2V7HJcjs.a;

package/dist/random-string.d.cts

@@ -0,0 +1,27 @@
+/**
+ * Random a non-cryptographic random string from characters a-zA-Z0-9.
+ *
+ * @param length - The length of the random string.
+ * @returns The random string.
+ * @signature
+ *   P.randomString(length)
+ * @example
+ *   P.randomString(5) // => aB92J
+ * @dataFirst
+ * @category String
+ */
+declare function randomString(length: number): string;
+/**
+ * Random a non-cryptographic random string from characters a-zA-Z0-9.
+ *
+ * @returns The random string.
+ * @signature
+ *   P.randomString()(length)
+ * @example
+ *   P.pipe(5, P.randomString()) // => aB92J
+ * @dataLast
+ * @category String
+ */
+declare function randomString(): (length: number) => string;
+
+export { randomString };

package/dist/random-string.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Random a non-cryptographic random string from characters a-zA-Z0-9.
+ *
+ * @param length - The length of the random string.
+ * @returns The random string.
+ * @signature
+ *   P.randomString(length)
+ * @example
+ *   P.randomString(5) // => aB92J
+ * @dataFirst
+ * @category String
+ */
+declare function randomString(length: number): string;
+/**
+ * Random a non-cryptographic random string from characters a-zA-Z0-9.
+ *
+ * @returns The random string.
+ * @signature
+ *   P.randomString()(length)
+ * @example
+ *   P.pipe(5, P.randomString()) // => aB92J
+ * @dataLast
+ * @category String
+ */
+declare function randomString(): (length: number) => string;
+
+export { randomString };

package/dist/random-string.js

@@ -0,0 +1 @@
+import{a}from"./chunk-JK22NVTR.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as randomString};

package/dist/range.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkOQ34Z5CLcjs = require('./chunk-OQ34Z5CL.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.range = _chunkOQ34Z5CLcjs.a;

package/dist/range.d.cts

@@ -0,0 +1,25 @@
+/**
+ * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
+ *
+ * @param start - The start number.
+ * @param end - The end number.
+ * @signature range(start, end)
+ * @example
+ *    P.range(1, 5) // => [1, 2, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function range(start: number, end: number): Array<number>;
+/**
+ * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
+ *
+ * @param end - The end number.
+ * @signature range(end)(start)
+ * @example
+ *    P.range(5)(1) // => [1, 2, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function range(end: number): (start: number) => Array<number>;
+
+export { range };

package/dist/range.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
+ *
+ * @param start - The start number.
+ * @param end - The end number.
+ * @signature range(start, end)
+ * @example
+ *    P.range(1, 5) // => [1, 2, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function range(start: number, end: number): Array<number>;
+/**
+ * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
+ *
+ * @param end - The end number.
+ * @signature range(end)(start)
+ * @example
+ *    P.range(5)(1) // => [1, 2, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function range(end: number): (start: number) => Array<number>;
+
+export { range };

package/dist/range.js

@@ -0,0 +1 @@
+import{a}from"./chunk-GU2VTZ37.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as range};

package/dist/rank-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkRF4ZO322cjs = require('./chunk-RF4ZO322.cjs');require('./chunk-FWQYL4Y4.cjs');exports.rankBy = _chunkRF4ZO322cjs.a;

package/dist/rank-by.d.cts

@@ -0,0 +1,43 @@
+import { N as NonEmptyArray } from './types-DCY4LHuA.cjs';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.cjs';
+import 'type-fest';
+
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param data - The input array.
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns The rank of the item in the sorted array in the range [0..data.length].
+ * @signature
+ *   P.rankBy(data, item, ...rules)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.rankBy(DATA, 0, P.prop('a')) // => 0
+ *   P.rankBy(DATA, 1, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 2, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 3, P.prop('a')) // => 2
+ * @dataFirst
+ * @category Array
+ */
+declare function rankBy<T>(data: ReadonlyArray<T>, item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): number;
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns The rank of the item in the sorted array in the range [0..data.length].
+ * @signature
+ *   P.rankBy(item, ...rules)(data)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.pipe(DATA, P.rankBy(0, P.prop('a'))) // => 0
+ *   P.pipe(DATA, P.rankBy(1, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(2, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(3, P.prop('a'))) // => 2
+ * @dataLast
+ * @category Array
+ */
+declare function rankBy<T>(item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => number;
+
+export { rankBy };

package/dist/rank-by.d.ts

@@ -0,0 +1,43 @@
+import { N as NonEmptyArray } from './types-DCY4LHuA.js';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.js';
+import 'type-fest';
+
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param data - The input array.
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns The rank of the item in the sorted array in the range [0..data.length].
+ * @signature
+ *   P.rankBy(data, item, ...rules)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.rankBy(DATA, 0, P.prop('a')) // => 0
+ *   P.rankBy(DATA, 1, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 2, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 3, P.prop('a')) // => 2
+ * @dataFirst
+ * @category Array
+ */
+declare function rankBy<T>(data: ReadonlyArray<T>, item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): number;
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns The rank of the item in the sorted array in the range [0..data.length].
+ * @signature
+ *   P.rankBy(item, ...rules)(data)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.pipe(DATA, P.rankBy(0, P.prop('a'))) // => 0
+ *   P.pipe(DATA, P.rankBy(1, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(2, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(3, P.prop('a'))) // => 2
+ * @dataLast
+ * @category Array
+ */
+declare function rankBy<T>(item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => number;
+
+export { rankBy };

package/dist/rank-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-TBMLJPXO.js";import"./chunk-JXXXUJM5.js";export{a as rankBy};

package/dist/reduce.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkQVDYQ7ZEcjs = require('./chunk-QVDYQ7ZE.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.reduce = _chunkQVDYQ7ZEcjs.a;