@rimbu/common 2.0.0 → 2.0.2

package/dist/cjs/comp.cjs

@@ -1,731 +1,542 @@
 "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/comp.mts
-var comp_exports = {};
-__export(comp_exports, {
-  Comp: () => Comp
-});
-module.exports = __toCommonJS(comp_exports);
-
-// src/collect.mts
-var CollectFun;
-((CollectFun2) => {
-  CollectFun2.Skip = Symbol("Skip");
-})(CollectFun || (CollectFun = {}));
-
-// src/eq.mts
-var Eq;
-((Eq2) => {
-  function convertAnyToString(value) {
-    if (typeof value !== "object" || null === value || !("toString" in value) || typeof value.toString !== "function" || value.toString !== Object.prototype.toString) {
-      return String(value);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Comp = void 0;
+var tslib_1 = require("tslib");
+var internal_cjs_1 = require("./internal.cjs");
+var Comp;
+(function (Comp) {
+    var _anyFlatComp = createAnyComp('FLAT');
+    var _anyShallowComp = createAnyComp('SHALLOW');
+    var _anyDeepComp = createAnyComp('DEEP');
+    /**
+     * Returns the default Comp instance, which is the Comp.anyDeepComp() instance.
+     */
+    function defaultComp() {
+        return _anyDeepComp;
     }
-    return JSON.stringify(value);
-  }
-  Eq2.convertAnyToString = convertAnyToString;
-  const _anyFlatEq = createAnyEq("FLAT");
-  const _anyShallowEq = createAnyEq("SHALLOW");
-  const _anyDeepEq = createAnyEq("DEEP");
-  function defaultEq() {
-    return _anyDeepEq;
-  }
-  Eq2.defaultEq = defaultEq;
-  Eq2.objectIs = Object.is;
-  const _valueOfEq = (v1, v2) => Object.is(v1.valueOf(), v2.valueOf());
-  function valueOfEq() {
-    return _valueOfEq;
-  }
-  Eq2.valueOfEq = valueOfEq;
-  function dateEq() {
-    return _valueOfEq;
-  }
-  Eq2.dateEq = dateEq;
-  function createIterableEq(itemEq) {
-    return (v1, v2) => {
-      if (Object.is(v1, v2))
-        return true;
-      const iter1 = v1[Symbol.iterator]();
-      const iter2 = v2[Symbol.iterator]();
-      while (true) {
-        const value1 = iter1.next();
-        const value2 = iter2.next();
-        if (value1.done || value2.done)
-          return value1.done === value2.done;
-        if (!itemEq(value1.value, value2.value))
-          return false;
-      }
-    };
-  }
-  const _iterableAnyEq = createIterableEq(defaultEq());
-  function iterableEq(itemEq) {
-    if (void 0 === itemEq)
-      return _iterableAnyEq;
-    return createIterableEq(itemEq);
-  }
-  Eq2.iterableEq = iterableEq;
-  function createObjectEq(valueEq) {
-    return (v1, v2) => {
-      if (Object.is(v1, v2))
-        return true;
-      if (v1.constructor !== v2.constructor)
-        return false;
-      for (const key in v1) {
-        if (!(key in v2))
-          return false;
-      }
-      for (const key in v2) {
-        if (!(key in v1))
-          return false;
-      }
-      for (const key in v1) {
-        const value1 = v1[key];
-        const value2 = v2[key];
-        if (!valueEq(value1, value2))
-          return false;
-      }
-      return true;
-    };
-  }
-  const _objectEq = createObjectEq(defaultEq());
-  function objectEq(valueEq) {
-    if (void 0 === valueEq)
-      return _objectEq;
-    return createObjectEq(valueEq);
-  }
-  Eq2.objectEq = objectEq;
-  function createAnyEq(mode) {
-    const result = (v1, v2) => {
-      if (Object.is(v1, v2))
-        return true;
-      const type1 = typeof v1;
-      const type2 = typeof v2;
-      if (type1 !== type2)
-        return false;
-      switch (type1) {
-        case "undefined":
-        case "bigint":
-        case "boolean":
-        case "number":
-        case "string":
-        case "symbol":
-        case "function":
-          return Object.is(v1, v2);
-        case "object": {
-          if (v1 === null || v2 === null)
-            return false;
-          if (v1.constructor !== v2.constructor) {
-            return false;
-          }
-          if (v1 instanceof Boolean || v1 instanceof Date || v1 instanceof Number || v1 instanceof String) {
-            return _valueOfEq(v1, v2);
-          }
-          if (mode !== "FLAT") {
-            if (Symbol.iterator in v1 && Symbol.iterator in v2) {
-              if (mode === "SHALLOW") {
-                return createIterableEq(_anyFlatEq)(v1, v2);
-              }
-              return createIterableEq(result)(v1, v2);
+    Comp.defaultComp = defaultComp;
+    var _numberComp = {
+        isComparable: function (obj) {
+            return typeof obj === 'number';
+        },
+        compare: function (v1, v2) {
+            if (Number.isFinite(v1) && Number.isFinite(v2)) {
+                return v1 - v2;
             }
-            if (mode === "SHALLOW") {
-              return createObjectEq(_anyFlatEq)(v1, v2);
+            if (Number.isNaN(v1)) {
+                if (Number.isNaN(v2))
+                    return 0;
+                if (v2 === Number.POSITIVE_INFINITY)
+                    return 1;
+                if (v2 === Number.NEGATIVE_INFINITY)
+                    return -1;
+                return -1;
             }
-            return _objectEq(v1, v2);
-          }
-          return false;
-        }
-      }
+            // only infinities remain
+            if (v1 === Number.POSITIVE_INFINITY) {
+                return v2 === Number.POSITIVE_INFINITY ? 0 : 1;
+            }
+            // v1 === Number.NEGATIVE_INFINITY
+            return v2 === Number.NEGATIVE_INFINITY ? 0 : -1;
+        },
     };
-    return result;
-  }
-  function anyFlatEq() {
-    return _anyFlatEq;
-  }
-  Eq2.anyFlatEq = anyFlatEq;
-  function anyShallowEq() {
-    return _anyShallowEq;
-  }
-  Eq2.anyShallowEq = anyShallowEq;
-  function anyDeepEq() {
-    return _anyDeepEq;
-  }
-  Eq2.anyDeepEq = anyDeepEq;
-  const _defaultCollator = Intl.Collator("und");
-  const _defaultStringCollatorEq = (v1, v2) => _defaultCollator.compare(v1, v2) === 0;
-  function createStringCollatorEq(...args) {
-    if (args.length === 0)
-      return _defaultStringCollatorEq;
-    const collator = Intl.Collator(...args);
-    return (v1, v2) => collator.compare(v1, v2) === 0;
-  }
-  Eq2.createStringCollatorEq = createStringCollatorEq;
-  const _stringCaseInsensitiveEq = createStringCollatorEq("und", {
-    sensitivity: "accent"
-  });
-  function stringCaseInsentitiveEq() {
-    return _stringCaseInsensitiveEq;
-  }
-  Eq2.stringCaseInsentitiveEq = stringCaseInsentitiveEq;
-  const _stringCharCodeEq = (v1, v2) => {
-    const len = v1.length;
-    if (len !== v2.length)
-      return false;
-    let i = -1;
-    while (++i < len) {
-      if (v1.charCodeAt(i) !== v2.charCodeAt(i))
-        return false;
+    /**
+     * Returns a default number Comp instance that orders numbers naturally.
+     * @example
+     * ```ts
+     * const c = Comp.numberComp();
+     * console.log(c.compare(3, 5))
+     * // => -2
+     * ```
+     */
+    function numberComp() {
+        return _numberComp;
     }
-    return true;
-  };
-  function stringCharCodeEq() {
-    return _stringCharCodeEq;
-  }
-  Eq2.stringCharCodeEq = stringCharCodeEq;
-  const _anyToStringEq = (v1, v2) => convertAnyToString(v1) === convertAnyToString(v2);
-  function anyToStringEq() {
-    return _anyToStringEq;
-  }
-  Eq2.anyToStringEq = anyToStringEq;
-  const _anyJsonEq = (v1, v2) => JSON.stringify(v1) === JSON.stringify(v2);
-  function anyJsonEq() {
-    return _anyJsonEq;
-  }
-  Eq2.anyJsonEq = anyJsonEq;
-  function tupleSymmetric(eq = defaultEq()) {
-    return (tup1, tup2) => eq(tup1[0], tup2[0]) && eq(tup1[1], tup2[1]) || eq(tup1[0], tup2[1]) && eq(tup1[1], tup2[0]);
-  }
-  Eq2.tupleSymmetric = tupleSymmetric;
-})(Eq || (Eq = {}));
-
-// src/err.mts
-var ErrBase;
-((ErrBase2) => {
-  class CustomError {
-    constructor(message) {
-      this.message = message;
+    Comp.numberComp = numberComp;
+    var _booleanComp = {
+        isComparable: function (obj) {
+            return typeof obj === 'boolean';
+        },
+        compare: function (v1, v2) {
+            return v1 === v2 ? 0 : v1 ? 1 : -1;
+        },
+    };
+    /**
+     * Returns a default boolean Comp instance that orders booleans according to false < true.
+     * @example
+     * ```ts
+     * const c = Comp.booleanComp();
+     * console.log(c.compare(false, true) < 0)
+     * // => true
+     * console.log(c.compare(true, true))
+     * // => 0
+     * ```
+     */
+    function booleanComp() {
+        return _booleanComp;
     }
-    get name() {
-      return this.constructor.name;
+    Comp.booleanComp = booleanComp;
+    var _bigIntComp = {
+        isComparable: function (obj) {
+            return typeof obj === 'bigint';
+        },
+        compare: function (v1, v2) {
+            var res = v1 - v2;
+            if (res > 0)
+                return 1;
+            if (res < 0)
+                return -1;
+            return 0;
+        },
+    };
+    /**
+     * Returns a default bigint Comp instance that orders bigint numbers naturally.
+     */
+    function bigIntComp() {
+        return _bigIntComp;
     }
-  }
-  ErrBase2.CustomError = CustomError;
-  class ForcedError extends CustomError {
-  }
-  ErrBase2.ForcedError = ForcedError;
-  function msg(message) {
-    return function() {
-      throw new ErrBase2.ForcedError(message);
+    Comp.bigIntComp = bigIntComp;
+    var _defaultCollator = Intl.Collator('und');
+    var _stringComp = {
+        isComparable: function (obj) {
+            return typeof obj === 'string';
+        },
+        compare: _defaultCollator.compare,
+    };
+    var _anyStringJSONComp = {
+        isComparable: function (obj) {
+            return true;
+        },
+        compare: function (v1, v2) {
+            return _defaultCollator.compare(JSON.stringify(v1), JSON.stringify(v2));
+        },
     };
-  }
-  ErrBase2.msg = msg;
-})(ErrBase || (ErrBase = {}));
-
-// src/index-range.mts
-var IndexRange;
-((IndexRange2) => {
-  function getIndexRangeIndices(range) {
-    if (void 0 !== range.amount) {
-      if (void 0 === range.start)
-        return [0, range.amount - 1];
-      if (Array.isArray(range.start)) {
-        const [start2, includeStart] = range.start;
-        if (includeStart)
-          return [start2, start2 + range.amount - 1];
-        return [start2 + 1, start2 + 1 + range.amount - 1];
-      }
-      return [range.start, range.start + range.amount - 1];
+    /**
+     * Returns a Comp instance converts values to string with JSON.stringify, and orders the resulting string naturally.
+     */
+    function anyStringJSONComp() {
+        return _anyStringJSONComp;
     }
-    let start = 0;
-    let end = void 0;
-    if (`start` in range) {
-      if (Array.isArray(range.start)) {
-        if (range.start[1])
-          start = range.start[0];
-        else
-          start = range.start[0] + 1;
-      } else
-        start = range.start ?? 0;
+    Comp.anyStringJSONComp = anyStringJSONComp;
+    /**
+     * Returns a `Comp` instance that compares strings based on the string's `localeCompare` method.
+     * @param locales - (optional) a locale or list of locales
+     * @param options - (optional) see String.localeCompare for details
+     */
+    function stringComp() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (args.length === 0)
+            return _stringComp;
+        var collator = Intl.Collator.apply(Intl, tslib_1.__spreadArray([], tslib_1.__read(args), false));
+        return {
+            isComparable: function (obj) {
+                return typeof obj === 'string';
+            },
+            compare: collator.compare,
+        };
     }
-    if (`end` in range) {
-      if (Array.isArray(range.end)) {
-        if (range.end[1])
-          end = range.end[0];
-        else
-          end = range.end[0] - 1;
-      } else
-        end = range.end;
+    Comp.stringComp = stringComp;
+    /**
+     * Returns a `Comp` instance that compares strings in a case-insensitive way.
+     */
+    function stringCaseInsensitiveComp() {
+        return stringComp('und', { sensitivity: 'accent' });
     }
-    return [start, end];
-  }
-  IndexRange2.getIndexRangeIndices = getIndexRangeIndices;
-  function getIndicesFor(range, length) {
-    if (length <= 0)
-      return "empty";
-    let start = 0;
-    let end = length - 1;
-    if (void 0 !== range.start) {
-      if (Array.isArray(range.start)) {
-        start = range.start[0];
-        if (!range.start[1])
-          start++;
-      } else
-        start = range.start;
-      if (start >= length || -start > length)
-        return "empty";
-      if (start < 0)
-        start = length + start;
+    Comp.stringCaseInsensitiveComp = stringCaseInsensitiveComp;
+    var _stringCharCodeComp = {
+        isComparable: function (obj) {
+            return typeof obj === 'string';
+        },
+        compare: function (v1, v2) {
+            var len = Math.min(v1.length, v2.length);
+            var i = -1;
+            while (++i < len) {
+                var diff = v1.charCodeAt(i) - v2.charCodeAt(i);
+                if (diff !== 0)
+                    return diff;
+            }
+            return v1.length - v2.length;
+        },
+    };
+    /**
+     * Returns a string Comp instance that orders strings according to their indexed char codes.
+     */
+    function stringCharCodeComp() {
+        return _stringCharCodeComp;
     }
-    if (void 0 !== range.amount) {
-      if (range.amount <= 0)
-        return "empty";
-      if (void 0 === range.start) {
-        if (range.amount >= length)
-          return "all";
-        return [0, Math.min(end, range.amount - 1)];
-      }
-      end = start + range.amount - 1;
-    } else if (void 0 !== range.end) {
-      if (Array.isArray(range.end)) {
-        end = range.end[0];
-        if (!range.end[1]) {
-          if (end === 0)
-            return "empty";
-          end--;
-        }
-      } else
-        end = range.end;
-      if (end < 0)
-        end = length + end;
+    Comp.stringCharCodeComp = stringCharCodeComp;
+    var _anyToStringComp = {
+        isComparable: function (obj) {
+            return true;
+        },
+        compare: function (v1, v2) {
+            return _defaultCollator.compare(internal_cjs_1.Eq.convertAnyToString(v1), internal_cjs_1.Eq.convertAnyToString(v2));
+        },
+    };
+    /**
+     * Returns a any Comp instance that orders any according to their toString values.
+     */
+    function anyToStringComp() {
+        return _anyToStringComp;
     }
-    if (end < start)
-      return "empty";
-    end = Math.min(length - 1, end);
-    if (start === 0 && end === length - 1)
-      return "all";
-    return [start, end];
-  }
-  IndexRange2.getIndicesFor = getIndicesFor;
-})(IndexRange || (IndexRange = {}));
-
-// src/range.mts
-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];
-      }
+    Comp.anyToStringComp = anyToStringComp;
+    /**
+     * Returns a Comp instance that orders objects with a `valueOf` method according to the given `valueComp` instance for the valueOf values.
+     * @param cls - the constructor of the values the Comp instance can compare
+     * @param valueComp - (optional) the Comp instance to use on the .valueOf values
+     */
+    function createValueOfComp(cls, valueComp) {
+        if (valueComp === void 0) { valueComp = anyShallowComp(); }
+        return {
+            isComparable: function (obj) {
+                return obj instanceof cls;
+            },
+            compare: function (v1, v2) {
+                return valueComp.compare(v1.valueOf(), v2.valueOf());
+            },
+        };
     }
-    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];
-      }
+    Comp.createValueOfComp = createValueOfComp;
+    var _DateComp = createValueOfComp(Date, _numberComp);
+    /**
+     * Returns a Date Comp instance that orders Dates according to their `.valueOf` value.
+     */
+    function dateComp() {
+        return _DateComp;
     }
-    return { start, end };
-  }
-  Range2.getNormalizedRange = getNormalizedRange;
-})(Range || (Range = {}));
-
-// src/async-optlazy.mts
-var AsyncOptLazy;
-((AsyncOptLazy2) => {
-  function toMaybePromise(optLazy, ...args) {
-    if (optLazy instanceof Function)
-      return optLazy(...args);
-    return optLazy;
-  }
-  AsyncOptLazy2.toMaybePromise = toMaybePromise;
-  async function toPromise(optLazy, ...args) {
-    if (optLazy instanceof Function)
-      return optLazy(...args);
-    return optLazy;
-  }
-  AsyncOptLazy2.toPromise = toPromise;
-})(AsyncOptLazy || (AsyncOptLazy = {}));
-
-// src/comp.mts
-var Comp;
-((Comp2) => {
-  const _anyFlatComp = createAnyComp("FLAT");
-  const _anyShallowComp = createAnyComp("SHALLOW");
-  const _anyDeepComp = createAnyComp("DEEP");
-  function defaultComp() {
-    return _anyDeepComp;
-  }
-  Comp2.defaultComp = defaultComp;
-  const _numberComp = {
-    isComparable(obj) {
-      return typeof obj === "number";
-    },
-    compare(v1, v2) {
-      if (Number.isFinite(v1) && Number.isFinite(v2)) {
-        return v1 - v2;
-      }
-      if (Number.isNaN(v1)) {
-        if (Number.isNaN(v2))
-          return 0;
-        if (v2 === Number.POSITIVE_INFINITY)
-          return 1;
-        if (v2 === Number.NEGATIVE_INFINITY)
-          return -1;
-        return -1;
-      }
-      if (v1 === Number.POSITIVE_INFINITY) {
-        return v2 === Number.POSITIVE_INFINITY ? 0 : 1;
-      }
-      return v2 === Number.NEGATIVE_INFINITY ? 0 : -1;
+    Comp.dateComp = dateComp;
+    function createIterableComp(itemComp) {
+        return {
+            isComparable: function (obj) {
+                // unfortunately we cannot check element compatability
+                return (typeof obj === 'object' && obj !== null && Symbol.iterator in obj);
+            },
+            compare: function (v1, v2) {
+                var iter1 = v1[Symbol.iterator]();
+                var iter2 = v2[Symbol.iterator]();
+                while (true) {
+                    var value1 = iter1.next();
+                    var value2 = iter2.next();
+                    if (value1.done)
+                        return value2.done ? 0 : -1;
+                    if (value2.done)
+                        return 1;
+                    var result = itemComp.compare(value1.value, value2.value);
+                    if (result !== 0)
+                        return result;
+                }
+            },
+        };
     }
-  };
-  function numberComp() {
-    return _numberComp;
-  }
-  Comp2.numberComp = numberComp;
-  const _booleanComp = {
-    isComparable(obj) {
-      return typeof obj === "boolean";
-    },
-    compare(v1, v2) {
-      return v1 === v2 ? 0 : v1 ? 1 : -1;
+    var _iterableAnyComp = createIterableComp(Comp.defaultComp());
+    /**
+     * Returns a Comp instance for Iterable objects that orders the Iterables by comparing the elements with the given `itemComp` Comp instance.
+     * @param itemComp - (optional) the Comp instance to use to compare the Iterable's elements.
+     * @example
+     * ```ts
+     * const c = Comp.iterableComp();
+     * console.log(c.compare([1, 3, 2], [1, 3, 2]))
+     * // => 0
+     * console.log(c.compare([1, 2, 3, 4], [1, 3, 2]) < 0)
+     * // => true
+     * ```
+     */
+    function iterableComp(itemComp) {
+        if (undefined === itemComp)
+            return _iterableAnyComp;
+        return createIterableComp(itemComp);
     }
-  };
-  function booleanComp() {
-    return _booleanComp;
-  }
-  Comp2.booleanComp = booleanComp;
-  const _bigIntComp = {
-    isComparable(obj) {
-      return typeof obj === "bigint";
-    },
-    compare(v1, v2) {
-      const res = v1 - v2;
-      if (res > 0)
-        return 1;
-      if (res < 0)
-        return -1;
-      return 0;
+    Comp.iterableComp = iterableComp;
+    var _BooleanComp = createValueOfComp(Boolean, _booleanComp);
+    var _NumberComp = createValueOfComp(Number, _numberComp);
+    var _StringComp = createValueOfComp(String, _stringComp);
+    var _wrappedComps = [
+        _BooleanComp,
+        _DateComp,
+        _NumberComp,
+        _StringComp,
+    ];
+    function tryWrappedComp(v1, v2) {
+        var i = -1;
+        var len = _wrappedComps.length;
+        while (++i < len) {
+            var comp = _wrappedComps[i];
+            if (comp.isComparable(v1) && comp.isComparable(v2)) {
+                return comp.compare(v1, v2);
+            }
+        }
+        return undefined;
     }
-  };
-  function bigIntComp() {
-    return _bigIntComp;
-  }
-  Comp2.bigIntComp = bigIntComp;
-  const _defaultCollator = Intl.Collator("und");
-  const _stringComp = {
-    isComparable(obj) {
-      return typeof obj === "string";
-    },
-    compare: _defaultCollator.compare
-  };
-  const _anyStringJSONComp = {
-    isComparable(obj) {
-      return true;
-    },
-    compare(v1, v2) {
-      return _defaultCollator.compare(JSON.stringify(v1), JSON.stringify(v2));
+    function createObjectComp(keyComp, valueComp) {
+        if (keyComp === void 0) { keyComp = anyFlatComp(); }
+        if (valueComp === void 0) { valueComp = defaultComp(); }
+        return {
+            isComparable: function (obj) {
+                return true;
+            },
+            compare: function (v1, v2) {
+                var keys1 = Object.keys(v1);
+                var keys2 = Object.keys(v2);
+                if (keys1.length === 0) {
+                    return keys2.length === 0 ? 0 : -1;
+                }
+                if (keys2.length === 0) {
+                    return keys1.length === 0 ? 0 : 1;
+                }
+                keys1.sort(keyComp.compare);
+                keys2.sort(keyComp.compare);
+                var length = Math.min(keys1.length, keys2.length);
+                for (var index = 0; index < length; index++) {
+                    var key1 = keys1[index];
+                    var key2 = keys2[index];
+                    var keyResult = keyComp.compare(key1, key2);
+                    if (keyResult !== 0)
+                        return keyResult;
+                    var value1 = v1[key1];
+                    var value2 = v2[key2];
+                    var valueResult = valueComp.compare(value1, value2);
+                    if (valueResult !== 0)
+                        return valueResult;
+                }
+                var keyDiff = keys1.length - keys2.length;
+                return keyDiff;
+            },
+        };
     }
-  };
-  function anyStringJSONComp() {
-    return _anyStringJSONComp;
-  }
-  Comp2.anyStringJSONComp = anyStringJSONComp;
-  function stringComp(...args) {
-    if (args.length === 0)
-      return _stringComp;
-    const collator = Intl.Collator(...args);
-    return {
-      isComparable(obj) {
-        return typeof obj === "string";
-      },
-      compare: collator.compare
-    };
-  }
-  Comp2.stringComp = stringComp;
-  function stringCaseInsensitiveComp() {
-    return stringComp("und", { sensitivity: "accent" });
-  }
-  Comp2.stringCaseInsensitiveComp = stringCaseInsensitiveComp;
-  const _stringCharCodeComp = {
-    isComparable(obj) {
-      return typeof obj === "string";
-    },
-    compare(v1, v2) {
-      const len = Math.min(v1.length, v2.length);
-      let i = -1;
-      while (++i < len) {
-        const diff = v1.charCodeAt(i) - v2.charCodeAt(i);
-        if (diff !== 0)
-          return diff;
-      }
-      return v1.length - v2.length;
+    var _objectAnyComp = createObjectComp();
+    /**
+     * Returns a Comp instance for objects that orders the object keys according to the given `keyComp`, and then compares the corresponding
+     * values using the given `valueComp`. Objects are then compared as follows:<br/>
+     * starting with the smallest key of either object:<br/>
+     * - if only one of the objects has the key, the object with the key is considered to be larger than the other<br/>
+     * - if both objects have the key, the values are compared with `valueComp`. If the values are not equal, this result is returned.<br/>
+     *
+     * if the objects have the same keys with the same values, they are considered equal<br/>
+     * @param keyComp - (optional) the Comp instance used to order the object keys
+     * @param valueComp - (optional) the Comp instance used to order the object values
+     * @example
+     * ```ts
+     * const c = Comp.objectComp();
+     * console.log(c.compare({ a: 1 }, { a: 1 }))
+     * // => 0
+     * console.log(c.compare({ a: 1 }, { a: 2 }) < 0)
+     * // => true
+     * console.log(c.compare({ b: 5 }, { a: 2 }) < 0)
+     * // => true
+     * console.log(c.compare({ a: 1, b: 2 }, { b: 5 }) < 0)
+     * // => true
+     * console.log(c.compare({ a: 1, b: 2 }, { b: 2, a: 1 }))
+     * // => 0
+     * ```
+     */
+    function objectComp(options) {
+        if (undefined === options)
+            return _objectAnyComp;
+        return createObjectComp(options.keyComp, options.valueComp);
     }
-  };
-  function stringCharCodeComp() {
-    return _stringCharCodeComp;
-  }
-  Comp2.stringCharCodeComp = stringCharCodeComp;
-  const _anyToStringComp = {
-    isComparable(obj) {
-      return true;
-    },
-    compare(v1, v2) {
-      return _defaultCollator.compare(
-        Eq.convertAnyToString(v1),
-        Eq.convertAnyToString(v2)
-      );
+    Comp.objectComp = objectComp;
+    function createAnyComp(mode) {
+        return {
+            isComparable: function (obj) {
+                return true;
+            },
+            compare: function (v1, v2) {
+                if (Object.is(v1, v2))
+                    return 0;
+                var type1 = typeof v1;
+                var type2 = typeof v2;
+                if (type1 !== type2) {
+                    // we can only compare different types though strings
+                    return _anyToStringComp.compare(v1, v2);
+                }
+                switch (type1) {
+                    case 'bigint':
+                        return _bigIntComp.compare(v1, v2);
+                    case 'boolean':
+                        return _booleanComp.compare(v1, v2);
+                    case 'number':
+                        return _numberComp.compare(v1, v2);
+                    case 'string':
+                        return _stringComp.compare(v1, v2);
+                    case 'object': {
+                        if (null === v1) {
+                            if (null === v2)
+                                return 0;
+                            return -1;
+                        }
+                        if (null === v2) {
+                            return 1;
+                        }
+                        var wrappedComp = tryWrappedComp(v1, v2);
+                        if (undefined !== wrappedComp)
+                            return wrappedComp;
+                        if (mode !== 'FLAT') {
+                            if (_iterableAnyComp.isComparable(v1) &&
+                                _iterableAnyComp.isComparable(v2)) {
+                                if (mode === 'SHALLOW') {
+                                    return iterableComp(_anyFlatComp).compare(v1, v2);
+                                }
+                                return iterableComp(this).compare(v1, v2);
+                            }
+                            if (mode === 'SHALLOW') {
+                                return createObjectComp(_anyFlatComp, _anyFlatComp).compare(v1, v2);
+                            }
+                            return _objectAnyComp.compare(v1, v2);
+                        }
+                    }
+                }
+                return _anyToStringComp.compare(v1, v2);
+            },
+        };
     }
-  };
-  function anyToStringComp() {
-    return _anyToStringComp;
-  }
-  Comp2.anyToStringComp = anyToStringComp;
-  function createValueOfComp(cls, valueComp = anyShallowComp()) {
-    return {
-      isComparable(obj) {
-        return obj instanceof cls;
-      },
-      compare(v1, v2) {
-        return valueComp.compare(v1.valueOf(), v2.valueOf());
-      }
-    };
-  }
-  Comp2.createValueOfComp = createValueOfComp;
-  const _DateComp = createValueOfComp(Date, _numberComp);
-  function dateComp() {
-    return _DateComp;
-  }
-  Comp2.dateComp = dateComp;
-  function createIterableComp(itemComp) {
-    return {
-      isComparable(obj) {
-        return typeof obj === "object" && obj !== null && Symbol.iterator in obj;
-      },
-      compare(v1, v2) {
-        const iter1 = v1[Symbol.iterator]();
-        const iter2 = v2[Symbol.iterator]();
-        while (true) {
-          const value1 = iter1.next();
-          const value2 = iter2.next();
-          if (value1.done)
-            return value2.done ? 0 : -1;
-          if (value2.done)
-            return 1;
-          const result = itemComp.compare(value1.value, value2.value);
-          if (result !== 0)
-            return result;
-        }
-      }
-    };
-  }
-  const _iterableAnyComp = createIterableComp(
-    Comp2.defaultComp()
-  );
-  function iterableComp(itemComp) {
-    if (void 0 === itemComp)
-      return _iterableAnyComp;
-    return createIterableComp(itemComp);
-  }
-  Comp2.iterableComp = iterableComp;
-  const _BooleanComp = createValueOfComp(Boolean, _booleanComp);
-  const _NumberComp = createValueOfComp(Number, _numberComp);
-  const _StringComp = createValueOfComp(String, _stringComp);
-  const _wrappedComps = [
-    _BooleanComp,
-    _DateComp,
-    _NumberComp,
-    _StringComp
-  ];
-  function tryWrappedComp(v1, v2) {
-    let i = -1;
-    const len = _wrappedComps.length;
-    while (++i < len) {
-      const comp = _wrappedComps[i];
-      if (comp.isComparable(v1) && comp.isComparable(v2)) {
-        return comp.compare(v1, v2);
-      }
+    /**
+     * Returns a Comp instance that compares any value using default comparison functions, but never recursively compares
+     * Iterables or objects. In those cases, it will use the stringComp instance.
+     * @example
+     * ```ts
+     * const c = Comp.anyFlatComp();
+     * console.log(c.compare({ a: 1, b: 1 }, { b: 1, a: 1 }) < 0)
+     * // => true
+     * // First object is smaller because the objects are converted to a string with and then compares the resulting string.
+     * ```
+     */
+    function anyFlatComp() {
+        return _anyFlatComp;
     }
-    return void 0;
-  }
-  function createObjectComp(keyComp = anyFlatComp(), valueComp = defaultComp()) {
-    return {
-      isComparable(obj) {
-        return true;
-      },
-      compare(v1, v2) {
-        const keys1 = Object.keys(v1);
-        const keys2 = Object.keys(v2);
-        if (keys1.length === 0) {
-          return keys2.length === 0 ? 0 : -1;
-        }
-        if (keys2.length === 0) {
-          return keys1.length === 0 ? 0 : 1;
-        }
-        keys1.sort(keyComp.compare);
-        keys2.sort(keyComp.compare);
-        const length = Math.min(keys1.length, keys2.length);
-        for (let index = 0; index < length; index++) {
-          const key1 = keys1[index];
-          const key2 = keys2[index];
-          const keyResult = keyComp.compare(key1, key2);
-          if (keyResult !== 0)
-            return keyResult;
-          const value1 = v1[key1];
-          const value2 = v2[key2];
-          const valueResult = valueComp.compare(value1, value2);
-          if (valueResult !== 0)
-            return valueResult;
-        }
-        const keyDiff = keys1.length - keys2.length;
-        return keyDiff;
-      }
-    };
-  }
-  const _objectAnyComp = createObjectComp();
-  function objectComp(options) {
-    if (void 0 === options)
-      return _objectAnyComp;
-    return createObjectComp(options.keyComp, options.valueComp);
-  }
-  Comp2.objectComp = objectComp;
-  function createAnyComp(mode) {
-    return {
-      isComparable(obj) {
-        return true;
-      },
-      compare(v1, v2) {
-        if (Object.is(v1, v2))
-          return 0;
-        const type1 = typeof v1;
-        const type2 = typeof v2;
-        if (type1 !== type2) {
-          return _anyToStringComp.compare(v1, v2);
-        }
-        switch (type1) {
-          case "bigint":
-            return _bigIntComp.compare(v1, v2);
-          case "boolean":
-            return _booleanComp.compare(v1, v2);
-          case "number":
-            return _numberComp.compare(v1, v2);
-          case "string":
-            return _stringComp.compare(v1, v2);
-          case "object": {
-            if (null === v1) {
-              if (null === v2)
-                return 0;
-              return -1;
-            }
-            if (null === v2) {
-              return 1;
-            }
-            const wrappedComp = tryWrappedComp(v1, v2);
-            if (void 0 !== wrappedComp)
-              return wrappedComp;
-            if (mode !== "FLAT") {
-              if (_iterableAnyComp.isComparable(v1) && _iterableAnyComp.isComparable(v2)) {
-                if (mode === "SHALLOW") {
-                  return iterableComp(_anyFlatComp).compare(v1, v2);
+    Comp.anyFlatComp = anyFlatComp;
+    /**
+     * Returns a Comp instance that compares any value using default comparison functions. For Iterables and objects, their elements are compared
+     * only one level deep for performance and to avoid infinite recursion.
+     * @example
+     * ```ts
+     * const c = Comp.anyShallowComp();
+     * console.log(c.compare({ a: 1, b: 1 }, { b: 1, a: 1 }))
+     * // => 0
+     * console.log(c.compare([{ a: 1, b: 1 }], [{ b: 1, a: 1 }]) < 0)
+     * // => true
+     * // First object is smaller because the objects are converted to a string and then compares the resulting string.
+     * ```
+     */
+    function anyShallowComp() {
+        return _anyShallowComp;
+    }
+    Comp.anyShallowComp = anyShallowComp;
+    /**
+     * Returns a Comp instance that compares any value using default comparison functions. For Iterables and objects, their elements are compared
+     * recursively.
+     * @note can become slow with large nested arrays and objects, and circular structures can cause infinite loops
+     * @example
+     * ```ts
+     * const c = Comp.anyDeepComp();
+     * console.log(c.compare({ a: 1, b: 1 }, { b: 1, a: 1 }))
+     * // => 0
+     * console.log(c.compare([{ a: 1, b: 1 }], [{ b: 1, a: 1 }]))
+     * // => 0
+     * ```
+     */
+    function anyDeepComp() {
+        return _anyDeepComp;
+    }
+    Comp.anyDeepComp = anyDeepComp;
+    /**
+     * Returns a Comp instance that extends the given `comp` instance with the capability to handle `undefined` values, where undefined is considered to be smaller
+     * than any other value, and equal to another undefined.
+     * @param comp - the Comp instance to wrap
+     * @example
+     * ```ts
+     * const c = Comp.withUndefined(Comp.numberComp())
+     * console.log(c.compare(undefined, 5) < 0)
+     * // => true
+     * console.log(c.compare(undefined, undefined))
+     * // => 0
+     * ```
+     */
+    function withUndefined(comp) {
+        return {
+            isComparable: function (obj) {
+                return undefined === obj || comp.isComparable(obj);
+            },
+            compare: function (v1, v2) {
+                if (undefined === v1) {
+                    if (undefined === v2)
+                        return 0;
+                    return -1;
                 }
-                return iterableComp(this).compare(v1, v2);
-              }
-              if (mode === "SHALLOW") {
-                return createObjectComp(_anyFlatComp, _anyFlatComp).compare(
-                  v1,
-                  v2
-                );
-              }
-              return _objectAnyComp.compare(v1, v2);
-            }
-          }
-        }
-        return _anyToStringComp.compare(v1, v2);
-      }
-    };
-  }
-  function anyFlatComp() {
-    return _anyFlatComp;
-  }
-  Comp2.anyFlatComp = anyFlatComp;
-  function anyShallowComp() {
-    return _anyShallowComp;
-  }
-  Comp2.anyShallowComp = anyShallowComp;
-  function anyDeepComp() {
-    return _anyDeepComp;
-  }
-  Comp2.anyDeepComp = anyDeepComp;
-  function withUndefined(comp) {
-    return {
-      isComparable(obj) {
-        return void 0 === obj || comp.isComparable(obj);
-      },
-      compare(v1, v2) {
-        if (void 0 === v1) {
-          if (void 0 === v2)
-            return 0;
-          return -1;
-        }
-        if (void 0 === v2)
-          return 1;
-        return comp.compare(v1, v2);
-      }
-    };
-  }
-  Comp2.withUndefined = withUndefined;
-  function withNull(comp) {
-    return {
-      isComparable(obj) {
-        return null === obj || comp.isComparable(obj);
-      },
-      compare(v1, v2) {
-        if (null === v1) {
-          if (null === v2)
-            return 0;
-          return -1;
-        }
-        if (null === v2)
-          return 1;
-        return comp.compare(v1, v2);
-      }
-    };
-  }
-  Comp2.withNull = withNull;
-  function invert(comp) {
-    return {
-      compare(v1, v2) {
-        return comp.compare(v2, v1);
-      },
-      isComparable: comp.isComparable
-    };
-  }
-  Comp2.invert = invert;
-  function toEq(comp) {
-    return (v1, v2) => comp.compare(v1, v2) === 0;
-  }
-  Comp2.toEq = toEq;
-})(Comp || (Comp = {}));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Comp
-});
+                if (undefined === v2)
+                    return 1;
+                return comp.compare(v1, v2);
+            },
+        };
+    }
+    Comp.withUndefined = withUndefined;
+    /**
+     * Returns a Comp instance that extends the given `comp` instance with the capability to handle `null` values, where null is considered to be smaller
+     * than any other value, and equal to another null.
+     * @param comp - the Comp instance to wrap
+     * @example
+     * ```ts
+     * const c = Comp.withNull(Comp.numberComp())
+     * console.log(c.compare(null, 5) < 0)
+     * // => true
+     * console.log(c.compare(null, null))
+     * // => 0
+     * ```
+     */
+    function withNull(comp) {
+        return {
+            isComparable: function (obj) {
+                return null === obj || comp.isComparable(obj);
+            },
+            compare: function (v1, v2) {
+                if (null === v1) {
+                    if (null === v2)
+                        return 0;
+                    return -1;
+                }
+                if (null === v2)
+                    return 1;
+                return comp.compare(v1, v2);
+            },
+        };
+    }
+    Comp.withNull = withNull;
+    /**
+     * Returns a Comp instance the reverses the order of the given `comp` instance.
+     * @param comp - the Comp instance to wrap
+     * @example
+     * ```ts
+     * const c = Comp.invert(Comp.numberComp())
+     * console.log(c.compare(3, 5) > 0)
+     * // => true
+     * console.log(c.compare(5, 5))
+     * // => 0
+     * ```
+     */
+    function invert(comp) {
+        return {
+            compare: function (v1, v2) {
+                return comp.compare(v2, v1);
+            },
+            isComparable: comp.isComparable,
+        };
+    }
+    Comp.invert = invert;
+    /**
+     * Returns an `Eq` equality instance thet will return true when the given `comp` comparable instance returns 0.
+     * @param comp - the `Comp` comparable instance to convert
+     * @example
+     * ```ts
+     * const eq = Comp.toEq(Comp.objectComp())
+     * console.log(eq({ a: 1, b: 2 }, { b: 2, a: 1 }))
+     * // => true
+     * ```
+     */
+    function toEq(comp) {
+        return function (v1, v2) { return comp.compare(v1, v2) === 0; };
+    }
+    Comp.toEq = toEq;
+})(Comp || (exports.Comp = Comp = {}));
+//# sourceMappingURL=comp.cjs.map