@vinicunca/perkakas 0.5.4 → 1.0.0

package/dist/from-entries.d.cts

@@ -0,0 +1,72 @@
+import { Simplify } from 'type-fest';
+import { I as IterableContainer } from './types-DCY4LHuA.cjs';
+
+type Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [
+    key: Key,
+    value: Value
+];
+type FromEntries<Entries> = Entries extends readonly [
+    infer First,
+    ...infer Tail
+] ? FromEntriesTuple<First, Tail> : Entries extends readonly [...infer Head, infer Last] ? FromEntriesTuple<Last, Head> : Entries extends IterableContainer<Entry> ? FromEntriesArray<Entries> : 'ERROR: Entries array-like could not be inferred';
+type FromEntriesTuple<E, Rest> = E extends Entry ? FromEntries<Rest> & Record<E[0], E[1]> : 'ERROR: Array-like contains a non-entry element';
+type FromEntriesArray<Entries extends IterableContainer<Entry>> = string extends AllKeys<Entries> ? Record<string, Entries[number][1]> : number extends AllKeys<Entries> ? Record<number, Entries[number][1]> : symbol extends AllKeys<Entries> ? Record<symbol, Entries[number][1]> : FromEntriesArrayWithLiteralKeys<Entries>;
+type FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>> = {
+    [P in AllKeys<Entries>]?: ValueForKey<Entries, P>;
+};
+type AllKeys<Entries extends IterableContainer<Entry>> = Extract<Entries[number], Entry>[0];
+type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey> = (Extract<Entries[number], Entry<K>> extends never ? Entries[number] : Extract<Entries[number], Entry<K>>)[1];
+/**
+ * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
+ * If a tuple is not supplied for any element in the array, the element will be ignored
+ * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
+ *
+ * The strict option supports more sophisticated use-cases like those that would
+ * result when calling the strict `toPairs` function.
+ *
+ * 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.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `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 entries - An array of key-value pairs.
+ * @signature
+ *   P.fromEntries(tuples)
+ * @example
+ *   P.fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}
+ * @dataFirst
+ * @category Object
+ */
+declare function fromEntries<Entries extends IterableContainer<Entry>>(entries: Entries): Simplify<FromEntries<Entries>>;
+/**
+ * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
+ * If a tuple is not supplied for any element in the array, the element will be ignored
+ * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
+ *
+ * The strict option supports more sophisticated use-cases like those that would
+ * result when calling the strict `toPairs` function.
+ *
+ * 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.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @signature
+ *   P.fromEntries()(tuples)
+ * @example
+ *   P.pipe(
+ *     [['a', 'b'], ['c', 'd']] as const,
+ *     P.fromEntries(),
+ *   ); // => {a: 'b', c: 'd'}
+ * @dataLast
+ * @category Object
+ */
+declare function fromEntries(): <Entries extends IterableContainer<Entry>>(entries: Entries) => Simplify<FromEntries<Entries>>;
+
+export { fromEntries };

package/dist/from-entries.d.ts

@@ -0,0 +1,72 @@
+import { Simplify } from 'type-fest';
+import { I as IterableContainer } from './types-DCY4LHuA.js';
+
+type Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [
+    key: Key,
+    value: Value
+];
+type FromEntries<Entries> = Entries extends readonly [
+    infer First,
+    ...infer Tail
+] ? FromEntriesTuple<First, Tail> : Entries extends readonly [...infer Head, infer Last] ? FromEntriesTuple<Last, Head> : Entries extends IterableContainer<Entry> ? FromEntriesArray<Entries> : 'ERROR: Entries array-like could not be inferred';
+type FromEntriesTuple<E, Rest> = E extends Entry ? FromEntries<Rest> & Record<E[0], E[1]> : 'ERROR: Array-like contains a non-entry element';
+type FromEntriesArray<Entries extends IterableContainer<Entry>> = string extends AllKeys<Entries> ? Record<string, Entries[number][1]> : number extends AllKeys<Entries> ? Record<number, Entries[number][1]> : symbol extends AllKeys<Entries> ? Record<symbol, Entries[number][1]> : FromEntriesArrayWithLiteralKeys<Entries>;
+type FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>> = {
+    [P in AllKeys<Entries>]?: ValueForKey<Entries, P>;
+};
+type AllKeys<Entries extends IterableContainer<Entry>> = Extract<Entries[number], Entry>[0];
+type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey> = (Extract<Entries[number], Entry<K>> extends never ? Entries[number] : Extract<Entries[number], Entry<K>>)[1];
+/**
+ * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
+ * If a tuple is not supplied for any element in the array, the element will be ignored
+ * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
+ *
+ * The strict option supports more sophisticated use-cases like those that would
+ * result when calling the strict `toPairs` function.
+ *
+ * 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.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `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 entries - An array of key-value pairs.
+ * @signature
+ *   P.fromEntries(tuples)
+ * @example
+ *   P.fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}
+ * @dataFirst
+ * @category Object
+ */
+declare function fromEntries<Entries extends IterableContainer<Entry>>(entries: Entries): Simplify<FromEntries<Entries>>;
+/**
+ * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
+ * If a tuple is not supplied for any element in the array, the element will be ignored
+ * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
+ *
+ * The strict option supports more sophisticated use-cases like those that would
+ * result when calling the strict `toPairs` function.
+ *
+ * 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.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @signature
+ *   P.fromEntries()(tuples)
+ * @example
+ *   P.pipe(
+ *     [['a', 'b'], ['c', 'd']] as const,
+ *     P.fromEntries(),
+ *   ); // => {a: 'b', c: 'd'}
+ * @dataLast
+ * @category Object
+ */
+declare function fromEntries(): <Entries extends IterableContainer<Entry>>(entries: Entries) => Simplify<FromEntries<Entries>>;
+
+export { fromEntries };

package/dist/from-entries.js

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

package/dist/from-keys.cjs

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

package/dist/from-keys.d.cts

@@ -0,0 +1,59 @@
+import { Simplify } from 'type-fest';
+import { I as IterableContainer } from './types-DCY4LHuA.cjs';
+
+type ExactlyOneKey<T, V> = T extends PropertyKey ? {
+    [P in T]: V;
+} : never;
+type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? Partial<Record<T[number], V>> : never;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `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 - An array of keys of the output object. All items in the array
+ * would be keys in the output array.
+ * @param mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(data, mapper);
+ * @example
+ *   P.fromKeys(["cat", "dog"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataFirst
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(data: T, mapper: (item: T[number], index: number, data: T) => V): Simplify<FromKeys<T, V>>;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `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 mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(mapper)(data);
+ * @example
+ *   P.pipe(["cat", "dog"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataLast
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(mapper: (item: T[number], index: number, data: T) => V): (data: T) => Simplify<FromKeys<T, V>>;
+
+export { fromKeys };

package/dist/from-keys.d.ts

@@ -0,0 +1,59 @@
+import { Simplify } from 'type-fest';
+import { I as IterableContainer } from './types-DCY4LHuA.js';
+
+type ExactlyOneKey<T, V> = T extends PropertyKey ? {
+    [P in T]: V;
+} : never;
+type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? Partial<Record<T[number], V>> : never;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `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 - An array of keys of the output object. All items in the array
+ * would be keys in the output array.
+ * @param mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(data, mapper);
+ * @example
+ *   P.fromKeys(["cat", "dog"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataFirst
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(data: T, mapper: (item: T[number], index: number, data: T) => V): Simplify<FromKeys<T, V>>;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `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 mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(mapper)(data);
+ * @example
+ *   P.pipe(["cat", "dog"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataLast
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(mapper: (item: T[number], index: number, data: T) => V): (data: T) => Simplify<FromKeys<T, V>>;
+
+export { fromKeys };

package/dist/from-keys.js

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

package/dist/group-by.cjs

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

package/dist/group-by.d.cts

@@ -0,0 +1,56 @@
+import { b as ExactRecord, N as NonEmptyArray } from './types-DCY4LHuA.cjs';
+import 'type-fest';
+
+/**
+ * Groups the elements of a given iterable according to the string values
+ * returned by a provided callback function. The returned object has separate
+ * properties for each group, containing arrays with the elements in the group.
+ * Unlike the built in `Object.groupBy` this function also allows the callback to
+ * return `undefined` in order to exclude the item from being added to any
+ * group.
+ *
+ * @param data - The items to group.
+ * @param callbackfn - A function to execute for each element in the iterable.
+ * It should return a value indicating the group of the current element, or
+ * `undefined` when the item should be excluded from any group.
+ * @returns An object with properties for all groups, each assigned to an array
+ * containing the elements of the associated group.
+ * @signature
+ *    P.groupBy(data, callbackfn)
+ * @example
+ *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
+ *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
+ * @dataFirst
+ * @category Array
+ */
+declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): ExactRecord<Key, NonEmptyArray<T>>;
+/**
+ * Groups the elements of a given iterable according to the string values
+ * returned by a provided callback function. The returned object has separate
+ * properties for each group, containing arrays with the elements in the group.
+ * Unlike the built in `Object.groupBy` this function also allows the callback to
+ * return `undefined` in order to exclude the item from being added to any
+ * group.
+ *
+ * @param callbackfn - A function to execute for each element in the iterable.
+ * It should return a value indicating the group of the current element, or
+ * `undefined` when the item should be excluded from any group.
+ * @returns An object with properties for all groups, each assigned to an array
+ * containing the elements of the associated group.
+ * @signature
+ *    P.groupBy(callbackfn)(data);
+ * @example
+ *    P.pipe(
+ *      [{a: 'cat'}, {a: 'dog'}] as const,
+ *      P.groupBy(P.prop('a')),
+ *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
+ *    P.pipe(
+ *      [0, 1],
+ *      P.groupBy(x => x % 2 === 0 ? 'even' : undefined),
+ *    ); // => {even: [0]}
+ * @dataLast
+ * @category Array
+ */
+declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => ExactRecord<Key, NonEmptyArray<T>>;
+
+export { groupBy };

package/dist/group-by.d.ts

@@ -0,0 +1,56 @@
+import { b as ExactRecord, N as NonEmptyArray } from './types-DCY4LHuA.js';
+import 'type-fest';
+
+/**
+ * Groups the elements of a given iterable according to the string values
+ * returned by a provided callback function. The returned object has separate
+ * properties for each group, containing arrays with the elements in the group.
+ * Unlike the built in `Object.groupBy` this function also allows the callback to
+ * return `undefined` in order to exclude the item from being added to any
+ * group.
+ *
+ * @param data - The items to group.
+ * @param callbackfn - A function to execute for each element in the iterable.
+ * It should return a value indicating the group of the current element, or
+ * `undefined` when the item should be excluded from any group.
+ * @returns An object with properties for all groups, each assigned to an array
+ * containing the elements of the associated group.
+ * @signature
+ *    P.groupBy(data, callbackfn)
+ * @example
+ *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
+ *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
+ * @dataFirst
+ * @category Array
+ */
+declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): ExactRecord<Key, NonEmptyArray<T>>;
+/**
+ * Groups the elements of a given iterable according to the string values
+ * returned by a provided callback function. The returned object has separate
+ * properties for each group, containing arrays with the elements in the group.
+ * Unlike the built in `Object.groupBy` this function also allows the callback to
+ * return `undefined` in order to exclude the item from being added to any
+ * group.
+ *
+ * @param callbackfn - A function to execute for each element in the iterable.
+ * It should return a value indicating the group of the current element, or
+ * `undefined` when the item should be excluded from any group.
+ * @returns An object with properties for all groups, each assigned to an array
+ * containing the elements of the associated group.
+ * @signature
+ *    P.groupBy(callbackfn)(data);
+ * @example
+ *    P.pipe(
+ *      [{a: 'cat'}, {a: 'dog'}] as const,
+ *      P.groupBy(P.prop('a')),
+ *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
+ *    P.pipe(
+ *      [0, 1],
+ *      P.groupBy(x => x % 2 === 0 ? 'even' : undefined),
+ *    ); // => {even: [0]}
+ * @dataLast
+ * @category Array
+ */
+declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => ExactRecord<Key, NonEmptyArray<T>>;
+
+export { groupBy };

package/dist/group-by.js

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

package/dist/has-at-least.cjs

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

package/dist/has-at-least.d.cts

@@ -0,0 +1,68 @@
+import { IsNumericLiteral } from 'type-fest';
+import { I as IterableContainer } from './types-DCY4LHuA.cjs';
+
+type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration extends ReadonlyArray<unknown> = []> = number extends Min ? never : Iteration['length'] extends Min ? T : T extends readonly [] ? never : T extends [infer Head, ...infer Rest] ? [
+    Head,
+    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
+] : T extends readonly [infer Head, ...infer Rest] ? readonly [
+    Head,
+    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
+] : T extends Array<infer Item> ? [
+    Item,
+    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
+] : T extends ReadonlyArray<infer Item> ? readonly [
+    Item,
+    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
+] : never;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data - The input array.
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(data, minimum)
+ * @example
+ *   P.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   P.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArraySetRequired<T, N>;
+declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(minimum)(data)
+ * @example
+ *   P.pipe([], P.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   P.pipe(
+ *     data,
+ *     P.filter(P.hasAtLeast(2)),
+ *     P.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArraySetRequired<T, N>;
+declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
+
+export { hasAtLeast };

package/dist/has-at-least.d.ts

@@ -0,0 +1,68 @@
+import { IsNumericLiteral } from 'type-fest';
+import { I as IterableContainer } from './types-DCY4LHuA.js';
+
+type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration extends ReadonlyArray<unknown> = []> = number extends Min ? never : Iteration['length'] extends Min ? T : T extends readonly [] ? never : T extends [infer Head, ...infer Rest] ? [
+    Head,
+    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
+] : T extends readonly [infer Head, ...infer Rest] ? readonly [
+    Head,
+    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
+] : T extends Array<infer Item> ? [
+    Item,
+    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
+] : T extends ReadonlyArray<infer Item> ? readonly [
+    Item,
+    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
+] : never;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data - The input array.
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(data, minimum)
+ * @example
+ *   P.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   P.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArraySetRequired<T, N>;
+declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(minimum)(data)
+ * @example
+ *   P.pipe([], P.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   P.pipe(
+ *     data,
+ *     P.filter(P.hasAtLeast(2)),
+ *     P.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArraySetRequired<T, N>;
+declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
+
+export { hasAtLeast };

package/dist/has-at-least.js

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

package/dist/has-sub-object.cjs

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

package/dist/has-sub-object.d.cts

@@ -0,0 +1,40 @@
+import { Simplify } from 'type-fest';
+import { B as Branded } from './types-DCY4LHuA.cjs';
+
+declare const HAS_SUB_OBJECT_BRAND: unique symbol;
+type HasSubObjectGuard<T, S> = Simplify<Branded<S & T, typeof HAS_SUB_OBJECT_BRAND>>;
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param data - The object to test.
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(data, subObject)
+ * @example
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true
+ * @dataFirst
+ * @category Guard
+ */
+declare function hasSubObject<T, S extends Partial<T>>(data: T, subObject: S): data is HasSubObjectGuard<T, S>;
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(subObject)(data)
+ * @example
+ *    P.hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true
+ *    P.hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false
+ *    P.hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true
+ * @dataLast
+ * @category Guard
+ */
+declare function hasSubObject<T, S extends Partial<T>>(subObject: S): (data: T) => data is HasSubObjectGuard<T, S>;
+
+export { hasSubObject };

package/dist/has-sub-object.d.ts

@@ -0,0 +1,40 @@
+import { Simplify } from 'type-fest';
+import { B as Branded } from './types-DCY4LHuA.js';
+
+declare const HAS_SUB_OBJECT_BRAND: unique symbol;
+type HasSubObjectGuard<T, S> = Simplify<Branded<S & T, typeof HAS_SUB_OBJECT_BRAND>>;
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param data - The object to test.
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(data, subObject)
+ * @example
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true
+ * @dataFirst
+ * @category Guard
+ */
+declare function hasSubObject<T, S extends Partial<T>>(data: T, subObject: S): data is HasSubObjectGuard<T, S>;
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(subObject)(data)
+ * @example
+ *    P.hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true
+ *    P.hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false
+ *    P.hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true
+ * @dataLast
+ * @category Guard
+ */
+declare function hasSubObject<T, S extends Partial<T>>(subObject: S): (data: T) => data is HasSubObjectGuard<T, S>;
+
+export { hasSubObject };

package/dist/has-sub-object.js

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

package/dist/human-readable-file-size.cjs

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

package/dist/human-readable-file-size.d.cts

@@ -0,0 +1,16 @@
+/**
+ * Returns human readable file size.
+ * @param bytes the file size in bytes
+ * @param base the base (1000 or 1024)
+ * @signature
+ *  humanReadableFileSize(bytes, base)
+ * @example
+ *  import { humanReadableFileSize } from '@vinicunca/perkakas';
+ *
+ *  humanReadableFileSize(1000); // => '1.0 kB'
+ *  humanReadableFileSize(2097152, 1024); // => '2.0 Mib'
+ * @category String
+ */
+declare function humanReadableFileSize(bytes: number, base?: 1000 | 1024): string;
+
+export { humanReadableFileSize };