@rimbu/common 2.0.0 → 2.0.2

package/dist/cjs/internal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.cjs","sourceRoot":"","sources":["../../_cjs_prepare/internal.cts"],"names":[],"mappings":";;;AAAA,wDAA8B;AAC9B,qDAA2B;AAC3B,mDAAyB;AACzB,oDAA0B;AAC1B,4DAAkC;AAClC,wDAA8B;AAC9B,sDAA4B;AAC5B,+DAAqC;AACrC,sDAA4B;AAC5B,uDAA6B;AAC7B,8DAAoC"}

package/dist/cjs/internal.d.cts

@@ -0,0 +1,11 @@
+export * from './collect.cjs';
+export * from './comp.cjs';
+export * from './eq.cjs';
+export * from './err.cjs';
+export * from './index-range.cjs';
+export * from './optlazy.cjs';
+export * from './range.cjs';
+export * from './traverse-state.cjs';
+export * from './types.cjs';
+export * from './update.cjs';
+export * from './async-optlazy.cjs';

package/dist/cjs/optlazy.cjs

@@ -1,41 +1,47 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/optlazy.mts
-var optlazy_exports = {};
-__export(optlazy_exports, {
-  OptLazy: () => OptLazy,
-  OptLazyOr: () => OptLazyOr
-});
-module.exports = __toCommonJS(optlazy_exports);
-function OptLazy(optLazy, ...args) {
-  if (optLazy instanceof Function)
-    return optLazy(...args);
-  return optLazy;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptLazy = OptLazy;
+exports.OptLazyOr = OptLazyOr;
+var tslib_1 = require("tslib");
+/**
+ * Returns the value contained in an `OptLazy` instance of type T.
+ * @param optLazy - the `OptLazy` value of type T
+ * @param args - when needed, the extra arguments to pass to the lazy invocation
+ * @typeparam T - the value type
+ * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
+ * @example
+ * ```ts
+ * OptLazy(1)              // => 1
+ * OptLazy(() => 1)        // => 1
+ * OptLazy(() => () => 1)  // => () => 1
+ * ```
+ */
+function OptLazy(optLazy) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    if (optLazy instanceof Function)
+        return optLazy.apply(void 0, tslib_1.__spreadArray([], tslib_1.__read(args), false));
+    return optLazy;
 }
+/**
+ * Returns the value contained in an `OptLazyOr` instance of type T, or the given
+ * `otherValue` if the lazy function returns it.
+ * @param optLazyOr - a value or a function returning a value or otherwise the received value
+ * @param otherValue - the value to return if the optLazyOr does not return its own value
+ * @typeparam T - the value type
+ * @typeparam O - the default value type
+ * @example
+ * ```ts
+ * OptLazyOr(1, 'a')               // => 1
+ * OptLazyOr(() => 1, 'a')         // => 1
+ * OptLazyOr((none) => none, 'a')  // => 'a'
+ * ```
+ */
 function OptLazyOr(optLazyOr, otherValue) {
-  if (optLazyOr instanceof Function)
-    return optLazyOr(otherValue);
-  return optLazyOr;
+    if (optLazyOr instanceof Function)
+        return optLazyOr(otherValue);
+    return optLazyOr;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  OptLazy,
-  OptLazyOr
-});
+//# sourceMappingURL=optlazy.cjs.map

package/dist/cjs/optlazy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"optlazy.cjs","sourceRoot":"","sources":["../../_cjs_prepare/optlazy.cts"],"names":[],"mappings":";;AAoBA,0BAMC;AAwBD,8BAMC;;AAjDD;;;;;;;;;;;;GAYG;AACH,SAAgB,OAAO,CACrB,OAAsB;IACtB,cAAU;SAAV,UAAU,EAAV,qBAAU,EAAV,IAAU;QAAV,6BAAU;;IAEV,IAAI,OAAO,YAAY,QAAQ;QAAE,OAAO,OAAO,wDAAI,IAAI,WAAE;IACzD,OAAO,OAAO,CAAC;AACjB,CAAC;AAUD;;;;;;;;;;;;;GAaG;AACH,SAAgB,SAAS,CACvB,SAA0B,EAC1B,UAAa;IAEb,IAAI,SAAS,YAAY,QAAQ;QAAE,OAAO,SAAS,CAAC,UAAU,CAAC,CAAC;IAChE,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/cjs/range.cjs

@@ -1,52 +1,38 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/range.mts
-var range_exports = {};
-__export(range_exports, {
-  Range: () => Range
-});
-module.exports = __toCommonJS(range_exports);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Range = void 0;
 var Range;
-((Range2) => {
-  function getNormalizedRange(range) {
-    let start = void 0;
-    let end = void 0;
-    if (`start` in range && void 0 !== range.start) {
-      if (Array.isArray(range.start) && range.start.length === 2 && typeof range.start[1] === "boolean") {
-        start = range.start;
-      } else {
-        start = [range.start, true];
-      }
+(function (Range) {
+    /**
+     * Simplifies a given `range` `Range` input for easier processing, by returning optional
+     * start and end ranges including whether they are inclusive or exclusive
+     * @param range - the `Range` to use
+     */
+    function getNormalizedRange(range) {
+        var start = undefined;
+        var end = undefined;
+        if ("start" in range && undefined !== range.start) {
+            if (Array.isArray(range.start) &&
+                range.start.length === 2 &&
+                typeof range.start[1] === 'boolean') {
+                start = range.start;
+            }
+            else {
+                start = [range.start, true];
+            }
+        }
+        if ("end" in range && undefined !== range.end) {
+            if (Array.isArray(range.end) &&
+                range.end.length === 2 &&
+                typeof range.end[1] === 'boolean') {
+                end = range.end;
+            }
+            else {
+                end = [range.end, true];
+            }
+        }
+        return { start: start, end: end };
     }
-    if (`end` in range && void 0 !== range.end) {
-      if (Array.isArray(range.end) && range.end.length === 2 && typeof range.end[1] === "boolean") {
-        end = range.end;
-      } else {
-        end = [range.end, true];
-      }
-    }
-    return { start, end };
-  }
-  Range2.getNormalizedRange = getNormalizedRange;
-})(Range || (Range = {}));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Range
-});
+    Range.getNormalizedRange = getNormalizedRange;
+})(Range || (exports.Range = Range = {}));
+//# sourceMappingURL=range.cjs.map

package/dist/cjs/range.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.cjs","sourceRoot":"","sources":["../../_cjs_prepare/range.cts"],"names":[],"mappings":";;;AAmBA,IAAiB,KAAK,CAsCrB;AAtCD,WAAiB,KAAK;IACpB;;;;OAIG;IACH,SAAgB,kBAAkB,CAAI,KAAe;QAInD,IAAI,KAAK,GAA6B,SAAS,CAAC;QAChD,IAAI,GAAG,GAA6B,SAAS,CAAC;QAE9C,IAAI,OAAO,IAAI,KAAK,IAAI,SAAS,KAAK,KAAK,CAAC,KAAK,EAAE,CAAC;YAClD,IACE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;gBAC1B,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;gBACxB,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,EACnC,CAAC;gBACD,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;YACtB,CAAC;iBAAM,CAAC;gBACN,KAAK,GAAG,CAAC,KAAK,CAAC,KAAU,EAAE,IAAI,CAAC,CAAC;YACnC,CAAC;QACH,CAAC;QACD,IAAI,KAAK,IAAI,KAAK,IAAI,SAAS,KAAK,KAAK,CAAC,GAAG,EAAE,CAAC;YAC9C,IACE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC;gBACxB,KAAK,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC;gBACtB,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,SAAS,EACjC,CAAC;gBACD,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;YAClB,CAAC;iBAAM,CAAC;gBACN,GAAG,GAAG,CAAC,KAAK,CAAC,GAAQ,EAAE,IAAI,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;QAED,OAAO,EAAE,KAAK,OAAA,EAAE,GAAG,KAAA,EAAE,CAAC;IACxB,CAAC;IA/Be,wBAAkB,qBA+BjC,CAAA;AACH,CAAC,EAtCgB,KAAK,qBAAL,KAAK,QAsCrB"}

package/dist/cjs/traverse-state.cjs

@@ -1,49 +1,32 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/traverse-state.mts
-var traverse_state_exports = {};
-__export(traverse_state_exports, {
-  TraverseState: () => TraverseState
-});
-module.exports = __toCommonJS(traverse_state_exports);
-var TraverseStateImpl = class {
-  constructor(startIndex) {
-    this.startIndex = startIndex;
-    this.halted = false;
-    this.halt = () => {
-      this.halted = true;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraverseState = TraverseState;
+var TraverseStateImpl = /** @class */ (function () {
+    function TraverseStateImpl(startIndex) {
+        var _this = this;
+        this.startIndex = startIndex;
+        this.halted = false;
+        this.halt = function () {
+            _this.halted = true;
+        };
+        this.currentIndex = startIndex;
+    }
+    TraverseStateImpl.prototype.nextIndex = function () {
+        return this.currentIndex++;
     };
-    this.currentIndex = startIndex;
-  }
-  nextIndex() {
-    return this.currentIndex++;
-  }
-  reset() {
-    this.currentIndex = this.startIndex;
-    this.halted = false;
-  }
-};
-function TraverseState(startIndex = 0) {
-  return new TraverseStateImpl(startIndex);
+    TraverseStateImpl.prototype.reset = function () {
+        this.currentIndex = this.startIndex;
+        this.halted = false;
+    };
+    return TraverseStateImpl;
+}());
+/**
+ * Returns a new `TraverseState` instance, using optionally given `startIndex` as a start
+ * index value.
+ * @param startIndex - (default: 0) the start index to use
+ */
+function TraverseState(startIndex) {
+    if (startIndex === void 0) { startIndex = 0; }
+    return new TraverseStateImpl(startIndex);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TraverseState
-});
+//# sourceMappingURL=traverse-state.cjs.map

package/dist/cjs/traverse-state.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse-state.cjs","sourceRoot":"","sources":["../../_cjs_prepare/traverse-state.cts"],"names":[],"mappings":";;AAwDA,sCAEC;AA7BD;IAIE,2BAAqB,UAAkB;QAAvC,iBAEC;QAFoB,eAAU,GAAV,UAAU,CAAQ;QAFvC,WAAM,GAAG,KAAK,CAAC;QAUN,SAAI,GAAG;YACd,KAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACrB,CAAC,CAAC;QATA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC;IACjC,CAAC;IAED,qCAAS,GAAT;QACE,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC;IAC7B,CAAC;IAMD,iCAAK,GAAL;QACE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC;QACpC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IACH,wBAAC;AAAD,CAAC,AApBD,IAoBC;AAED;;;;GAIG;AACH,SAAgB,aAAa,CAAC,UAAc;IAAd,2BAAA,EAAA,cAAc;IAC1C,OAAO,IAAI,iBAAiB,CAAC,UAAU,CAAC,CAAC;AAC3C,CAAC"}

package/dist/cjs/types.cjs

@@ -1,18 +1,3 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/types.mts
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.cjs.map

package/dist/cjs/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sourceRoot":"","sources":["../../_cjs_prepare/types.cts"],"names":[],"mappings":""}

package/dist/cjs/update.cjs

@@ -1,35 +1,23 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/update.mts
-var update_exports = {};
-__export(update_exports, {
-  Update: () => Update
-});
-module.exports = __toCommonJS(update_exports);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Update = Update;
+/**
+ * Returns the result of given `update` parameter, where it can either directly give a new value,
+ * or it is a function receiving the given `value`, and returns a new value.
+ * @param value - the current value
+ * @param update - an `Update` value, either a new value or a function receiving the old value
+ * and returning a new one.
+ * @example
+ * ```ts
+ * Update(1, 2)          // => 2
+ * Update(1, () => 10)   // => 10
+ * Update(1, v => v + 1) // => 2
+ * ```
+ */
 function Update(value, update) {
-  if (typeof update === "function") {
-    return update(value);
-  }
-  return update;
+    if (typeof update === 'function') {
+        return update(value);
+    }
+    return update;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Update
-});
+//# sourceMappingURL=update.cjs.map

package/dist/cjs/update.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.cjs","sourceRoot":"","sources":["../../_cjs_prepare/update.cts"],"names":[],"mappings":";;AAkBA,wBAKC;AAlBD;;;;;;;;;;;;GAYG;AACH,SAAgB,MAAM,CAAI,KAAQ,EAAE,MAAiB;IACnD,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;QACjC,OAAQ,MAA0B,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/esm/eq.d.mts

@@ -0,0 +1,196 @@
+/**
+ * A function returning true if given `v1` and `v2` should be considered equal.
+ */
+export type Eq<T> = (v1: T, v2: T) => boolean;
+export declare namespace Eq {
+    function convertAnyToString(value: any): string;
+    /**
+     * Returns the default Eq instance, which is the Eq.anyDeepEq() instance.
+     */
+    function defaultEq(): Eq<any>;
+    /**
+     * An Eq instance that uses `Object.is` to determine if two objects are equal.
+     * @example
+     * ```ts
+     * const eq = Eq.objectIs
+     * console.log(eq(5, 5))
+     * // => true
+     * console.log(eq(5, 'a'))
+     * // => false
+     * ```
+     */
+    const objectIs: Eq<any>;
+    /**
+     * Returns an Eq instance for objects that have a `valueOf` method. It returns true if the `.valueOf` values of both given objects are equal.
+     * @typeparam T - the object type containing a valueOf function of type V
+     * @typeparam V - the valueOf result type
+     * @example
+     * ```ts
+     * const eq = Eq.valueOfEq()
+     * console.log(eq(new Number(5), new Number(5)))
+     * // => true
+     * console.log(eq(new Number(5), new Number(3)))
+     * // => false
+     * ```
+     */
+    function valueOfEq<T extends {
+        valueOf(): V;
+    }, V>(): Eq<T>;
+    /**
+     * Returns an Eq instance that compares Date objects according to their `valueOf` value.
+     * @example
+     * ```ts
+     * const eq = Eq.dateEq()
+     * console.log(eq(new Date(2020, 1, 1), new Date(2020, 1, 1))
+     * // => true
+     * console.log(eq(new Date(2020, 1, 1), new Date(2020, 2, 1))
+     * // => false
+     * ```
+     */
+    function dateEq(): Eq<Date>;
+    /**
+     * Returns an Eq instance that compares Iterables by comparing their elements with the given `itemEq` Eq instance.
+     * @typeparam T - the Iterable element type
+     * @param itemEq - (optional) the Eq instance to use to compare the Iterable's elements
+     * @example
+     * ```ts
+     * const eq = Eq.iterableEq();
+     * console.log(eq([1, 2, 3], [1, 2, 3])
+     * // => true
+     * console.log(eq([1, 2, 3], [1, 3, 2])
+     * // => false
+     * ```
+     */
+    function iterableEq<T>(itemEq?: Eq<T>): Eq<Iterable<T>>;
+    /**
+     * Returns an Eq instance that checks equality of objects containing property values of type V by iteratively
+     * applying given `valueEq` to each of the object's property values.
+     * @typeparam - the object property value type
+     * @param valueEq - (optional) the Eq instance to use to compare property values
+     * @example
+     * ```ts
+     * const eq = Eq.objectEq()
+     * console.log(eq({ a: 1, b: { c: 2 }}, { b: { c: 2 }, a: 1 }))
+     * // => true
+     * console.log(eq({ a: 1, b: { c: 2 }}, { a: 1, b: { c: 3 }}))
+     * // => false
+     * ```
+     */
+    function objectEq<V = any>(valueEq?: Eq<V>): Eq<Record<any, V>>;
+    /**
+     * Returns an Eq instance that checks equality of any values. For composed values (objects and iterables)
+     * it will compare with Object.is.
+     * @typeparam T - the value type
+     * @example
+     * ```ts
+     * const eq = anyFlatEq()
+     * console.log(eq(1, 'a'))
+     * // => false
+     * console.log(eq({ a: 1, b: 2 }, { b: 2, a: 1 }))
+     * // => false
+     * ```
+     */
+    function anyFlatEq<T = any>(): Eq<T>;
+    /**
+     * Returns an Eq instance that checks equality of any values. For composed values (objects and iterables)
+     * it will enter 1 level, and if again compound values are found, they are compared
+     * with Object.is.
+     * @typeparam T - the value type
+     * @example
+     * ```ts
+     * const eq = anyFlatEq()
+     * console.log(eq(1, 'a'))
+     * // => false
+     * console.log(eq({ a: 1, b: 2 }, { b: 2, a: 1 }))
+     * // => true
+     * console.log(eq([{ a: 1, b: 2 }], [{ b: 2, a: 1 }]))
+     * // => false
+     * ```
+     */
+    function anyShallowEq<T = any>(): Eq<T>;
+    /**
+     * Returns an Eq instance that checks equality of any values. For composed values (objects and iterables)
+     * it will recursively compare the contained values.
+     * @note may have poor performance for deeply nested types and large arrays, and objects with circular structures
+     * may cause infinite loops
+     * @typeparam T - the value type
+     * @example
+     * ```ts
+     * const eq = anyFlatEq()
+     * console.log(eq(1, 'a'))
+     * // => false
+     * console.log(eq({ a: 1, b: 2 }, { b: 2, a: 1 }))
+     * // => true
+     * console.log(eq([{ a: 1, b: 2 }], [{ b: 2, a: 1 }]))
+     * // => false
+     * ```
+     */
+    function anyDeepEq<T = any>(): Eq<T>;
+    /**
+     * Returns an Eq instance that considers strings equal taking the given or default locale into account.
+     * @param locales - (optional) a locale or list of locales
+     * @param options - (optional) see String.localeCompare for details
+     * @example
+     * ```ts
+     * const eq = Eq.createStringCollatorEq()
+     * console.log(eq('a', 'a'))
+     * // => true
+     * console.log(eq('abc', 'aBc'))
+     * // => false
+     * ```
+     */
+    function createStringCollatorEq(...args: ConstructorParameters<typeof Intl.Collator>): Eq<string>;
+    /**
+     * Returns an Eq instance that considers strings equal regardless of their case.
+     * @example
+     * ```ts
+     * const eq = Eq.stringCaseInsentitiveEq()
+     * console.log(eq('aB', 'Ab'))
+     * // => true
+     * console.log(eq('aBc', 'abB'))
+     * // => false
+     * ```
+     */
+    function stringCaseInsentitiveEq(): Eq<string>;
+    /**
+     * Returns an Eq instance that considers strings equal when all their charcodes are equal.
+     * @example
+     * ```ts
+     * const eq = Eq.stringCharCodeEq()
+     * console.log(eq('a', 'a'))
+     * // => true
+     * console.log(eq('abc', 'aBc'))
+     * // => false
+     * ```
+     */
+    function stringCharCodeEq(): Eq<string>;
+    function anyToStringEq(): Eq<any>;
+    /**
+     * Returns an Eq instance that considers values equal their JSON.stringify values are equal.
+     * @example
+     * ```ts
+     * const eq = Eq.anyJsonEq()
+     * console.log(eq({ a: 1, b: 2 }, { a: 1, b: 2 }))
+     * // => true
+     * console.log(eq({ a: 1, b: 2 }, { b: 2, a: 1 }))
+     * // => false
+     * ```
+     */
+    function anyJsonEq(): Eq<any>;
+    /**
+     * Returns an `Eq` instance for tuples that considers two tuples [A, B] and [C, D] equal if [A, B] equals [C, D],
+     * or if [A, B] equals [D, C]
+     * @param eq - (optional) an alternative `Eq` instance to use for the values in the tuple
+     * @example
+     * ```ts
+     * const eq = Eq.tupleSymmetric()
+     * console.log(eq([1, 2], [1, 2]))
+     * // => true
+     * console.log(eq([1, 2], [2, 1]))
+     * // => true
+     * console.log(eq([1, 3], [2, 1]))
+     * // => false
+     * ```
+     */
+    function tupleSymmetric<T>(eq?: Eq<T>): Eq<readonly [T, T]>;
+}

package/dist/esm/err.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Throws an `Err.ForcedError` error when called.
+ * @example
+ * ```ts
+ * const emptyMap = HashMap.empty<number, string>()
+ * emptyMap.get(5, Err);
+ * // throws: Err.CustomError(message: 'Err: forced to throw error')
+ * ```
+ */
+export declare function Err(): never;
+export declare namespace ErrBase {
+    /**
+     * A custom error instance.
+     */
+    abstract class CustomError {
+        readonly message: string;
+        constructor(message: string);
+        get name(): string;
+    }
+    class ForcedError extends CustomError {
+    }
+    /**
+     * Returns a function that, when called, throws an `Err.ForcedError` with the given `message` string.
+     * @param message - the message to put in the `Err.ForcedError` instance.
+     * @example
+     * ```ts
+     * const emptyMap = HashMap.empty<number, string>()
+     * emptyMap.get(5, ErrBase.msg('not found'));
+     * // throws: Err.CustomError(message: 'not found')
+     * ```
+     */
+    function msg(message: string): () => never;
+}

package/dist/esm/optlazy.d.mts

@@ -0,0 +1,42 @@
+/**
+ * A potentially lazy value of type T.
+ * @typeparam T - the value type
+ * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
+ */
+export type OptLazy<T, A extends any[] = []> = T | ((...args: A) => T);
+/**
+ * Returns the value contained in an `OptLazy` instance of type T.
+ * @param optLazy - the `OptLazy` value of type T
+ * @param args - when needed, the extra arguments to pass to the lazy invocation
+ * @typeparam T - the value type
+ * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
+ * @example
+ * ```ts
+ * OptLazy(1)              // => 1
+ * OptLazy(() => 1)        // => 1
+ * OptLazy(() => () => 1)  // => () => 1
+ * ```
+ */
+export declare function OptLazy<T, A extends any[] = []>(optLazy: OptLazy<T, A>, ...args: A): T;
+/**
+ * A potentially lazy value that, in case of a lazy function, received a default value
+ * that it can return.
+ * @typeparam T - the value type
+ * @typeparam O - the default value type
+ */
+export type OptLazyOr<T, O> = T | ((none: O) => T | O);
+/**
+ * Returns the value contained in an `OptLazyOr` instance of type T, or the given
+ * `otherValue` if the lazy function returns it.
+ * @param optLazyOr - a value or a function returning a value or otherwise the received value
+ * @param otherValue - the value to return if the optLazyOr does not return its own value
+ * @typeparam T - the value type
+ * @typeparam O - the default value type
+ * @example
+ * ```ts
+ * OptLazyOr(1, 'a')               // => 1
+ * OptLazyOr(() => 1, 'a')         // => 1
+ * OptLazyOr((none) => none, 'a')  // => 'a'
+ * ```
+ */
+export declare function OptLazyOr<T, O>(optLazyOr: OptLazyOr<T, O>, otherValue: O): T | O;