@bemoje/array 1.0.1 → 1.0.2

package/index.d.ts

@@ -1,56 +1,368 @@
-export * from './lib/arrAverage';
-export * from './lib/arrEachToString';
-export * from './lib/arrFindIndicesOf';
-export * from './lib/arrGetOrDefault';
-export * from './lib/arrHasDuplicates';
-export * from './lib/arrIndicesOf';
-export * from './lib/arrLast';
-export * from './lib/arrMapMutable';
-export * from './lib/arrObjectsToTable';
-export * from './lib/arrObjectsUniqueKeys';
-export * from './lib/arrRemove';
-export * from './lib/arrRemoveDuplicates';
-export * from './lib/arrRemoveMutable';
-export * from './lib/arrShuffle';
-export * from './lib/arrSortNumeric';
-export * from './lib/arrSortedInsertionIndex';
-export * from './lib/arrSum';
-export * from './lib/arrSwap';
-export * from './lib/arrTableAssertRowsSameLength';
-export * from './lib/arrTableEachToString';
-export * from './lib/arrTableIterateAsObjects';
-export * from './lib/arrTableRemoveColumns';
-export * from './lib/arrTableToCsv';
-export * from './lib/arrTableToObjects';
-export * from './lib/arrayToString';
-declare const _default: {
-    arrayToString<T>(array: T[]): string;
-    arrTableToObjects<T>(rows: T[][], headers?: string[], ignoreKeys?: Set<string>): Record<string, T>[];
-    arrTableToCsv<T>(input: T[][], delimiter?: string, replaceLinebreakWith?: string): string;
-    arrTableRemoveColumns(table: string[][], ...removeColumnNames: string[]): string[][];
-    arrTableIterateAsObjects<T>(rows: T[][], headers: string[], ignoreHeaders?: Set<string>): Generator<Record<string, T>, void, unknown>;
-    arrTableEachToString<T>(table: T[][]): string[][];
-    arrTableAssertRowsSameLength<T>(rows: T[][], headers?: string[]): void;
-    arrSwap<T>(input: Array<T>, from: number, to: number): Array<T>;
-    arrSum(array: number[]): number;
-    arrSortedInsertionIndex<T>(array: readonly T[], value: T, comparator: (a: T, b: T) => number): number;
-    arrSortNumeric(input: Array<number | bigint | boolean>): Array<number | bigint | boolean>;
-    arrShuffle<T>(input: Array<T>): Array<T>;
-    arrRemoveMutable<T>(arr: T[], elementToRemove: T): void;
-    arrRemoveDuplicates<T>(array: T[]): T[];
-    arrRemove<T>(arr: T[], elementToRemove: T): T[];
-    arrObjectsUniqueKeys<T>(objects: Record<string, T>[]): string[];
-    arrObjectsToTable<T, E>(objects: Record<string, T | undefined>[], options?: {
-        headers?: string[];
-        emptyCell?: E;
-    }): Array<Array<string | T | E>>;
-    arrMapMutable<T>(input: Array<T>, f: (value: T, index: number, array: T[]) => T): Array<T>;
-    arrLast<T>(array: T[]): T;
-    arrIndicesOf<T>(input: Array<T>, element: T): number[];
-    arrHasDuplicates<T>(arr: T[]): boolean;
-    arrGetOrDefault<V>(array: V[], index: number, factory: (index: number) => V): V;
-    arrFindIndicesOf<T>(input: Array<T>, predicate: (value: T) => boolean): number[];
-    arrEachToString<T>(array: T[]): string[];
-    arrAverage(array: number[]): number;
+/**
+ * Calculates the average of an array of numbers.
+ * @returns The average of all numbers in the array.
+ * @throws an error if the input array is empty.
+ * @param array The array of numbers.
+ * @example ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * arrAverage(numbers);
+ * //=> 3
+ * ```
+ */
+declare function arrAverage(array: number[]): number;
+
+/**
+ * Coerce each element of an array to string.
+ * @template T - The type of elements in the input array.
+ * @returns A new array where each element is the string representation of the corresponding element in the input array.
+ * @param array The array to iterate over.
+ * @example ```ts
+ * const numbers = [1, 2, 3];
+ * arrEachToString(numbers);
+ * //=> ['1', '2', '3']
+ * ```
+ */
+declare function arrEachToString<T>(array: T[]): string[];
+
+/**
+ * Returns an array of indices where the predicate function returns true for the corresponding element in the input array.
+ * @param input - The array to search.
+ * @param predicate - The function to test each element of the array.
+ * @returns An array of indices where the predicate function returns true.
+ */
+declare function arrFindIndicesOf<T>(input: Array<T>, predicate: (value: T) => boolean): number[];
+
+/**
+ * Get array element at index or create it using factory function if it doesn't exist.
+ */
+declare function arrGetOrDefault<V>(array: V[], index: number, factory: (index: number) => V): V;
+
+/**
+ * Checks if an array has any duplicate elements.
+ * @param arr - The array to check for duplicates.
+ * @returns A boolean indicating whether the array has duplicates.
+ * @typeParam T - The type of elements in the array.
+ */
+declare function arrHasDuplicates<T>(arr: T[]): boolean;
+
+/**
+ * Returns all indexes at which an element is found.
+ * @param input The array to search
+ * @template T - The type of elements in the input array.
+ * @returns An array of indices where the specified element can be found.
+ * @param element The element to find
+ * @example ```ts
+ *  const inputArray = [1, 2, 3, 2, 4, 2, 5];
+ *  const elementToFind = 2;
+ *  arrIndicesOf(inputArray, elementToFind);
+ *  //=> [1, 3, 5]
+ *  ```
+ */
+declare function arrIndicesOf<T>(input: Array<T>, element: T): number[];
+
+/**
+ * Returns the last element of an array.
+ * Throws an error if the array is empty.
+ * @template T The type of elements in the array.
+ * @param array The array to get the last element from.
+ * @returns The last element of the array.
+ * @throws If the array is empty.
+ * @example const numbers = [1, 2, 3, 4, 5];
+ * const lastNumber = arrLast(numbers);
+ * //=> 5
+ */
+declare function arrLast<T>(array: T[]): T;
+
+/**
+ * This function takes an array and a callback function as arguments. It applies the callback function to each element of the array, mutating the original array in the process.
+ * @template T The type of elements in the input array.
+ * @param input The array to be mapped over.
+ * @param f The callback function to be applied to each element of the array. This function takes three arguments: the current element, its index, and the original array.
+ * @returns The original array, mutated by the callback function.
+ * @example ```ts
+ * arrMapMutable([1, 2, 3], (value: number) => value * 2);
+ * //=> [2, 4, 6]
+ * ```
+ */
+declare function arrMapMutable<T>(input: Array<T>, f: (value: T, index: number, array: T[]) => T): Array<T>;
+
+/**
+ * Convert an array of objects to a two-dimensional table.
+ * @param objects The array of objects to convert to a table.
+ * @template T - The type of the values in the objects.
+ * @param options.headers An optional array of strings specifying the headers (property names) to use. If not provided, the function will use all unique keys found in the objects.
+ * @param options.emptyCell An optional value to use for empty cells. If not provided, the function will use `undefined`.
+ * @returns A 2D array (table) where each row represents an object and each column represents a property of the object.
+ * @param options The options for converting the objects to a table.
+ * @example ```ts
+ * arrObjectsToTable(
+ *   [
+ *     { a: 1, b: 2 },
+ *     { a: 3, b: 4, c: 5 },
+ *   ],
+ *   { emptyCell:1 },
+ * ) //=> [ [ 'a', 'b', 'c' ], [ 1, 2,1 ], [ 3, 4, 5 ] ]
+ * ```
+ */
+declare function arrObjectsToTable<T, E>(
+  objects: Record<string, T | undefined>[],
+  options?: {
+    headers?: string[];
+    emptyCell?: E;
+  },
+): Array<Array<string | T | E>>;
+
+/**
+ * Returns an array of all unique object keys found in an array of objects.
+ * @template T - The type of values in the input objects.
+ * @returns An array of unique keys present in the input objects.
+ * @param objects The array of objects.
+ * @example ```ts
+ * const objects = [
+ *   { name: 'John', age: 25 },
+ *   { name: 'Jane', gender: 'female' },
+ *   { name: 'Bob', age: 30, gender: 'male' },
+ * ];
+ * arrObjectsUniqueKeys(objects);
+ * //=> ['name', 'age', 'gender']
+ * ```
+ */
+declare function arrObjectsUniqueKeys<T>(objects: Record<string, T>[]): string[];
+
+/**
+ * Remove a given element from a copy of a given array and return the resulting array.
+ */
+declare function arrRemove<T>(arr: T[], elementToRemove: T): T[];
+
+/**
+ * Remove duplicates from an array
+ * @remarks This function uses the JavaScript Set object to remove duplicate values from an array.
+ * @typeparam T - The type of elements in the array.
+ * @returns The new array with duplicates removed.
+ * @param array The array from which to remove duplicates.
+ * @example ```ts
+ * const array = [1, 2, 2, 3, 4, 4, 5];
+ * arrRemoveDuplicates(array);
+ * //=> [1, 2, 3, 4, 5]
+ * ```
+ */
+declare function arrRemoveDuplicates<T>(array: T[]): T[];
+
+/**
+ * Remove elements in-place from an array.
+ */
+declare function arrRemoveMutable<T>(arr: T[], elementToRemove: T): void;
+
+/**
+ * Shuffle items in an array in-place. Guarantees changes.
+ * @remarks This function does not guarantee that the order of the elements will be different after shuffling.
+ * @typeparam T - The type of the elements in the input array.
+ * @returns The same array, but shuffled.
+ * @param input The array to shuffle.
+ * @example ```ts
+ * const input = [1, 2, 3, 4, 5];
+ * arrShuffle(input);
+ * //=> [3, 1, 5, 2, 4]
+ * ```
+ */
+declare function arrShuffle<T>(input: Array<T>): Array<T>;
+
+/**
+ * Sorts an array of numbers, bigints, or booleans in ascending order.
+ * @returns The sorted array.
+ * @remarks This function uses the JavaScript `Array.prototype.sort()` method, which sorts elements in place.
+ * Therefore, the original array will be modified.
+ * @throws If any element in the input array is not a number, bigint, or boolean.
+ * @param input The array to be sorted.
+ * @example ```ts
+ * const input = [5, 2n, true, 10, false];
+ * arrSortNumeric(input);
+ * //=> [false, true, 2n, 5, 10]
+ * ```
+ */
+declare function arrSortNumeric(input: Array<number | bigint | boolean>): Array<number | bigint | boolean>;
+
+/**
+ * Returns an index in the sorted array where the specified value could be inserted while maintaining the sorted order of the array.
+ * If the element is already in the array, returns the index after the last instance of the element.
+ * @param array - The sorted array to search.
+ * @param value - The value to locate in the array.
+ * @param comparator - A function that defines the sort order. If omitted, the array elements are converted to strings, then sorted according to each character's Unicode code point value.
+ * @returns The index at which the value could be inserted into array to maintain the array's sorted order.
+ * @example ```ts
+ * const array = [1, 2, 3, 5, 6];
+ * const value = 4;
+ * const comparator = (a, b) => a - b;
+ * const index = arrSortedLowerBound(array, value, comparator);
+ * console.log(index); // Output: 3
+ * ```
+ */
+declare function arrSortedInsertionIndex<T>(
+  array: readonly T[],
+  value: T,
+  comparator: (a: T, b: T) => number,
+): number;
+
+/**
+ * Calculates the sum of an array of numbers.
+ * @returns The sum of all numbers in the array.
+ * @param array The array of numbers to sum.
+ * @example ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * arrSum(numbers);
+ * //=> 15
+ * ```
+ */
+declare function arrSum(array: number[]): number;
+
+/**
+ * Swaps two elements in an array. This function takes an input array and swaps the elements at the specified indices.
+ * @param to The index of the element to swap to.
+ * @param from The index of the element to swap from.
+ * @template T - The type of elements in the array.
+ * @returns The modified array with swapped elements.
+ * @throws Will throw an error if 'from' or 'to' is not a valid index in the array.
+ * @param input The input array.
+ * @example ```ts
+ * const arr = [1, 2, 3, 4, 5]
+ * arrSwap(arr, 1, 3) //=> [1, 4, 3, 2, 5]
+ * ```
+ */
+declare function arrSwap<T>(input: Array<T>, from: number, to: number): Array<T>;
+
+/**
+ * Asserts that all rows in a 2D array have the same length.
+ * @param - Optional array of headers to compare the row length against.
+ * @throws If any row in the array has a different length than the others.
+ * @param headers Optional. An array of headers. If provided, each row must have the same length as this array.
+ * @typeparam T - The type of elements in the rows.
+ * @param rows The 2D array to check.
+ * @example ```ts
+ *  const rows = [
+ *    [1, 2, 3],
+ *    [4, 5, 6],
+ *    [7, 8, 9],
+ *  ];
+ *  arrTableAssertRowsSameLength(rows);
+ *  //=> undefined
+ *  const rowsWithDifferentLength = [
+ *    [1, 2, 3],
+ *    [4, 5],
+ *    [7, 8, 9],
+ *  ];
+ *  arrTableAssertRowsSameLength(rowsWithDifferentLength);
+ *  //=> Error: Expected 3 columns, got 2
+ *  ```
+ */
+declare function arrTableAssertRowsSameLength<T>(rows: T[][], headers?: string[]): void;
+
+/**
+ * Coerce each value of a 2D array table to string.
+ * @template T - The type of the elements in the input array.
+ * @returns The converted 2D array where each element is a string.
+ * @param table The 2D array to convert.
+ * @example ```ts
+ * const input: number[][] = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+ * arrTableEachToString(input);
+ * //=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']]
+ * ```
+ */
+declare function arrTableEachToString<T>(table: T[][]): string[][];
+
+/**
+ * Generator that iterates through a 2D array table, yielding objects with header keys and row values.
+ */
+declare function arrTableIterateAsObjects<T>(
+  rows: T[][],
+  headers: string[],
+  ignoreHeaders?: Set<string>,
+): Generator<Record<string, T>, void, unknown>;
+
+/**
+ * Removes specified columns from a 2D array table.
+ * @param table - The 2D array (table) from which columns will be removed. The first row of the table is assumed to contain column names.
+ * @param removeColumnNames - The names of the columns to be removed. These should match the entries in the first row of the table.
+ * @returns A new 2D array (table) with the specified columns removed.
+ */
+declare function arrTableRemoveColumns(table: string[][], ...removeColumnNames: string[]): string[][];
+
+/**
+ * Converts a 2D array to a CSV string.
+ * @param input The input 2D array.
+ * @remarks This function is useful for exporting data to CSV format.
+ * @param replaceLinebreakWith The character used to replace line breaks in the CSV string. Defaults to '|'.
+ * @typeparam T - The type of the elements in the input array.
+ * @returns The CSV string representation of the input array.
+ * @param delimiter The delimiter to use for separating values in the CSV string.
+ * @example ```ts
+ * const input = [
+ *   ['Name', 'Age', 'Country'],
+ *   ['John', '25', 'USA'],
+ *   ['Alice', '30', 'Canada'],
+ *   ['Bob', '35', 'UK'],
+ * ];
+ * arrTableToCsv(input);
+ * //=> "Name;Age;Country\nJohn;25;USA\nAlice;30;Canada\nBob;35;UK"
+ * ```
+ */
+declare function arrTableToCsv<T>(input: T[][], delimiter?: string, replaceLinebreakWith?: string): string;
+
+/**
+ * Converts a 2D array representing a table into an array of objects.
+ * @param rows The 2D array representing the table.
+ * @template T - The type of the elements in the rows.
+ * @param headers The headers to use as keys for the objects. If not provided, the first row of the table is used as headers.
+ * @returns An array of objects, where each object represents a row in the table.
+ * @throws Throws an error if the headers are not provided and the table is empty or only contains one row.
+ * @param headers Optional array of headers for the table.
+ * @example ```ts
+ * const table = [
+ *   ['Name', 'Age', 'Country'],
+ *   ['John', 25, 'USA'],
+ *   ['Jane', 30, 'Canada'],
+ * ];
+ * const headers = ['Name', 'Age', 'Country'];
+ * arrTableToObjects(table, headers) //=> [
+ * //   { Name: 'John', Age: 25, Country: 'USA' },
+ * //   { Name: 'Jane', Age: 30, Country: 'Canada' },
+ * // ]
+ * ```
+ */
+declare function arrTableToObjects<T>(
+  rows: T[][],
+  headers?: string[],
+  ignoreKeys?: Set<string>,
+): Record<string, T>[];
+
+/**
+ * Short and condensed string representation of an array, easy to read for error outputs or similar.
+ */
+declare function arrayToString<T>(array: T[]): string;
+
+export {
+  arrAverage,
+  arrEachToString,
+  arrFindIndicesOf,
+  arrGetOrDefault,
+  arrHasDuplicates,
+  arrIndicesOf,
+  arrLast,
+  arrMapMutable,
+  arrObjectsToTable,
+  arrObjectsUniqueKeys,
+  arrRemove,
+  arrRemoveDuplicates,
+  arrRemoveMutable,
+  arrShuffle,
+  arrSortNumeric,
+  arrSortedInsertionIndex,
+  arrSum,
+  arrSwap,
+  arrTableAssertRowsSameLength,
+  arrTableEachToString,
+  arrTableIterateAsObjects,
+  arrTableRemoveColumns,
+  arrTableToCsv,
+  arrTableToObjects,
+  arrayToString,
 };
-export default _default;

package/index.mjs

@@ -1,50 +1,34 @@
 var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __name = (target, value) => {
+  return __defProp(target, 'name', { value, configurable: true });
 };
 
-// src/lib/arrAverage.ts
-var arrAverage_exports = {};
-__export(arrAverage_exports, {
-  arrAverage: () => arrAverage
-});
-
 // src/lib/arrSum.ts
-var arrSum_exports = {};
-__export(arrSum_exports, {
-  arrSum: () => arrSum
-});
 function arrSum(array) {
   return array.reduce((acc, cur) => {
     return acc + cur;
   }, 0);
 }
+__name(arrSum, 'arrSum');
 
 // src/lib/arrAverage.ts
 function arrAverage(array) {
   if (!array.length) {
-    throw new Error("Cannot take an average of zero values.");
+    throw new Error('Cannot take an average of zero values.');
   }
   return arrSum(array) / array.length;
 }
+__name(arrAverage, 'arrAverage');
 
 // src/lib/arrEachToString.ts
-var arrEachToString_exports = {};
-__export(arrEachToString_exports, {
-  arrEachToString: () => arrEachToString
-});
 function arrEachToString(array) {
   return array.map((element) => {
     return `${element}`;
   });
 }
+__name(arrEachToString, 'arrEachToString');
 
 // src/lib/arrFindIndicesOf.ts
-var arrFindIndicesOf_exports = {};
-__export(arrFindIndicesOf_exports, {
-  arrFindIndicesOf: () => arrFindIndicesOf
-});
 function arrFindIndicesOf(input, predicate) {
   const result = [];
   for (let i = 0; i < input.length; i++) {
@@ -54,25 +38,19 @@ function arrFindIndicesOf(input, predicate) {
   }
   return result;
 }
+__name(arrFindIndicesOf, 'arrFindIndicesOf');
 
 // src/lib/arrGetOrDefault.ts
-var arrGetOrDefault_exports = {};
-__export(arrGetOrDefault_exports, {
-  arrGetOrDefault: () => arrGetOrDefault
-});
 function arrGetOrDefault(array, index, factory) {
   const value = array[index];
   if (value !== void 0 || Object.hasOwn(array, index)) {
     return value;
   }
-  return array[index] = factory(index);
+  return (array[index] = factory(index));
 }
+__name(arrGetOrDefault, 'arrGetOrDefault');
 
 // src/lib/arrHasDuplicates.ts
-var arrHasDuplicates_exports = {};
-__export(arrHasDuplicates_exports, {
-  arrHasDuplicates: () => arrHasDuplicates
-});
 function arrHasDuplicates(arr) {
   const seen = /* @__PURE__ */ new Set();
   for (const e of arr) {
@@ -83,12 +61,9 @@ function arrHasDuplicates(arr) {
   }
   return false;
 }
+__name(arrHasDuplicates, 'arrHasDuplicates');
 
 // src/lib/arrIndicesOf.ts
-var arrIndicesOf_exports = {};
-__export(arrIndicesOf_exports, {
-  arrIndicesOf: () => arrIndicesOf
-});
 function arrIndicesOf(input, element) {
   const result = [];
   for (let i = 0; i < input.length; i++) {
@@ -98,42 +73,27 @@ function arrIndicesOf(input, element) {
   }
   return result;
 }
+__name(arrIndicesOf, 'arrIndicesOf');
 
 // src/lib/arrLast.ts
-var arrLast_exports = {};
-__export(arrLast_exports, {
-  arrLast: () => arrLast
-});
 function arrLast(array) {
   if (!array.length) {
-    throw new Error("Cannot get last element of empty array.");
+    throw new Error('Cannot get last element of empty array.');
   }
   return array[array.length - 1];
 }
+__name(arrLast, 'arrLast');
 
 // src/lib/arrMapMutable.ts
-var arrMapMutable_exports = {};
-__export(arrMapMutable_exports, {
-  arrMapMutable: () => arrMapMutable
-});
 function arrMapMutable(input, f) {
   for (let i = 0; i < input.length; i++) {
     input[i] = f(input[i], i, input);
   }
   return input;
 }
-
-// src/lib/arrObjectsToTable.ts
-var arrObjectsToTable_exports = {};
-__export(arrObjectsToTable_exports, {
-  arrObjectsToTable: () => arrObjectsToTable
-});
+__name(arrMapMutable, 'arrMapMutable');
 
 // src/lib/arrObjectsUniqueKeys.ts
-var arrObjectsUniqueKeys_exports = {};
-__export(arrObjectsUniqueKeys_exports, {
-  arrObjectsUniqueKeys: () => arrObjectsUniqueKeys
-});
 function arrObjectsUniqueKeys(objects) {
   const keys = /* @__PURE__ */ new Set();
   for (const o of objects) {
@@ -143,6 +103,7 @@ function arrObjectsUniqueKeys(objects) {
   }
   return Array.from(keys);
 }
+__name(arrObjectsUniqueKeys, 'arrObjectsUniqueKeys');
 
 // src/lib/arrObjectsToTable.ts
 function arrObjectsToTable(objects, options = {}) {
@@ -157,32 +118,23 @@ function arrObjectsToTable(objects, options = {}) {
   }
   return table;
 }
+__name(arrObjectsToTable, 'arrObjectsToTable');
 
 // src/lib/arrRemove.ts
-var arrRemove_exports = {};
-__export(arrRemove_exports, {
-  arrRemove: () => arrRemove
-});
 function arrRemove(arr, elementToRemove) {
   return arr.filter((element) => {
     return element !== elementToRemove;
   });
 }
+__name(arrRemove, 'arrRemove');
 
 // src/lib/arrRemoveDuplicates.ts
-var arrRemoveDuplicates_exports = {};
-__export(arrRemoveDuplicates_exports, {
-  arrRemoveDuplicates: () => arrRemoveDuplicates
-});
 function arrRemoveDuplicates(array) {
   return Array.from(new Set(array));
 }
+__name(arrRemoveDuplicates, 'arrRemoveDuplicates');
 
 // src/lib/arrRemoveMutable.ts
-var arrRemoveMutable_exports = {};
-__export(arrRemoveMutable_exports, {
-  arrRemoveMutable: () => arrRemoveMutable
-});
 function arrRemoveMutable(arr, elementToRemove) {
   let index = arr.indexOf(elementToRemove);
   while (index !== -1) {
@@ -190,26 +142,17 @@ function arrRemoveMutable(arr, elementToRemove) {
     index = arr.indexOf(elementToRemove);
   }
 }
-
-// src/lib/arrShuffle.ts
-var arrShuffle_exports = {};
-__export(arrShuffle_exports, {
-  arrShuffle: () => arrShuffle
-});
+__name(arrRemoveMutable, 'arrRemoveMutable');
 
 // src/lib/arrSwap.ts
-var arrSwap_exports = {};
-__export(arrSwap_exports, {
-  arrSwap: () => arrSwap
-});
 function arrSwap(input, from, to) {
   if (from === to) {
     return input;
   }
-  ;
   [input[from], input[to]] = [input[to], input[from]];
   return input;
 }
+__name(arrSwap, 'arrSwap');
 
 // src/lib/arrShuffle.ts
 function arrShuffle(input) {
@@ -223,16 +166,13 @@ function arrShuffle(input) {
       const newIndex = Math.floor(Math.random() * input.length);
       arrSwap(input, i, newIndex);
     }
-    equal = input.join(",") === original.join(",");
+    equal = input.join(',') === original.join(',');
   }
   return input;
 }
+__name(arrShuffle, 'arrShuffle');
 
 // src/lib/arrSortNumeric.ts
-var arrSortNumeric_exports = {};
-__export(arrSortNumeric_exports, {
-  arrSortNumeric: () => arrSortNumeric
-});
 function arrSortNumeric(input) {
   return input.sort((a, b) => {
     if (a < b) {
@@ -244,12 +184,9 @@ function arrSortNumeric(input) {
     return 0;
   });
 }
+__name(arrSortNumeric, 'arrSortNumeric');
 
 // src/lib/arrSortedInsertionIndex.ts
-var arrSortedInsertionIndex_exports = {};
-__export(arrSortedInsertionIndex_exports, {
-  arrSortedInsertionIndex: () => arrSortedInsertionIndex
-});
 function arrSortedInsertionIndex(array, value, comparator) {
   let first = 0;
   let count = array.length;
@@ -266,12 +203,9 @@ function arrSortedInsertionIndex(array, value, comparator) {
   }
   return first;
 }
+__name(arrSortedInsertionIndex, 'arrSortedInsertionIndex');
 
 // src/lib/arrTableAssertRowsSameLength.ts
-var arrTableAssertRowsSameLength_exports = {};
-__export(arrTableAssertRowsSameLength_exports, {
-  arrTableAssertRowsSameLength: () => arrTableAssertRowsSameLength
-});
 function arrTableAssertRowsSameLength(rows, headers) {
   const numHeaders = (headers || rows[0]).length;
   for (const row of rows) {
@@ -280,24 +214,18 @@ function arrTableAssertRowsSameLength(rows, headers) {
     }
   }
 }
+__name(arrTableAssertRowsSameLength, 'arrTableAssertRowsSameLength');
 
 // src/lib/arrTableEachToString.ts
-var arrTableEachToString_exports = {};
-__export(arrTableEachToString_exports, {
-  arrTableEachToString: () => arrTableEachToString
-});
 function arrTableEachToString(table) {
   return table.map(arrEachToString);
 }
+__name(arrTableEachToString, 'arrTableEachToString');
 
 // src/lib/arrTableIterateAsObjects.ts
-var arrTableIterateAsObjects_exports = {};
-__export(arrTableIterateAsObjects_exports, {
-  arrTableIterateAsObjects: () => arrTableIterateAsObjects
-});
 function* arrTableIterateAsObjects(rows, headers, ignoreHeaders = /* @__PURE__ */ new Set()) {
   if (!headers.length) {
-    throw new Error("No headers provided");
+    throw new Error('No headers provided');
   }
   ignoreHeaders.forEach((h) => {
     if (!headers.includes(h)) {
@@ -305,7 +233,7 @@ function* arrTableIterateAsObjects(rows, headers, ignoreHeaders = /* @__PURE__ *
     }
   });
   if (new Set(headers).size === ignoreHeaders.size) {
-    throw new Error("All headers are ignored");
+    throw new Error('All headers are ignored');
   }
   for (let r = 0; r < rows.length; r++) {
     if (rows[r].length !== headers.length) {
@@ -321,20 +249,19 @@ function* arrTableIterateAsObjects(rows, headers, ignoreHeaders = /* @__PURE__ *
     yield o;
   }
 }
+__name(arrTableIterateAsObjects, 'arrTableIterateAsObjects');
 
 // src/lib/arrTableRemoveColumns.ts
-var arrTableRemoveColumns_exports = {};
-__export(arrTableRemoveColumns_exports, {
-  arrTableRemoveColumns: () => arrTableRemoveColumns
-});
 function arrTableRemoveColumns(table, ...removeColumnNames) {
   if (!removeColumnNames.length || !table.length) {
     return table;
   }
   const set = new Set(
-    removeColumnNames.map((col) => {
-      return arrIndicesOf(table[0], col);
-    }).flat()
+    removeColumnNames
+      .map((col) => {
+        return arrIndicesOf(table[0], col);
+      })
+      .flat(),
   );
   return table.map((row) => {
     return row.filter((_, i) => {
@@ -342,25 +269,23 @@ function arrTableRemoveColumns(table, ...removeColumnNames) {
     });
   });
 }
+__name(arrTableRemoveColumns, 'arrTableRemoveColumns');
 
 // src/lib/arrTableToCsv.ts
-var arrTableToCsv_exports = {};
-__export(arrTableToCsv_exports, {
-  arrTableToCsv: () => arrTableToCsv
-});
-function arrTableToCsv(input, delimiter = ";", replaceLinebreakWith = "<br>") {
-  return input.map((row) => {
-    return row.map((item) => {
-      return String(item).replace(new RegExp(";", "g"), "").replace(/\r*\n/g, replaceLinebreakWith);
-    }).join(delimiter);
-  }).join("\n");
+function arrTableToCsv(input, delimiter = ';', replaceLinebreakWith = '<br>') {
+  return input
+    .map((row) => {
+      return row
+        .map((item) => {
+          return String(item).replace(new RegExp(';', 'g'), '').replace(/\r*\n/g, replaceLinebreakWith);
+        })
+        .join(delimiter);
+    })
+    .join('\n');
 }
+__name(arrTableToCsv, 'arrTableToCsv');
 
 // src/lib/arrTableToObjects.ts
-var arrTableToObjects_exports = {};
-__export(arrTableToObjects_exports, {
-  arrTableToObjects: () => arrTableToObjects
-});
 function arrTableToObjects(rows, headers, ignoreKeys) {
   if (headers) {
     if (!rows.length) {
@@ -371,7 +296,7 @@ function arrTableToObjects(rows, headers, ignoreKeys) {
       return [];
     }
     headers = rows[0].map((header) => {
-      return header === null || header === void 0 ? "" : String(header);
+      return header === null || header === void 0 ? '' : String(header);
     });
     rows = rows.slice(1);
   }
@@ -388,47 +313,18 @@ function arrTableToObjects(rows, headers, ignoreKeys) {
     return o;
   });
 }
+__name(arrTableToObjects, 'arrTableToObjects');
 
 // src/lib/arrayToString.ts
-var arrayToString_exports = {};
-__export(arrayToString_exports, {
-  arrayToString: () => arrayToString
-});
 function arrayToString(array) {
-  return `[${array.map((item) => {
-    return item == null ? String(item) : Array.isArray(item) ? arrayToString(item) : item.toString();
-  }).join(",")}]`;
+  return `[${array
+    .map((item) => {
+      return item == null ? String(item) : Array.isArray(item) ? arrayToString(item) : item.toString();
+    })
+    .join(',')}]`;
 }
+__name(arrayToString, 'arrayToString');
 
-// src/index.ts
-var src_default = {
-  ...arrAverage_exports,
-  //
-  ...arrEachToString_exports,
-  ...arrFindIndicesOf_exports,
-  ...arrGetOrDefault_exports,
-  ...arrHasDuplicates_exports,
-  ...arrIndicesOf_exports,
-  ...arrLast_exports,
-  ...arrMapMutable_exports,
-  ...arrObjectsToTable_exports,
-  ...arrObjectsUniqueKeys_exports,
-  ...arrRemove_exports,
-  ...arrRemoveDuplicates_exports,
-  ...arrRemoveMutable_exports,
-  ...arrShuffle_exports,
-  ...arrSortNumeric_exports,
-  ...arrSortedInsertionIndex_exports,
-  ...arrSum_exports,
-  ...arrSwap_exports,
-  ...arrTableAssertRowsSameLength_exports,
-  ...arrTableEachToString_exports,
-  ...arrTableIterateAsObjects_exports,
-  ...arrTableRemoveColumns_exports,
-  ...arrTableToCsv_exports,
-  ...arrTableToObjects_exports,
-  ...arrayToString_exports
-};
 export {
   arrAverage,
   arrEachToString,
@@ -455,5 +351,4 @@ export {
   arrTableToCsv,
   arrTableToObjects,
   arrayToString,
-  src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bemoje/array",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Array utils",
   "type": "module",
   "sideEffects": false,

package/lib/arrAverage.d.ts

@@ -1,12 +0,0 @@
-/**
- * Calculates the average of an array of numbers.
- * @returns The average of all numbers in the array.
- * @throws an error if the input array is empty.
- * @param array The array of numbers.
- * @example ```ts
- * const numbers = [1, 2, 3, 4, 5];
- * arrAverage(numbers);
- * //=> 3
- * ```
- */
-export declare function arrAverage(array: number[]): number;

package/lib/arrEachToString.d.ts

@@ -1,12 +0,0 @@
-/**
- * Coerce each element of an array to string.
- * @template T - The type of elements in the input array.
- * @returns A new array where each element is the string representation of the corresponding element in the input array.
- * @param array The array to iterate over.
- * @example ```ts
- * const numbers = [1, 2, 3];
- * arrEachToString(numbers);
- * //=> ['1', '2', '3']
- * ```
- */
-export declare function arrEachToString<T>(array: T[]): string[];

package/lib/arrFindIndicesOf.d.ts

@@ -1,7 +0,0 @@
-/**
- * Returns an array of indices where the predicate function returns true for the corresponding element in the input array.
- * @param input - The array to search.
- * @param predicate - The function to test each element of the array.
- * @returns An array of indices where the predicate function returns true.
- */
-export declare function arrFindIndicesOf<T>(input: Array<T>, predicate: (value: T) => boolean): number[];

package/lib/arrGetOrDefault.d.ts

@@ -1,4 +0,0 @@
-/**
- * Get array element at index or create it using factory function if it doesn't exist.
- */
-export declare function arrGetOrDefault<V>(array: V[], index: number, factory: (index: number) => V): V;

package/lib/arrHasDuplicates.d.ts

@@ -1,7 +0,0 @@
-/**
- * Checks if an array has any duplicate elements.
- * @param arr - The array to check for duplicates.
- * @returns A boolean indicating whether the array has duplicates.
- * @typeParam T - The type of elements in the array.
- */
-export declare function arrHasDuplicates<T>(arr: T[]): boolean;

package/lib/arrIndicesOf.d.ts

@@ -1,14 +0,0 @@
-/**
- * Returns all indexes at which an element is found.
- * @param input The array to search
- * @template T - The type of elements in the input array.
- * @returns An array of indices where the specified element can be found.
- * @param element The element to find
- * @example ```ts
- *  const inputArray = [1, 2, 3, 2, 4, 2, 5];
- *  const elementToFind = 2;
- *  arrIndicesOf(inputArray, elementToFind);
- *  //=> [1, 3, 5]
- *  ```
- */
-export declare function arrIndicesOf<T>(input: Array<T>, element: T): number[];

package/lib/arrLast.d.ts

@@ -1,12 +0,0 @@
-/**
- * Returns the last element of an array.
- * Throws an error if the array is empty.
- * @template T The type of elements in the array.
- * @param array The array to get the last element from.
- * @returns The last element of the array.
- * @throws If the array is empty.
- * @example const numbers = [1, 2, 3, 4, 5];
- * const lastNumber = arrLast(numbers);
- * //=> 5
- */
-export declare function arrLast<T>(array: T[]): T;

package/lib/arrMapMutable.d.ts

@@ -1,12 +0,0 @@
-/**
- * This function takes an array and a callback function as arguments. It applies the callback function to each element of the array, mutating the original array in the process.
- * @template T The type of elements in the input array.
- * @param input The array to be mapped over.
- * @param f The callback function to be applied to each element of the array. This function takes three arguments: the current element, its index, and the original array.
- * @returns The original array, mutated by the callback function.
- * @example ```ts
- * arrMapMutable([1, 2, 3], (value: number) => value * 2);
- * //=> [2, 4, 6]
- * ```
- */
-export declare function arrMapMutable<T>(input: Array<T>, f: (value: T, index: number, array: T[]) => T): Array<T>;

package/lib/arrObjectsToTable.d.ts

@@ -1,22 +0,0 @@
-/**
- * Convert an array of objects to a two-dimensional table.
- * @param objects The array of objects to convert to a table.
- * @template T - The type of the values in the objects.
- * @param options.headers An optional array of strings specifying the headers (property names) to use. If not provided, the function will use all unique keys found in the objects.
- * @param options.emptyCell An optional value to use for empty cells. If not provided, the function will use `undefined`.
- * @returns A 2D array (table) where each row represents an object and each column represents a property of the object.
- * @param options The options for converting the objects to a table.
- * @example ```ts
- * arrObjectsToTable(
- *   [
- *     { a: 1, b: 2 },
- *     { a: 3, b: 4, c: 5 },
- *   ],
- *   { emptyCell:1 },
- * ) //=> [ [ 'a', 'b', 'c' ], [ 1, 2,1 ], [ 3, 4, 5 ] ]
- * ```
- */
-export declare function arrObjectsToTable<T, E>(objects: Record<string, T | undefined>[], options?: {
-    headers?: string[];
-    emptyCell?: E;
-}): Array<Array<string | T | E>>;

package/lib/arrObjectsUniqueKeys.d.ts

@@ -1,16 +0,0 @@
-/**
- * Returns an array of all unique object keys found in an array of objects.
- * @template T - The type of values in the input objects.
- * @returns An array of unique keys present in the input objects.
- * @param objects The array of objects.
- * @example ```ts
- * const objects = [
- *   { name: 'John', age: 25 },
- *   { name: 'Jane', gender: 'female' },
- *   { name: 'Bob', age: 30, gender: 'male' },
- * ];
- * arrObjectsUniqueKeys(objects);
- * //=> ['name', 'age', 'gender']
- * ```
- */
-export declare function arrObjectsUniqueKeys<T>(objects: Record<string, T>[]): string[];

package/lib/arrRemove.d.ts

@@ -1,4 +0,0 @@
-/**
- * Remove a given element from a copy of a given array and return the resulting array.
- */
-export declare function arrRemove<T>(arr: T[], elementToRemove: T): T[];

package/lib/arrRemoveDuplicates.d.ts

@@ -1,13 +0,0 @@
-/**
- * Remove duplicates from an array
- * @remarks This function uses the JavaScript Set object to remove duplicate values from an array.
- * @typeparam T - The type of elements in the array.
- * @returns The new array with duplicates removed.
- * @param array The array from which to remove duplicates.
- * @example ```ts
- * const array = [1, 2, 2, 3, 4, 4, 5];
- * arrRemoveDuplicates(array);
- * //=> [1, 2, 3, 4, 5]
- * ```
- */
-export declare function arrRemoveDuplicates<T>(array: T[]): T[];

package/lib/arrRemoveMutable.d.ts

@@ -1,4 +0,0 @@
-/**
- * Remove elements in-place from an array.
- */
-export declare function arrRemoveMutable<T>(arr: T[], elementToRemove: T): void;

package/lib/arrShuffle.d.ts

@@ -1,13 +0,0 @@
-/**
- * Shuffle items in an array in-place. Guarantees changes.
- * @remarks This function does not guarantee that the order of the elements will be different after shuffling.
- * @typeparam T - The type of the elements in the input array.
- * @returns The same array, but shuffled.
- * @param input The array to shuffle.
- * @example ```ts
- * const input = [1, 2, 3, 4, 5];
- * arrShuffle(input);
- * //=> [3, 1, 5, 2, 4]
- * ```
- */
-export declare function arrShuffle<T>(input: Array<T>): Array<T>;

package/lib/arrSortNumeric.d.ts

@@ -1,14 +0,0 @@
-/**
- * Sorts an array of numbers, bigints, or booleans in ascending order.
- * @returns The sorted array.
- * @remarks This function uses the JavaScript `Array.prototype.sort()` method, which sorts elements in place.
- * Therefore, the original array will be modified.
- * @throws If any element in the input array is not a number, bigint, or boolean.
- * @param input The array to be sorted.
- * @example ```ts
- * const input = [5, 2n, true, 10, false];
- * arrSortNumeric(input);
- * //=> [false, true, 2n, 5, 10]
- * ```
- */
-export declare function arrSortNumeric(input: Array<number | bigint | boolean>): Array<number | bigint | boolean>;

package/lib/arrSortedInsertionIndex.d.ts

@@ -1,16 +0,0 @@
-/**
- * Returns an index in the sorted array where the specified value could be inserted while maintaining the sorted order of the array.
- * If the element is already in the array, returns the index after the last instance of the element.
- * @param array - The sorted array to search.
- * @param value - The value to locate in the array.
- * @param comparator - A function that defines the sort order. If omitted, the array elements are converted to strings, then sorted according to each character's Unicode code point value.
- * @returns The index at which the value could be inserted into array to maintain the array's sorted order.
- * @example ```ts
- * const array = [1, 2, 3, 5, 6];
- * const value = 4;
- * const comparator = (a, b) => a - b;
- * const index = arrSortedLowerBound(array, value, comparator);
- * console.log(index); // Output: 3
- * ```
- */
-export declare function arrSortedInsertionIndex<T>(array: readonly T[], value: T, comparator: (a: T, b: T) => number): number;

package/lib/arrSum.d.ts

@@ -1,11 +0,0 @@
-/**
- * Calculates the sum of an array of numbers.
- * @returns The sum of all numbers in the array.
- * @param array The array of numbers to sum.
- * @example ```ts
- * const numbers = [1, 2, 3, 4, 5];
- * arrSum(numbers);
- * //=> 15
- * ```
- */
-export declare function arrSum(array: number[]): number;

package/lib/arrSwap.d.ts

@@ -1,14 +0,0 @@
-/**
- * Swaps two elements in an array. This function takes an input array and swaps the elements at the specified indices.
- * @param to The index of the element to swap to.
- * @param from The index of the element to swap from.
- * @template T - The type of elements in the array.
- * @returns The modified array with swapped elements.
- * @throws Will throw an error if 'from' or 'to' is not a valid index in the array.
- * @param input The input array.
- * @example ```ts
- * const arr = [1, 2, 3, 4, 5]
- * arrSwap(arr, 1, 3) //=> [1, 4, 3, 2, 5]
- * ```
- */
-export declare function arrSwap<T>(input: Array<T>, from: number, to: number): Array<T>;

package/lib/arrTableAssertRowsSameLength.d.ts

@@ -1,25 +0,0 @@
-/**
- * Asserts that all rows in a 2D array have the same length.
- * @param - Optional array of headers to compare the row length against.
- * @throws If any row in the array has a different length than the others.
- * @param headers Optional. An array of headers. If provided, each row must have the same length as this array.
- * @typeparam T - The type of elements in the rows.
- * @param rows The 2D array to check.
- * @example ```ts
- *  const rows = [
- *    [1, 2, 3],
- *    [4, 5, 6],
- *    [7, 8, 9],
- *  ];
- *  arrTableAssertRowsSameLength(rows);
- *  //=> undefined
- *  const rowsWithDifferentLength = [
- *    [1, 2, 3],
- *    [4, 5],
- *    [7, 8, 9],
- *  ];
- *  arrTableAssertRowsSameLength(rowsWithDifferentLength);
- *  //=> Error: Expected 3 columns, got 2
- *  ```
- */
-export declare function arrTableAssertRowsSameLength<T>(rows: T[][], headers?: string[]): void;

package/lib/arrTableEachToString.d.ts

@@ -1,12 +0,0 @@
-/**
- * Coerce each value of a 2D array table to string.
- * @template T - The type of the elements in the input array.
- * @returns The converted 2D array where each element is a string.
- * @param table The 2D array to convert.
- * @example ```ts
- * const input: number[][] = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
- * arrTableEachToString(input);
- * //=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']]
- * ```
- */
-export declare function arrTableEachToString<T>(table: T[][]): string[][];

package/lib/arrTableIterateAsObjects.d.ts

@@ -1,4 +0,0 @@
-/**
- * Generator that iterates through a 2D array table, yielding objects with header keys and row values.
- */
-export declare function arrTableIterateAsObjects<T>(rows: T[][], headers: string[], ignoreHeaders?: Set<string>): Generator<Record<string, T>, void, unknown>;

package/lib/arrTableRemoveColumns.d.ts

@@ -1,7 +0,0 @@
-/**
- * Removes specified columns from a 2D array table.
- * @param table - The 2D array (table) from which columns will be removed. The first row of the table is assumed to contain column names.
- * @param removeColumnNames - The names of the columns to be removed. These should match the entries in the first row of the table.
- * @returns A new 2D array (table) with the specified columns removed.
- */
-export declare function arrTableRemoveColumns(table: string[][], ...removeColumnNames: string[]): string[][];

package/lib/arrTableToCsv.d.ts

@@ -1,20 +0,0 @@
-/**
- * Converts a 2D array to a CSV string.
- * @param input The input 2D array.
- * @remarks This function is useful for exporting data to CSV format.
- * @param replaceLinebreakWith The character used to replace line breaks in the CSV string. Defaults to '|'.
- * @typeparam T - The type of the elements in the input array.
- * @returns The CSV string representation of the input array.
- * @param delimiter The delimiter to use for separating values in the CSV string.
- * @example ```ts
- * const input = [
- *   ['Name', 'Age', 'Country'],
- *   ['John', '25', 'USA'],
- *   ['Alice', '30', 'Canada'],
- *   ['Bob', '35', 'UK'],
- * ];
- * arrTableToCsv(input);
- * //=> "Name;Age;Country\nJohn;25;USA\nAlice;30;Canada\nBob;35;UK"
- * ```
- */
-export declare function arrTableToCsv<T>(input: T[][], delimiter?: string, replaceLinebreakWith?: string): string;

package/lib/arrTableToObjects.d.ts

@@ -1,22 +0,0 @@
-/**
- * Converts a 2D array representing a table into an array of objects.
- * @param rows The 2D array representing the table.
- * @template T - The type of the elements in the rows.
- * @param headers The headers to use as keys for the objects. If not provided, the first row of the table is used as headers.
- * @returns An array of objects, where each object represents a row in the table.
- * @throws Throws an error if the headers are not provided and the table is empty or only contains one row.
- * @param headers Optional array of headers for the table.
- * @example ```ts
- * const table = [
- *   ['Name', 'Age', 'Country'],
- *   ['John', 25, 'USA'],
- *   ['Jane', 30, 'Canada'],
- * ];
- * const headers = ['Name', 'Age', 'Country'];
- * arrTableToObjects(table, headers) //=> [
- * //   { Name: 'John', Age: 25, Country: 'USA' },
- * //   { Name: 'Jane', Age: 30, Country: 'Canada' },
- * // ]
- * ```
- */
-export declare function arrTableToObjects<T>(rows: T[][], headers?: string[], ignoreKeys?: Set<string>): Record<string, T>[];

package/lib/arrayToString.d.ts

@@ -1,4 +0,0 @@
-/**
- * Short and condensed string representation of an array, easy to read for error outputs or similar.
- */
-export declare function arrayToString<T>(array: T[]): string;