@bemoje/array 0.3.3 → 1.0.1

package/index.d.ts

@@ -0,0 +1,56 @@
+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;
+};
+export default _default;

package/index.mjs

@@ -0,0 +1,459 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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);
+}
+
+// src/lib/arrAverage.ts
+function arrAverage(array) {
+  if (!array.length) {
+    throw new Error("Cannot take an average of zero values.");
+  }
+  return arrSum(array) / array.length;
+}
+
+// src/lib/arrEachToString.ts
+var arrEachToString_exports = {};
+__export(arrEachToString_exports, {
+  arrEachToString: () => arrEachToString
+});
+function arrEachToString(array) {
+  return array.map((element) => {
+    return `${element}`;
+  });
+}
+
+// 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++) {
+    if (predicate(input[i])) {
+      result.push(i);
+    }
+  }
+  return result;
+}
+
+// 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);
+}
+
+// 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) {
+    if (seen.has(e)) {
+      return true;
+    }
+    seen.add(e);
+  }
+  return false;
+}
+
+// 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++) {
+    if (element === input[i]) {
+      result.push(i);
+    }
+  }
+  return result;
+}
+
+// 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.");
+  }
+  return array[array.length - 1];
+}
+
+// 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
+});
+
+// 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) {
+    for (const key of Object.keys(o)) {
+      keys.add(key);
+    }
+  }
+  return Array.from(keys);
+}
+
+// src/lib/arrObjectsToTable.ts
+function arrObjectsToTable(objects, options = {}) {
+  const headers = options?.headers?.slice() || arrObjectsUniqueKeys(objects);
+  const table = [headers];
+  for (const o of objects) {
+    const row = headers.map((header) => {
+      const value = o[header];
+      return value !== void 0 ? value : options.emptyCell;
+    });
+    table.push(row);
+  }
+  return table;
+}
+
+// src/lib/arrRemove.ts
+var arrRemove_exports = {};
+__export(arrRemove_exports, {
+  arrRemove: () => arrRemove
+});
+function arrRemove(arr, elementToRemove) {
+  return arr.filter((element) => {
+    return element !== elementToRemove;
+  });
+}
+
+// src/lib/arrRemoveDuplicates.ts
+var arrRemoveDuplicates_exports = {};
+__export(arrRemoveDuplicates_exports, {
+  arrRemoveDuplicates: () => arrRemoveDuplicates
+});
+function arrRemoveDuplicates(array) {
+  return Array.from(new Set(array));
+}
+
+// src/lib/arrRemoveMutable.ts
+var arrRemoveMutable_exports = {};
+__export(arrRemoveMutable_exports, {
+  arrRemoveMutable: () => arrRemoveMutable
+});
+function arrRemoveMutable(arr, elementToRemove) {
+  let index = arr.indexOf(elementToRemove);
+  while (index !== -1) {
+    arr.splice(index, 1);
+    index = arr.indexOf(elementToRemove);
+  }
+}
+
+// src/lib/arrShuffle.ts
+var arrShuffle_exports = {};
+__export(arrShuffle_exports, {
+  arrShuffle: () => arrShuffle
+});
+
+// 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;
+}
+
+// src/lib/arrShuffle.ts
+function arrShuffle(input) {
+  if (input.length <= 1) {
+    return input;
+  }
+  const original = input.slice();
+  let equal = true;
+  while (equal) {
+    for (let i = 0; i < input.length; i++) {
+      const newIndex = Math.floor(Math.random() * input.length);
+      arrSwap(input, i, newIndex);
+    }
+    equal = input.join(",") === original.join(",");
+  }
+  return input;
+}
+
+// src/lib/arrSortNumeric.ts
+var arrSortNumeric_exports = {};
+__export(arrSortNumeric_exports, {
+  arrSortNumeric: () => arrSortNumeric
+});
+function arrSortNumeric(input) {
+  return input.sort((a, b) => {
+    if (a < b) {
+      return -1;
+    }
+    if (a > b) {
+      return 1;
+    }
+    return 0;
+  });
+}
+
+// src/lib/arrSortedInsertionIndex.ts
+var arrSortedInsertionIndex_exports = {};
+__export(arrSortedInsertionIndex_exports, {
+  arrSortedInsertionIndex: () => arrSortedInsertionIndex
+});
+function arrSortedInsertionIndex(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      it++;
+      first = it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+
+// 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) {
+    if (row.length !== numHeaders) {
+      throw new Error(`Expected ${numHeaders} columns, got ${row.length}`);
+    }
+  }
+}
+
+// src/lib/arrTableEachToString.ts
+var arrTableEachToString_exports = {};
+__export(arrTableEachToString_exports, {
+  arrTableEachToString: () => arrTableEachToString
+});
+function arrTableEachToString(table) {
+  return table.map(arrEachToString);
+}
+
+// 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");
+  }
+  ignoreHeaders.forEach((h) => {
+    if (!headers.includes(h)) {
+      throw new Error(`Header "${h}" not found in headers: ${headers}`);
+    }
+  });
+  if (new Set(headers).size === ignoreHeaders.size) {
+    throw new Error("All headers are ignored");
+  }
+  for (let r = 0; r < rows.length; r++) {
+    if (rows[r].length !== headers.length) {
+      throw new Error(`Row ${r} has ${rows[r].length} columns, but expected ${headers.length}`);
+    }
+    const o = {};
+    for (let c = 0; c < headers.length; c++) {
+      if (ignoreHeaders.has(headers[c])) {
+        continue;
+      }
+      o[headers[c]] = rows[r][c];
+    }
+    yield o;
+  }
+}
+
+// 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()
+  );
+  return table.map((row) => {
+    return row.filter((_, i) => {
+      return !set.has(i);
+    });
+  });
+}
+
+// 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");
+}
+
+// src/lib/arrTableToObjects.ts
+var arrTableToObjects_exports = {};
+__export(arrTableToObjects_exports, {
+  arrTableToObjects: () => arrTableToObjects
+});
+function arrTableToObjects(rows, headers, ignoreKeys) {
+  if (headers) {
+    if (!rows.length) {
+      return [];
+    }
+  } else {
+    if (rows.length <= 1) {
+      return [];
+    }
+    headers = rows[0].map((header) => {
+      return header === null || header === void 0 ? "" : String(header);
+    });
+    rows = rows.slice(1);
+  }
+  const _headers = headers;
+  return rows.map((row) => {
+    const o = {};
+    for (let i = 0; i < _headers.length; i++) {
+      const header = _headers[i];
+      if (ignoreKeys && ignoreKeys.has(header)) {
+        continue;
+      }
+      o[header] = row[i];
+    }
+    return o;
+  });
+}
+
+// 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(",")}]`;
+}
+
+// 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,
+  arrFindIndicesOf,
+  arrGetOrDefault,
+  arrHasDuplicates,
+  arrIndicesOf,
+  arrLast,
+  arrMapMutable,
+  arrObjectsToTable,
+  arrObjectsUniqueKeys,
+  arrRemove,
+  arrRemoveDuplicates,
+  arrRemoveMutable,
+  arrShuffle,
+  arrSortNumeric,
+  arrSortedInsertionIndex,
+  arrSum,
+  arrSwap,
+  arrTableAssertRowsSameLength,
+  arrTableEachToString,
+  arrTableIterateAsObjects,
+  arrTableRemoveColumns,
+  arrTableToCsv,
+  arrTableToObjects,
+  arrayToString,
+  src_default as default
+};

package/{cjs/lib → lib}/arrAverage.d.ts

@@ -10,4 +10,3 @@
  * ```
  */
 export declare function arrAverage(array: number[]): number;
-//# sourceMappingURL=arrAverage.d.ts.map

package/{cjs/lib → lib}/arrEachToString.d.ts

@@ -10,4 +10,3 @@
  * ```
  */
 export declare function arrEachToString<T>(array: T[]): string[];
-//# sourceMappingURL=arrEachToString.d.ts.map

package/{cjs/lib → lib}/arrFindIndicesOf.d.ts

@@ -5,4 +5,3 @@
  * @returns An array of indices where the predicate function returns true.
  */
 export declare function arrFindIndicesOf<T>(input: Array<T>, predicate: (value: T) => boolean): number[];
-//# sourceMappingURL=arrFindIndicesOf.d.ts.map

package/lib/arrGetOrDefault.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 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/{cjs/lib → lib}/arrHasDuplicates.d.ts

@@ -5,4 +5,3 @@
  * @typeParam T - The type of elements in the array.
  */
 export declare function arrHasDuplicates<T>(arr: T[]): boolean;
-//# sourceMappingURL=arrHasDuplicates.d.ts.map

package/{cjs/lib → lib}/arrIndicesOf.d.ts

@@ -12,4 +12,3 @@
  *  ```
  */
 export declare function arrIndicesOf<T>(input: Array<T>, element: T): number[];
-//# sourceMappingURL=arrIndicesOf.d.ts.map

package/{cjs/lib → lib}/arrLast.d.ts

@@ -10,4 +10,3 @@
  * //=> 5
  */
 export declare function arrLast<T>(array: T[]): T;
-//# sourceMappingURL=arrLast.d.ts.map

package/{cjs/lib → lib}/arrMapMutable.d.ts

@@ -1,4 +1,3 @@
-import { ArrayValueCallback } from './types/ArrayValueCallback';
 /**
  * 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.
@@ -10,5 +9,4 @@ import { ArrayValueCallback } from './types/ArrayValueCallback';
  * //=> [2, 4, 6]
  * ```
  */
-export declare function arrMapMutable<T>(input: Array<T>, f: ArrayValueCallback<T>): Array<T>;
-//# sourceMappingURL=arrMapMutable.d.ts.map
+export declare function arrMapMutable<T>(input: Array<T>, f: (value: T, index: number, array: T[]) => T): Array<T>;

package/{cjs/lib → lib}/arrObjectsToTable.d.ts

@@ -20,4 +20,3 @@ export declare function arrObjectsToTable<T, E>(objects: Record<string, T | unde
     headers?: string[];
     emptyCell?: E;
 }): Array<Array<string | T | E>>;
-//# sourceMappingURL=arrObjectsToTable.d.ts.map

package/{cjs/lib → lib}/arrObjectsUniqueKeys.d.ts

@@ -14,4 +14,3 @@
  * ```
  */
 export declare function arrObjectsUniqueKeys<T>(objects: Record<string, T>[]): string[];
-//# sourceMappingURL=arrObjectsUniqueKeys.d.ts.map

package/{cjs/lib → lib}/arrRemove.d.ts

@@ -2,4 +2,3 @@
  * 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[];
-//# sourceMappingURL=arrRemove.d.ts.map

package/{cjs/lib → lib}/arrRemoveDuplicates.d.ts

@@ -11,4 +11,3 @@
  * ```
  */
 export declare function arrRemoveDuplicates<T>(array: T[]): T[];
-//# sourceMappingURL=arrRemoveDuplicates.d.ts.map

package/{cjs/lib → lib}/arrRemoveMutable.d.ts

@@ -2,4 +2,3 @@
  * Remove elements in-place from an array.
  */
 export declare function arrRemoveMutable<T>(arr: T[], elementToRemove: T): void;
-//# sourceMappingURL=arrRemoveMutable.d.ts.map

package/{cjs/lib → lib}/arrShuffle.d.ts

@@ -11,4 +11,3 @@
  * ```
  */
 export declare function arrShuffle<T>(input: Array<T>): Array<T>;
-//# sourceMappingURL=arrShuffle.d.ts.map

package/{cjs/lib → lib}/arrSortNumeric.d.ts

@@ -12,4 +12,3 @@
  * ```
  */
 export declare function arrSortNumeric(input: Array<number | bigint | boolean>): Array<number | bigint | boolean>;
-//# sourceMappingURL=arrSortNumeric.d.ts.map

package/{cjs/lib → lib}/arrSortedInsertionIndex.d.ts

@@ -14,4 +14,3 @@
  * ```
  */
 export declare function arrSortedInsertionIndex<T>(array: readonly T[], value: T, comparator: (a: T, b: T) => number): number;
-//# sourceMappingURL=arrSortedInsertionIndex.d.ts.map

package/{cjs/lib → lib}/arrSum.d.ts

@@ -9,4 +9,3 @@
  * ```
  */
 export declare function arrSum(array: number[]): number;
-//# sourceMappingURL=arrSum.d.ts.map

package/{cjs/lib → lib}/arrSwap.d.ts

@@ -12,4 +12,3 @@
  * ```
  */
 export declare function arrSwap<T>(input: Array<T>, from: number, to: number): Array<T>;
-//# sourceMappingURL=arrSwap.d.ts.map

package/{cjs/lib → lib}/arrTableAssertRowsSameLength.d.ts

@@ -23,4 +23,3 @@
  *  ```
  */
 export declare function arrTableAssertRowsSameLength<T>(rows: T[][], headers?: string[]): void;
-//# sourceMappingURL=arrTableAssertRowsSameLength.d.ts.map

package/{cjs/lib → lib}/arrTableEachToString.d.ts

@@ -10,4 +10,3 @@
  * ```
  */
 export declare function arrTableEachToString<T>(table: T[][]): string[][];
-//# sourceMappingURL=arrTableEachToString.d.ts.map

package/lib/arrTableIterateAsObjects.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 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/{cjs/lib → lib}/arrTableRemoveColumns.d.ts

@@ -5,4 +5,3 @@
  * @returns A new 2D array (table) with the specified columns removed.
  */
 export declare function arrTableRemoveColumns(table: string[][], ...removeColumnNames: string[]): string[][];
-//# sourceMappingURL=arrTableRemoveColumns.d.ts.map

package/{cjs/lib → lib}/arrTableToCsv.d.ts

@@ -18,4 +18,3 @@
  * ```
  */
 export declare function arrTableToCsv<T>(input: T[][], delimiter?: string, replaceLinebreakWith?: string): string;
-//# sourceMappingURL=arrTableToCsv.d.ts.map

package/{cjs/lib → lib}/arrTableToObjects.d.ts

@@ -20,4 +20,3 @@
  * ```
  */
 export declare function arrTableToObjects<T>(rows: T[][], headers?: string[], ignoreKeys?: Set<string>): Record<string, T>[];
-//# sourceMappingURL=arrTableToObjects.d.ts.map

package/lib/arrayToString.d.ts

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