@rimbu/base 0.11.4 → 1.0.0-alpha.1

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/index.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAChD,cAAc,oBAAoB,CAAC;AAEnC,cAAc,gBAAgB,CAAC"}

package/dist/esm/internal.mjs

@@ -0,0 +1,2 @@
+export * from './token.mjs';
+//# sourceMappingURL=internal.mjs.map

package/dist/esm/internal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.mjs","sourceRoot":"","sources":["../../src/internal.mts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/{module/plain-object.js → esm/plain-object.mjs}

@@ -19,4 +19,4 @@ export function isPlainObj(obj) {
 export function isIterable(obj) {
     return obj !== null && typeof obj === 'object' && Symbol.iterator in obj;
 }
-//# sourceMappingURL=plain-object.js.map
+//# sourceMappingURL=plain-object.mjs.map

package/dist/esm/plain-object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain-object.mjs","sourceRoot":"","sources":["../../src/plain-object.mts"],"names":[],"mappings":"AAuEA;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,GAAQ;IACjC,OAAO,CACL,OAAO,GAAG,KAAK,QAAQ;QACvB,IAAI,KAAK,GAAG;QACZ,CAAC,GAAG,CAAC,WAAW,KAAK,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,WAAW,YAAY,QAAQ,CAAC,CAAC;QACtE,CAAC,CAAC,MAAM,CAAC,QAAQ,IAAI,GAAG,CAAC;QACzB,CAAC,CAAC,MAAM,CAAC,aAAa,IAAI,GAAG,CAAC,CAC/B,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,GAAQ;IACjC,OAAO,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,IAAI,GAAG,CAAC;AAC3E,CAAC"}

package/dist/{module/rimbu-error.js → esm/rimbu-error.mjs}

@@ -28,4 +28,4 @@ export function throwInvalidStateError() {
 export function throwInvalidUsageError(msg) {
     throw new InvalidUsageError(msg);
 }
-//# sourceMappingURL=rimbu-error.js.map
+//# sourceMappingURL=rimbu-error.mjs.map

package/dist/esm/rimbu-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rimbu-error.mjs","sourceRoot":"","sources":["../../src/rimbu-error.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,MAAM,OAAO,mCAAoC,SAAQ,OAAO,CAAC,WAAW;IAC1E;QACE,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACzD,CAAC;CACF;AAED,MAAM,OAAO,sCAAuC,SAAQ,OAAO,CAAC,WAAW;IAC7E;QACE,KAAK,CAAC,+DAA+D,CAAC,CAAC;IACzE,CAAC;CACF;AAED,MAAM,OAAO,iBAAkB,SAAQ,OAAO,CAAC,WAAW;IACxD;QACE,KAAK,CACH,4EAA4E,CAC7E,CAAC;IACJ,CAAC;CACF;AAED,MAAM,OAAO,iBAAkB,SAAQ,OAAO,CAAC,WAAW;CAAG;AAE7D,MAAM,UAAU,wCAAwC;IACtD,MAAM,IAAI,mCAAmC,EAAE,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,2CAA2C;IACzD,MAAM,IAAI,sCAAsC,EAAE,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,MAAM,IAAI,iBAAiB,EAAE,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,GAAW;IAChD,MAAM,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAAC;AACnC,CAAC"}

package/dist/{module/token.js → esm/token.mjs}

@@ -1,2 +1,2 @@
 export const Token = Symbol('Token');
-//# sourceMappingURL=token.js.map
+//# sourceMappingURL=token.mjs.map

package/dist/esm/token.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.mjs","sourceRoot":"","sources":["../../src/token.mts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC"}

package/dist/types/{arr.d.ts → arr.d.mts}

@@ -1,4 +1,4 @@
-import { Update, TraverseState, ArrayNonEmpty } from '@rimbu/common';
+import { Update, TraverseState, type ArrayNonEmpty } from '@rimbu/common';
 export declare function append<T>(array: readonly T[], value: T): ArrayNonEmpty<T>;
 export declare function concat<T>(first: readonly T[], second: readonly T[]): readonly T[];
 export declare function reverse<T>(array: readonly T[], start?: number, end?: number): T[];

package/dist/types/index.d.mts

@@ -0,0 +1,5 @@
+export * as Arr from './arr.mjs';
+export * as Entry from './entry.mjs';
+export * as RimbuError from './rimbu-error.mjs';
+export * from './plain-object.mjs';
+export * from './internal.mjs';

package/dist/types/internal.d.mts

@@ -0,0 +1 @@
+export * from './token.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimbu/base",
-  "version": "0.11.4",
+  "version": "1.0.0-alpha.1",
   "description": "Utilities to implement Rimbu collections",
   "keywords": [
     "array",
@@ -26,17 +26,17 @@
     "url": "https://github.com/rimbu-org/rimbu.git",
     "directory": "packages/base"
   },
-  "source": "./src/index.ts",
-  "main": "./dist/main/index.js",
-  "module": "./dist/module/index.js",
-  "types": "./dist/types/index.d.ts",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.mjs",
+  "types": "./dist/types/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
-      "bun": "./src/index.ts",
-      "import": "./dist/module/index.js",
-      "require": "./dist/main/index.js",
-      "default": "./dist/module/index.js"
+      "types": "./dist/types/index.d.mts",
+      "bun": "./dist/bun/index.mts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.mjs"
     }
   },
   "files": [
@@ -45,27 +45,33 @@
   ],
   "scripts": {
     "build": "yarn clean && yarn bundle",
-    "build:deno": "rimraf deno_dist ../../deno_dist/base && denoify && mv deno_dist ../../deno_dist/base",
-    "bundle": "yarn bundle:main && yarn bundle:module && yarn bundle:types",
-    "bundle:main": "tsc --p tsconfig.main.json",
-    "bundle:module": "tsc --p tsconfig.module.json",
+    "build:deno": "yarn bundle:deno-prepare && yarn bundle:deno-convert && yarn bundle:deno-move && yarn bundle:deno-clean",
+    "bundle": "yarn bundle:cjs && yarn bundle:esm && yarn bundle:types && yarn bundle:bun",
+    "bundle:bun": "node ../../config/bunnify.mjs",
+    "bundle:cjs": "tsup src --format cjs --clean -d dist/cjs --loader '.mts=ts' --legacy-output",
+    "bundle:deno-prepare": "node ../../config/prepare-denoify.mjs",
+    "bundle:deno-convert": "denoify --src _deno_prepare/src",
+    "bundle:deno-move": "rimraf ../../deno_dist/base && mv deno_dist ../../deno_dist/base",
+    "bundle:deno-clean": "rimraf _deno_prepare",
+    "bundle:esm": "tsc --p tsconfig.esm.json",
     "bundle:types": "tsc --p tsconfig.types.json",
     "clean": "rimraf dist",
     "format": "yarn format:base --write",
-    "format:base": "prettier \"{!CHANGELOG.md}|**/**/*.{ts,tsx,js,json,md}\"",
+    "format:base": "prettier \"{!CHANGELOG.md}|**/**/*.{ts,tsx,js,mts,mjs,json,md}\"",
     "format:check": "yarn format:base --check",
     "lint": "eslint src",
-    "test": "jest",
-    "test:types": "tsd",
+    "test": "vitest run",
+    "test:cov": "vitest run --coverage",
+    "test:watch": "vitest",
+    "test:types": "tsd --files test-d",
     "typecheck": "tsc"
   },
-  "sideEffects": false,
   "dependencies": {
-    "@rimbu/common": "*",
-    "tslib": "^2.5.0"
+    "@rimbu/common": "^1.0.0-alpha.1",
+    "tslib": "^2.5.3"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5400f8471bdfc7a227f7defc4a3942bdf3ff1423"
+  "gitHead": "dfaf8143e56f54ed1e31f7c96802548c46e03bd8"
 }

package/src/arr.mts

@@ -0,0 +1,195 @@
+import { Update, TraverseState, type ArrayNonEmpty } from '@rimbu/common';
+
+// Returns a copy of the array with the given value appended
+export function append<T>(array: readonly T[], value: T): ArrayNonEmpty<T> {
+  const clone = array.slice();
+  clone.push(value);
+  return clone as ArrayNonEmpty<T>;
+}
+
+// Returns the concatenation of the two arrays, potentially reusing the input array if one of the arrays is empty
+export function concat<T>(
+  first: readonly T[],
+  second: readonly T[]
+): readonly T[] {
+  if (first.length === 0) return second;
+  if (second.length === 0) return first;
+  return first.concat(second);
+}
+
+// Returns an copy of the array between the start and end indices, with the elements in reversed order.
+export function reverse<T>(
+  array: readonly T[],
+  start = 0,
+  end = array.length - 1
+): T[] {
+  const length = end - start + 1;
+  const res = [] as T[];
+
+  let arrayIndex = start - 1;
+  let resIndex = length - 1;
+
+  while (++arrayIndex <= end) res[resIndex--] = array[arrayIndex];
+
+  return res;
+}
+
+// Performs given function on each element of the array, in reverse order if 'reversed' is true.
+export function forEach<T>(
+  array: readonly T[],
+  f: (value: T, index: number, halt: () => void) => void,
+  state: TraverseState = TraverseState(),
+  reversed = false
+): void {
+  if (state.halted) return;
+
+  const { halt } = state;
+
+  if (reversed) {
+    let i = array.length;
+
+    while (!state.halted && --i >= 0) {
+      f(array[i], state.nextIndex(), halt);
+    }
+  } else {
+    const length = array.length;
+    let i = -1;
+
+    while (!state.halted && ++i < length) {
+      f(array[i], state.nextIndex(), halt);
+    }
+  }
+}
+
+// Returns a copy of the array where given function is applied to each element
+export function map<T, R>(
+  array: readonly T[],
+  f: (value: T, index: number) => R,
+  indexOffset = 0
+): R[] {
+  const result: R[] = [];
+
+  let index = indexOffset;
+  let i = -1;
+  const length = array.length;
+  while (++i < length) {
+    result[i] = f(array[i], index++);
+  }
+  return result;
+}
+
+// Returns a copy of the array where given functio is applied to each element in reverse order
+export function reverseMap<T, R>(
+  array: readonly T[],
+  f: (value: T, index: number) => R,
+  indexOffset = 0
+): R[] {
+  const result: R[] = [];
+
+  let index = indexOffset;
+  let arrayIndex = array.length;
+  let resultIndex = 0;
+  while (--arrayIndex >= 0)
+    result[resultIndex++] = f(array[arrayIndex], index++);
+
+  return result;
+}
+
+// Returns a copy of the given array with the given value added at the start
+export function prepend<T>(array: readonly T[], value: T): ArrayNonEmpty<T> {
+  const clone = array.slice();
+  clone.unshift(value);
+  return clone as ArrayNonEmpty<T>;
+}
+
+// Returns the last element of the array
+export function last<T>(arr: readonly T[]): T {
+  return arr[arr.length - 1];
+}
+
+// Returns a copy of the array where the element at given index is replaced by the given updater.
+// If the new element is the same as the old element, the original array is returned
+export function update<T>(
+  arr: readonly T[],
+  index: number,
+  updater: Update<T>
+): readonly T[] {
+  if (index < 0 || index >= arr.length) return arr;
+  const curValue = arr[index];
+
+  const newValue = Update(curValue, updater);
+  if (Object.is(newValue, curValue)) return arr;
+  const newArr = arr.slice();
+  newArr[index] = newValue;
+  return newArr;
+}
+
+// Returns a copy of the array where the element at given index is replaced by applying given function.
+// If the new element is the same as the old element, the original array is returned
+export function mod<T>(
+  arr: readonly T[],
+  index: number,
+  f: (value: T) => T
+): readonly T[] {
+  if (index < 0 || index >= arr.length) return arr;
+
+  const curValue = arr[index];
+  const newValue = f(curValue);
+  if (Object.is(newValue, curValue)) return arr;
+  const newArr = arr.slice();
+  newArr[index] = newValue;
+  return newArr;
+}
+
+// Returns a copy of the array where at given index the given value is inserted
+export function insert<T>(arr: readonly T[], index: number, value: T): T[] {
+  const clone = arr.slice();
+  clone.splice(index, 0, value);
+  return clone;
+}
+
+// Returns a copy of the array, without its first element
+export function tail<T>(arr: readonly T[]): T[] {
+  return arr.slice(1);
+}
+
+// Returns a copy of the array, without its last element
+export function init<T>(arr: readonly T[]): T[] {
+  return arr.slice(0, arr.length - 1);
+}
+
+// Immutable version of the array .splice command, always returns a new array
+export function splice<T>(
+  arr: readonly T[],
+  start: number,
+  deleteCount: number,
+  ...items: T[]
+): T[] {
+  const clone = arr.slice();
+  clone.splice(start, deleteCount, ...items);
+  return clone;
+}
+
+// Returns a copy of the array, where its 'sparse' property is kept (sparse = not all indices have a value)
+export function copySparse<T>(arr: readonly T[]): T[] {
+  const clone: T[] = [];
+  for (const key in arr) {
+    clone[key] = arr[key];
+  }
+  return clone;
+}
+
+// Returns a copy of the array with given function applied to each element, where its 'sparse' property is kept
+// (sparse = not all indices have a value)
+export function mapSparse<T, T2>(
+  arr: readonly T[],
+  f: (value: T, index: number) => T2
+): T2[] {
+  const result: T2[] = Array(arr.length);
+
+  for (const key in arr) {
+    result[key] = f(arr[key], key as any);
+  }
+
+  return result;
+}

package/src/entry.mts

@@ -0,0 +1,9 @@
+// Returns the first element of a 2-Tuple
+export function first<K, V>(entry: readonly [K, V]): K {
+  return entry[0];
+}
+
+// Returns the second element of a 2-Tuple
+export function second<K, V>(entry: readonly [K, V]): V {
+  return entry[1];
+}

package/src/index.mts

@@ -0,0 +1,6 @@
+export * as Arr from './arr.mjs';
+export * as Entry from './entry.mjs';
+export * as RimbuError from './rimbu-error.mjs';
+export * from './plain-object.mjs';
+
+export * from './internal.mjs';

package/src/internal.mts

@@ -0,0 +1 @@
+export * from './token.mjs';

package/src/plain-object.mts

@@ -0,0 +1,95 @@
+/**
+ * Matches any type of function
+ */
+export type AnyFunc = (...args: any[]) => any;
+
+/**
+ * Gives true if the given type T is a function, false otherwise.
+ * @typeparam T - the input type
+ */
+export type IsAnyFunc<T> = AnyFunc extends T ? true : false;
+
+/**
+ * A predicate type for any record that resolves to true if any of the record
+ * properties is a function, false otherwise.
+ * This is useful to have a coarse discrimination between pure data objects and class instances.
+ * @typeparam T - the input type
+ */
+export type IsObjWithoutFunctions<T> = AnyFunc extends T[keyof T]
+  ? false
+  : true;
+
+/**
+ * A predicate type that resolves to true if the given type satisfies:
+ * - it is an object type (not a primitive)
+ * - it is not a function
+ * - it is not iterable
+ * - it does not have any properties that are functions
+ * Otherwise, it resolves to false
+ * @typeparam T - the input type
+ */
+export type IsPlainObj<T> = T extends
+  | null
+  | undefined
+  | number
+  | string
+  | boolean
+  | bigint
+  | symbol
+  | AnyFunc
+  | Iterable<any>
+  | AsyncIterable<any>
+  ? false
+  : IsObjWithoutFunctions<T>;
+
+/**
+ * Utility type that will only accept objects that are considered 'plain objects' according
+ * to the `IsPlainObj` predicate type.
+ * @typeparam T - the value type to test
+ */
+export type PlainObj<T> = IsPlainObj<T> extends true ? T : never;
+
+/**
+ * Utility type that will only return true if the input type T is equal to `any`.
+ * @typeparam T - the value type to test
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+
+/**
+ * Utility type that will only return true if the input type T is a (readonly) array.
+ * @typeparm T - the value type to test
+ */
+export type IsArray<T> = T extends readonly any[] ? true : false;
+
+/**
+ * Utility type to exclude any types that are iterable. Useful in cases where
+ * plain objects are required as inputs but not arrays.
+ */
+export type NotIterable = {
+  [Symbol.iterator]?: never;
+};
+
+/**
+ * Companion function to the `IsRecord<T>` type that checks whether the given object is a pure
+ * data object.
+ * @param obj - the object to check
+ * @returns true if the given object is a pure data object
+ * @note does not check whether a record's properties are not functions
+ */
+export function isPlainObj(obj: any): obj is object {
+  return (
+    typeof obj === 'object' &&
+    null !== obj &&
+    (obj.constructor === Object || !(obj.constructor instanceof Function)) &&
+    !(Symbol.iterator in obj) &&
+    !(Symbol.asyncIterator in obj)
+  );
+}
+
+/**
+ * Returns true if the given object is Iterable
+ * @param obj - the object to check
+ */
+export function isIterable(obj: any): obj is Iterable<unknown> {
+  return obj !== null && typeof obj === 'object' && Symbol.iterator in obj;
+}

package/src/rimbu-error.mts

@@ -0,0 +1,39 @@
+import { ErrBase } from '@rimbu/common';
+
+export class EmptyCollectionAssumedNonEmptyError extends ErrBase.CustomError {
+  constructor() {
+    super('empty collection was assumbed to be non-empty');
+  }
+}
+
+export class ModifiedBuilderWhileLoopingOverItError extends ErrBase.CustomError {
+  constructor() {
+    super('an attempt was made to modify a builder while looping over it');
+  }
+}
+
+export class InvalidStateError extends ErrBase.CustomError {
+  constructor() {
+    super(
+      "something happend that shouldn't happen, please consider creating an issue"
+    );
+  }
+}
+
+export class InvalidUsageError extends ErrBase.CustomError {}
+
+export function throwEmptyCollectionAssumedNonEmptyError(): never {
+  throw new EmptyCollectionAssumedNonEmptyError();
+}
+
+export function throwModifiedBuilderWhileLoopingOverItError(): never {
+  throw new ModifiedBuilderWhileLoopingOverItError();
+}
+
+export function throwInvalidStateError(): never {
+  throw new InvalidStateError();
+}
+
+export function throwInvalidUsageError(msg: string): never {
+  throw new InvalidUsageError(msg);
+}

package/src/token.mts

@@ -0,0 +1,2 @@
+export const Token = Symbol('Token');
+export type Token = typeof Token;

package/dist/main/arr.js

@@ -1,169 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapSparse = exports.copySparse = exports.splice = exports.init = exports.tail = exports.insert = exports.mod = exports.update = exports.last = exports.prepend = exports.reverseMap = exports.map = exports.forEach = exports.reverse = exports.concat = exports.append = void 0;
-var tslib_1 = require("tslib");
-var common_1 = require("@rimbu/common");
-// Returns a copy of the array with the given value appended
-function append(array, value) {
-    var clone = array.slice();
-    clone.push(value);
-    return clone;
-}
-exports.append = append;
-// Returns the concatenation of the two arrays, potentially reusing the input array if one of the arrays is empty
-function concat(first, second) {
-    if (first.length === 0)
-        return second;
-    if (second.length === 0)
-        return first;
-    return first.concat(second);
-}
-exports.concat = concat;
-// Returns an copy of the array between the start and end indices, with the elements in reversed order.
-function reverse(array, start, end) {
-    if (start === void 0) { start = 0; }
-    if (end === void 0) { end = array.length - 1; }
-    var length = end - start + 1;
-    var res = [];
-    var arrayIndex = start - 1;
-    var resIndex = length - 1;
-    while (++arrayIndex <= end)
-        res[resIndex--] = array[arrayIndex];
-    return res;
-}
-exports.reverse = reverse;
-// Performs given function on each element of the array, in reverse order if 'reversed' is true.
-function forEach(array, f, state, reversed) {
-    if (state === void 0) { state = (0, common_1.TraverseState)(); }
-    if (reversed === void 0) { reversed = false; }
-    if (state.halted)
-        return;
-    var halt = state.halt;
-    if (reversed) {
-        var i = array.length;
-        while (!state.halted && --i >= 0) {
-            f(array[i], state.nextIndex(), halt);
-        }
-    }
-    else {
-        var length_1 = array.length;
-        var i = -1;
-        while (!state.halted && ++i < length_1) {
-            f(array[i], state.nextIndex(), halt);
-        }
-    }
-}
-exports.forEach = forEach;
-// Returns a copy of the array where given function is applied to each element
-function map(array, f, indexOffset) {
-    if (indexOffset === void 0) { indexOffset = 0; }
-    var result = [];
-    var index = indexOffset;
-    var i = -1;
-    var length = array.length;
-    while (++i < length) {
-        result[i] = f(array[i], index++);
-    }
-    return result;
-}
-exports.map = map;
-// Returns a copy of the array where given functio is applied to each element in reverse order
-function reverseMap(array, f, indexOffset) {
-    if (indexOffset === void 0) { indexOffset = 0; }
-    var result = [];
-    var index = indexOffset;
-    var arrayIndex = array.length;
-    var resultIndex = 0;
-    while (--arrayIndex >= 0)
-        result[resultIndex++] = f(array[arrayIndex], index++);
-    return result;
-}
-exports.reverseMap = reverseMap;
-// Returns a copy of the given array with the given value added at the start
-function prepend(array, value) {
-    var clone = array.slice();
-    clone.unshift(value);
-    return clone;
-}
-exports.prepend = prepend;
-// Returns the last element of the array
-function last(arr) {
-    return arr[arr.length - 1];
-}
-exports.last = last;
-// Returns a copy of the array where the element at given index is replaced by the given updater.
-// If the new element is the same as the old element, the original array is returned
-function update(arr, index, updater) {
-    if (index < 0 || index >= arr.length)
-        return arr;
-    var curValue = arr[index];
-    var newValue = (0, common_1.Update)(curValue, updater);
-    if (Object.is(newValue, curValue))
-        return arr;
-    var newArr = arr.slice();
-    newArr[index] = newValue;
-    return newArr;
-}
-exports.update = update;
-// Returns a copy of the array where the element at given index is replaced by applying given function.
-// If the new element is the same as the old element, the original array is returned
-function mod(arr, index, f) {
-    if (index < 0 || index >= arr.length)
-        return arr;
-    var curValue = arr[index];
-    var newValue = f(curValue);
-    if (Object.is(newValue, curValue))
-        return arr;
-    var newArr = arr.slice();
-    newArr[index] = newValue;
-    return newArr;
-}
-exports.mod = mod;
-// Returns a copy of the array where at given index the given value is inserted
-function insert(arr, index, value) {
-    var clone = arr.slice();
-    clone.splice(index, 0, value);
-    return clone;
-}
-exports.insert = insert;
-// Returns a copy of the array, without its first element
-function tail(arr) {
-    return arr.slice(1);
-}
-exports.tail = tail;
-// Returns a copy of the array, without its last element
-function init(arr) {
-    return arr.slice(0, arr.length - 1);
-}
-exports.init = init;
-// Immutable version of the array .splice command, always returns a new array
-function splice(arr, start, deleteCount) {
-    var items = [];
-    for (var _i = 3; _i < arguments.length; _i++) {
-        items[_i - 3] = arguments[_i];
-    }
-    var clone = arr.slice();
-    clone.splice.apply(clone, tslib_1.__spreadArray([start, deleteCount], tslib_1.__read(items), false));
-    return clone;
-}
-exports.splice = splice;
-// Returns a copy of the array, where its 'sparse' property is kept (sparse = not all indices have a value)
-function copySparse(arr) {
-    var clone = [];
-    for (var key in arr) {
-        clone[key] = arr[key];
-    }
-    return clone;
-}
-exports.copySparse = copySparse;
-// Returns a copy of the array with given function applied to each element, where its 'sparse' property is kept
-// (sparse = not all indices have a value)
-function mapSparse(arr, f) {
-    var result = Array(arr.length);
-    for (var key in arr) {
-        result[key] = f(arr[key], key);
-    }
-    return result;
-}
-exports.mapSparse = mapSparse;
-//# sourceMappingURL=arr.js.map