@lowentry/utils 1.19.4 → 1.21.1

package/index.js

@@ -1,8 +1,8 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _typeof from '@babel/runtime/helpers/typeof';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import '@babel/runtime/helpers/awaitAsyncGenerator';
 import _wrapAsyncGenerator from '@babel/runtime/helpers/wrapAsyncGenerator';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
@@ -257,6 +257,68 @@ var LeUtils = {
   equals: function equals(value, other) {
     return FastDeepEqual(value, other);
   },
+  /**
+   * Performs a deep equality comparison between two collections (objects, maps, arrays, etc), sorting on the keys before comparing them.
+   *
+   * This is useful for comparing objects that have the same properties, but in a different order, and/or in a different collection type (like Maps vs Objects).
+   *
+   * @param {*} elementsA The elements to compare.
+   * @param {*} elementsB The other elements to compare.
+   * @param {string[]} [ignoreKeys=[]] An array of keys to ignore when comparing the elements. This is useful for ignoring properties that are not relevant for the comparison.
+   * @return {boolean} Returns true if the given values are equivalent, ignoring the order of properties.
+   */
+  equalsMapLike: function () {
+    var sortKeyValueArrays = function sortKeyValueArrays(pairA, pairB) {
+      return LeUtils.compare(pairA[0], pairB[0]);
+    };
+    return function (elementsA, elementsB) {
+      var ignoreKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      elementsA = LeUtils.mapToArray(elementsA, function (value, key) {
+        return [key, value];
+      }).sort(sortKeyValueArrays);
+      elementsB = LeUtils.mapToArray(elementsB, function (value, key) {
+        return [key, value];
+      }).sort(sortKeyValueArrays);
+      ignoreKeys = typeof ignoreKeys === 'string' ? ARRAY(ignoreKeys) : LeUtils.mapToArray(ignoreKeys);
+      var indexA = 0;
+      var indexB = 0;
+      while (indexA < elementsA.length && indexB < elementsB.length) {
+        var _elementsA$indexA = _slicedToArray(elementsA[indexA], 2),
+          mapKey = _elementsA$indexA[0],
+          mapValue = _elementsA$indexA[1];
+        var _elementsB$indexB = _slicedToArray(elementsB[indexB], 2),
+          ownMapKey = _elementsB$indexB[0],
+          ownMapValue = _elementsB$indexB[1];
+        var ignoreKeysIncludesMapKey = ignoreKeys.includes(mapKey);
+        var ignoreKeysIncludesOwnMapKey = ignoreKeys.includes(ownMapKey);
+        if (ignoreKeysIncludesMapKey) {
+          indexA++;
+          if (ignoreKeysIncludesOwnMapKey) {
+            indexB++;
+          }
+          continue;
+        } else if (ignoreKeysIncludesOwnMapKey) {
+          indexB++;
+          continue;
+        }
+        if (!LeUtils.equals(mapKey, ownMapKey) || !LeUtils.equals(mapValue, ownMapValue)) {
+          return false;
+        }
+        indexA++;
+        indexB++;
+      }
+      while (indexA < elementsA.length && ignoreKeys.includes(elementsA[indexA][0])) {
+        indexA++;
+      }
+      if (indexA < elementsA.length) {
+        return false;
+      }
+      while (indexB < elementsB.length && ignoreKeys.includes(elementsB[indexB][0])) {
+        indexB++;
+      }
+      return indexB >= elementsB.length;
+    };
+  }(),
   /**
    * Returns a deep copy of the given value.
    *
@@ -2972,6 +3034,15 @@ var LeUtils = {
    * @returns {boolean}
    */
   isGivenHostPrivate: function isGivenHostPrivate(host) {
+    host = STRING(host).trim();
+    if (!host) {
+      return false;
+    }
+    try {
+      host = new URL(host).hostname;
+    } catch (e) {
+      host = host.split(':')[0];
+    }
     host = STRING(host).trim().toLowerCase();
     if (host === 'localhost' || host === '127.0.0.1') {
       return true;
@@ -2986,178 +3057,6 @@ var LeUtils = {
     // 172.16.0.0 - 172.31.255.255
     parts[0] === '192' && parts[1] === '168'; // 192.168.0.0 - 192.168.255.255
   },
-  /**
-   * Creates and returns a new TreeSet.
-   * A TreeSet is a set of elements, sorted by a comparator.
-   * Binary search is used to find elements, which makes it very fast to find elements.
-   *
-   * The comparator is also used to determine if two values are equal to each other.
-   * This way, you can have values that aren't the same be treated as if they are. This can be used to deal with issues such as floating point errors for example.
-   *
-   * @param {*[]} elements
-   * @param {(valueA:*, valueB:*) => number} comparator
-   * @returns {{getElements:(()=>*[]), getComparator:(()=>((valueA:*,valueB:*)=>number)), size:(()=>number), isEmpty:(()=>boolean), contains:((value:*)=>boolean), first:(()=>*|undefined), last:(()=>*|undefined), pollFirst:(()=>*|undefined), pollLast:(()=>*|undefined), add:((value:*)=>void), addAll:((values:*)=>void), getEqualValue:((value:*)=>*), getEqualValueOrAdd:((value:*)=>*)}}
-   */
-  createTreeSet: function createTreeSet(elements, comparator) {
-    comparator = comparator || LeUtils.compare;
-    elements = elements || [];
-    elements.sort(comparator);
-
-    /**
-     * Performs a binary search on the elements, and returns the result.
-     *
-     * @param {*} value
-     * @returns {{found: boolean,  index: number,  value: *|undefined}}
-     */
-    var binarySearch = function binarySearch(value) {
-      var low = 0;
-      var high = elements.length - 1;
-      while (low <= high) {
-        var mid = Math.floor((low + high) / 2);
-        var midValue = elements[mid];
-        var cmp = comparator(midValue, value);
-        if (cmp < 0) {
-          low = mid + 1;
-        } else if (cmp > 0) {
-          high = mid - 1;
-        } else {
-          return {
-            found: true,
-            index: mid,
-            value: midValue
-          };
-        }
-      }
-      return {
-        found: false,
-        index: low,
-        value: undefined
-      };
-    };
-    var treeSet = {
-      /**
-       * Returns the elements of the set.
-       *
-       * @returns {*[]}
-       */
-      getElements: function getElements() {
-        return elements;
-      },
-      /**
-       * Returns the comparator of the set.
-       *
-       * @returns {(valueA:*, valueB:*) => number}
-       */
-      getComparator: function getComparator() {
-        return comparator;
-      },
-      /**
-       * Returns the size of the set.
-       *
-       * @returns {number}
-       */
-      size: function size() {
-        return elements.length;
-      },
-      /**
-       * Returns true if the set is empty, false otherwise.
-       *
-       * @returns {boolean}
-       */
-      isEmpty: function isEmpty() {
-        return elements.length <= 0;
-      },
-      /**
-       * Returns true if the set contains a value that is equal to the given value, returns false otherwise.
-       *
-       * @param {*} value
-       * @returns {boolean}
-       */
-      contains: function contains(value) {
-        return binarySearch(value).found;
-      },
-      /**
-       * Returns the first element of the set, or undefined if it is empty.
-       *
-       * @returns {*|undefined}
-       */
-      first: function first() {
-        return elements.length > 0 ? elements[0] : undefined;
-      },
-      /**
-       * Returns the last element of the set, or undefined if it is empty.
-       *
-       * @returns {*|undefined}
-       */
-      last: function last() {
-        return elements.length > 0 ? elements[elements.length - 1] : undefined;
-      },
-      /**
-       * Removes and returns the first element of the set, or undefined if it is empty.
-       *
-       * @returns {*|undefined}
-       */
-      pollFirst: function pollFirst() {
-        return elements.length > 0 ? elements.splice(0, 1)[0] : undefined;
-      },
-      /**
-       * Removes and returns the last element of the set, or undefined if it is empty.
-       *
-       * @returns {*|undefined}
-       */
-      pollLast: function pollLast() {
-        return elements.length > 0 ? elements.splice(elements.length - 1, 1)[0] : undefined;
-      },
-      /**
-       * Adds the given value to the set. Will only do so if no equal value already exists.
-       *
-       * @param {*} value
-       */
-      add: function add(value) {
-        var result = binarySearch(value);
-        if (result.found) {
-          return;
-        }
-        elements.splice(result.index, 0, value);
-      },
-      /**
-       * Adds all the given values to the set. Will only do so if no equal value already exists.
-       *
-       * @param {*} values
-       */
-      addAll: function addAll(values) {
-        LeUtils.each(values, treeSet.add);
-      },
-      /**
-       * Returns an equal value that's already in the tree set, or undefined if no equal values in it exist.
-       *
-       * @param {*} value
-       * @returns {*|undefined}
-       */
-      getEqualValue: function getEqualValue(value) {
-        var result = binarySearch(value);
-        if (result.found) {
-          return result.value;
-        }
-        return undefined;
-      },
-      /**
-       * Returns an equal value that's already in the tree set. If no equal values in it exist, the given value will be added and returned.
-       *
-       * @param {*} value
-       * @returns {*}
-       */
-      getEqualValueOrAdd: function getEqualValueOrAdd(value) {
-        var result = binarySearch(value);
-        if (result.found) {
-          return result.value;
-        }
-        elements.splice(result.index, 0, value);
-        return value;
-      }
-    };
-    return treeSet;
-  },
   /**
    * @typedef {Object} LeUtils_TransactionalValue
    * @property {*} value
@@ -3526,11 +3425,11 @@ var LeUtils = {
   }()
 };
 
-function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
-function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+function _classPrivateFieldInitSpec$1(e, t, a) { _checkPrivateRedeclaration$1(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration$1(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldSet$1(s, a, r) { return s.set(_assertClassBrand$1(s, a), r), r; }
+function _classPrivateFieldGet$1(s, a) { return s.get(_assertClassBrand$1(s, a)); }
+function _assertClassBrand$1(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
 var LinkedListNode = /*#__PURE__*/_createClass(
 /**
  * @param {*} value
@@ -3552,11 +3451,11 @@ var LinkedList = /*#__PURE__*/function () {
   function LinkedList() {
     _classCallCheck(this, LinkedList);
     /** @type {LinkedListNode|null} */
-    _classPrivateFieldInitSpec(this, _head, null);
+    _classPrivateFieldInitSpec$1(this, _head, null);
     /** @type {LinkedListNode|null} */
-    _classPrivateFieldInitSpec(this, _tail, null);
+    _classPrivateFieldInitSpec$1(this, _tail, null);
     /** @type {number} */
-    _classPrivateFieldInitSpec(this, _size, 0);
+    _classPrivateFieldInitSpec$1(this, _size, 0);
   }
 
   /**
@@ -3567,7 +3466,7 @@ var LinkedList = /*#__PURE__*/function () {
   return _createClass(LinkedList, [{
     key: "size",
     get: function get() {
-      return _classPrivateFieldGet(_size, this);
+      return _classPrivateFieldGet$1(_size, this);
     }
 
     /**
@@ -3580,15 +3479,15 @@ var LinkedList = /*#__PURE__*/function () {
     value: function unshift(value) {
       var _this$size;
       var newNode = new LinkedListNode(value);
-      if (_classPrivateFieldGet(_head, this) === null) {
-        _classPrivateFieldSet(_head, this, newNode);
-        _classPrivateFieldSet(_tail, this, newNode);
+      if (_classPrivateFieldGet$1(_head, this) === null) {
+        _classPrivateFieldSet$1(_head, this, newNode);
+        _classPrivateFieldSet$1(_tail, this, newNode);
       } else {
-        newNode.next = _classPrivateFieldGet(_head, this);
-        _classPrivateFieldGet(_head, this).previous = newNode;
-        _classPrivateFieldSet(_head, this, newNode);
+        newNode.next = _classPrivateFieldGet$1(_head, this);
+        _classPrivateFieldGet$1(_head, this).previous = newNode;
+        _classPrivateFieldSet$1(_head, this, newNode);
       }
-      _classPrivateFieldSet(_size, this, (_this$size = _classPrivateFieldGet(_size, this), _this$size++, _this$size));
+      _classPrivateFieldSet$1(_size, this, (_this$size = _classPrivateFieldGet$1(_size, this), _this$size++, _this$size));
     }
 
     /**
@@ -3601,15 +3500,15 @@ var LinkedList = /*#__PURE__*/function () {
     value: function push(value) {
       var _this$size3;
       var newNode = new LinkedListNode(value);
-      if (_classPrivateFieldGet(_tail, this) === null) {
-        _classPrivateFieldSet(_head, this, newNode);
-        _classPrivateFieldSet(_tail, this, newNode);
+      if (_classPrivateFieldGet$1(_tail, this) === null) {
+        _classPrivateFieldSet$1(_head, this, newNode);
+        _classPrivateFieldSet$1(_tail, this, newNode);
       } else {
-        newNode.previous = _classPrivateFieldGet(_tail, this);
-        _classPrivateFieldGet(_tail, this).next = newNode;
-        _classPrivateFieldSet(_tail, this, newNode);
+        newNode.previous = _classPrivateFieldGet$1(_tail, this);
+        _classPrivateFieldGet$1(_tail, this).next = newNode;
+        _classPrivateFieldSet$1(_tail, this, newNode);
       }
-      _classPrivateFieldSet(_size, this, (_this$size3 = _classPrivateFieldGet(_size, this), _this$size3++, _this$size3));
+      _classPrivateFieldSet$1(_size, this, (_this$size3 = _classPrivateFieldGet$1(_size, this), _this$size3++, _this$size3));
     }
 
     /**
@@ -3621,17 +3520,17 @@ var LinkedList = /*#__PURE__*/function () {
     key: "shift",
     value: function shift() {
       var _this$size5;
-      if (_classPrivateFieldGet(_head, this) === null) {
+      if (_classPrivateFieldGet$1(_head, this) === null) {
         return undefined;
       }
-      var value = _classPrivateFieldGet(_head, this).value;
-      _classPrivateFieldSet(_head, this, _classPrivateFieldGet(_head, this).next);
-      if (_classPrivateFieldGet(_head, this) !== null) {
-        _classPrivateFieldGet(_head, this).previous = null;
+      var value = _classPrivateFieldGet$1(_head, this).value;
+      _classPrivateFieldSet$1(_head, this, _classPrivateFieldGet$1(_head, this).next);
+      if (_classPrivateFieldGet$1(_head, this) !== null) {
+        _classPrivateFieldGet$1(_head, this).previous = null;
       } else {
-        _classPrivateFieldSet(_tail, this, null);
+        _classPrivateFieldSet$1(_tail, this, null);
       }
-      _classPrivateFieldSet(_size, this, (_this$size5 = _classPrivateFieldGet(_size, this), _this$size5--, _this$size5));
+      _classPrivateFieldSet$1(_size, this, (_this$size5 = _classPrivateFieldGet$1(_size, this), _this$size5--, _this$size5));
       return value;
     }
 
@@ -3644,17 +3543,17 @@ var LinkedList = /*#__PURE__*/function () {
     key: "pop",
     value: function pop() {
       var _this$size7;
-      if (_classPrivateFieldGet(_tail, this) === null) {
+      if (_classPrivateFieldGet$1(_tail, this) === null) {
         return undefined;
       }
-      var value = _classPrivateFieldGet(_tail, this).value;
-      _classPrivateFieldSet(_tail, this, _classPrivateFieldGet(_tail, this).previous);
-      if (_classPrivateFieldGet(_tail, this) !== null) {
-        _classPrivateFieldGet(_tail, this).next = null;
+      var value = _classPrivateFieldGet$1(_tail, this).value;
+      _classPrivateFieldSet$1(_tail, this, _classPrivateFieldGet$1(_tail, this).previous);
+      if (_classPrivateFieldGet$1(_tail, this) !== null) {
+        _classPrivateFieldGet$1(_tail, this).next = null;
       } else {
-        _classPrivateFieldSet(_head, this, null);
+        _classPrivateFieldSet$1(_head, this, null);
       }
-      _classPrivateFieldSet(_size, this, (_this$size7 = _classPrivateFieldGet(_size, this), _this$size7--, _this$size7));
+      _classPrivateFieldSet$1(_size, this, (_this$size7 = _classPrivateFieldGet$1(_size, this), _this$size7--, _this$size7));
       return value;
     }
   }]);
@@ -3687,5 +3586,256 @@ var SerializableMap = /*#__PURE__*/function (_Map) {
   }]);
 }(/*#__PURE__*/_wrapNativeSuper(Map));
 
-export { ARRAY, FLOAT, FLOAT_ANY, FLOAT_LAX, FLOAT_LAX_ANY, INT, INT_ANY, INT_LAX, INT_LAX_ANY, ISSET, IS_ARRAY, IS_OBJECT, LeUtils, LinkedList, OBJECT, STRING, STRING_ANY, SerializableMap };
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+
+/**
+ * A TreeSet is a set of elements, sorted by a comparator.
+ * Binary search is used to find elements, which makes it very fast to find elements.
+ *
+ * The comparator is also used to determine if two values are equal to each other.
+ * This way, you can have values that aren't the same be treated as if they are. This can be used to deal with issues such as floating point errors for example.
+ */
+var _elements = /*#__PURE__*/new WeakMap();
+var _comparator = /*#__PURE__*/new WeakMap();
+var TreeSet = /*#__PURE__*/function () {
+  /**
+   * Creates a new TreeSet with the given elements and comparator.
+   *
+   * @param {*[]} [elements=[]] - The initial elements of the set.
+   * @param {(valueA:*, valueB:*) => number} [comparator=LeUtils.compare] - The comparator function to use for sorting.
+   */
+  function TreeSet(elements, comparator) {
+    _classCallCheck(this, TreeSet);
+    /** @type {*[]} */
+    _classPrivateFieldInitSpec(this, _elements, void 0);
+    /** @type {(valueA:*, valueB:*) => number} */
+    _classPrivateFieldInitSpec(this, _comparator, void 0);
+    _classPrivateFieldSet(_comparator, this, comparator || LeUtils.compare);
+    _classPrivateFieldSet(_elements, this, elements || []);
+    _classPrivateFieldGet(_elements, this).sort(_classPrivateFieldGet(_comparator, this));
+  }
+
+  /**
+   *
+   *
+   * @param {*} value - The value to search for in the set.
+   * @returns {{found:boolean, index:number, value:*|undefined}} - An object containing whether the value was found, the index where it would be inserted, and the value at that index (if found).
+   * @private
+   */
+  return _createClass(TreeSet, [{
+    key: "binarySearch",
+    value: function binarySearch(value) {
+      var low = 0;
+      var high = _classPrivateFieldGet(_elements, this).length - 1;
+      while (low <= high) {
+        var mid = Math.floor((low + high) / 2);
+        var midValue = _classPrivateFieldGet(_elements, this)[mid];
+        var cmp = _classPrivateFieldGet(_comparator, this).call(this, midValue, value);
+        if (cmp < 0) {
+          low = mid + 1;
+        } else if (cmp > 0) {
+          high = mid - 1;
+        } else {
+          return {
+            found: true,
+            index: mid,
+            value: midValue
+          };
+        }
+      }
+      return {
+        found: false,
+        index: low,
+        value: undefined
+      };
+    }
+  }, {
+    key: "getElements",
+    value:
+    /**
+     * Returns the elements of the set.
+     */
+    function getElements() {
+      return _classPrivateFieldGet(_elements, this);
+    }
+
+    /**
+     * Returns the comparator of the set.
+     *
+     * @returns {(valueA:*, valueB:*) => number}
+     */
+  }, {
+    key: "getComparator",
+    value: function getComparator() {
+      return _classPrivateFieldGet(_comparator, this);
+    }
+
+    /**
+     * Returns the size of the set.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "size",
+    value: function size() {
+      return _classPrivateFieldGet(_elements, this).length;
+    }
+
+    /**
+     * Returns true if the set is empty, false otherwise.
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return _classPrivateFieldGet(_elements, this).length <= 0;
+    }
+
+    /**
+     * Returns true if the set contains a value that is equal to the given value, returns false otherwise.
+     *
+     * @param {*} value - The value to check for in the set.
+     * @return {boolean} - True if the set contains the value, false otherwise.
+     */
+  }, {
+    key: "contains",
+    value: function contains(value) {
+      return this.binarySearch(value).found;
+    }
+
+    /**
+     * Returns the first element of the set, or undefined if it is empty.
+     *
+     * @return {*|undefined} - The first element of the set, or undefined if it is empty.
+     */
+  }, {
+    key: "first",
+    value: function first() {
+      return _classPrivateFieldGet(_elements, this).length > 0 ? _classPrivateFieldGet(_elements, this)[0] : undefined;
+    }
+
+    /**
+     * Returns the last element of the set, or undefined if it is empty.
+     *
+     * @return {*|undefined} - The last element of the set, or undefined if it is empty.
+     */
+  }, {
+    key: "last",
+    value: function last() {
+      return _classPrivateFieldGet(_elements, this).length > 0 ? _classPrivateFieldGet(_elements, this)[_classPrivateFieldGet(_elements, this).length - 1] : undefined;
+    }
+
+    /**
+     * Removes and returns the first element of the set, or undefined if it is empty.
+     *
+     * @returns {*|undefined} - The first element of the set, or undefined if it is empty.
+     */
+  }, {
+    key: "pollFirst",
+    value: function pollFirst() {
+      return _classPrivateFieldGet(_elements, this).length > 0 ? _classPrivateFieldGet(_elements, this).splice(0, 1)[0] : undefined;
+    }
+
+    /**
+     * Removes and returns the last element of the set, or undefined if it is empty.
+     *
+     * @returns {*|undefined} - The last element of the set, or undefined if it is empty.
+     */
+  }, {
+    key: "pollLast",
+    value: function pollLast() {
+      return _classPrivateFieldGet(_elements, this).length > 0 ? _classPrivateFieldGet(_elements, this).splice(_classPrivateFieldGet(_elements, this).length - 1, 1)[0] : undefined;
+    }
+
+    /**
+     * Adds the given value to the set. Will only do so if no equal value already exists.
+     * @param {*} value - The value to add to the set.
+     */
+  }, {
+    key: "add",
+    value: function add(value) {
+      var result = this.binarySearch(value);
+      if (result.found) {
+        return;
+      }
+      _classPrivateFieldGet(_elements, this).splice(result.index, 0, value);
+    }
+
+    /**
+     * Adds all the given values to the set. Will only do so if no equal value already exists.
+     *
+     * @param {*} values - The values to add to the set.
+     */
+  }, {
+    key: "addAll",
+    value: function addAll(values) {
+      LeUtils.each(values, this.add.bind(this));
+    }
+
+    /**
+     * Returns an equal value that's already in the tree set, or undefined if no equal values in it exist.
+     *
+     * @param {*} value - The value to search for in the set.
+     * @return {*|undefined} - The equal value if found, or undefined if not found.
+     */
+  }, {
+    key: "getEqualValue",
+    value: function getEqualValue(value) {
+      var result = this.binarySearch(value);
+      if (result.found) {
+        return result.value;
+      }
+      return undefined;
+    }
+
+    /**
+     * Returns an equal value that's already in the tree set. If no equal values in it exist, the given value will be added and returned.
+     *
+     * @param {*} value - The value to search for in the set.
+     * @return {*} - The equal value if found, or the added value if not found.
+     */
+  }, {
+    key: "getEqualValueOrAdd",
+    value: function getEqualValueOrAdd(value) {
+      var result = this.binarySearch(value);
+      if (result.found) {
+        return result.value;
+      }
+      _classPrivateFieldGet(_elements, this).splice(result.index, 0, value);
+      return value;
+    }
+
+    /**
+     * Returns a string representation of the TreeSet.
+     *
+     * @returns {string} - A string representation of the TreeSet, including its elements and comparator.
+     */
+  }, {
+    key: "toString",
+    value: function toString() {
+      return "TreeSet{elements:".concat(_classPrivateFieldGet(_elements, this), ", comparator:").concat(_classPrivateFieldGet(_comparator, this), "}");
+    }
+
+    /**
+     * Returns a JSON representation of the TreeSet.
+     *
+     * @returns {Object} - An object containing the elements and comparator of the TreeSet.
+     */
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        elements: _classPrivateFieldGet(_elements, this),
+        comparator: _classPrivateFieldGet(_comparator, this).toString()
+      };
+    }
+  }]);
+}();
+
+export { ARRAY, FLOAT, FLOAT_ANY, FLOAT_LAX, FLOAT_LAX_ANY, INT, INT_ANY, INT_LAX, INT_LAX_ANY, ISSET, IS_ARRAY, IS_OBJECT, LeUtils, LinkedList, OBJECT, STRING, STRING_ANY, SerializableMap, TreeSet };
 //# sourceMappingURL=index.js.map