@lowentry/utils 1.20.1 → 1.22.1

package/index.js

@@ -8,8 +8,8 @@ import _wrapAsyncGenerator from '@babel/runtime/helpers/wrapAsyncGenerator';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
 import FastDeepEqual from 'fast-deep-equal';
 import CloneDeep from 'clone-deep';
-import _createClass from '@babel/runtime/helpers/createClass';
 import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
 import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
 import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
 import _inherits from '@babel/runtime/helpers/inherits';
@@ -214,9 +214,9 @@ var FLOAT_LAX_ANY = function FLOAT_LAX_ANY() {
 
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _createForOfIteratorHelper$1(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$1(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$1(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$1(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0; } }
+function _arrayLikeToArray$1(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 
 /**
  * @param {LeUtils_TransactionalValue} transactionalValue
@@ -704,7 +704,7 @@ var LeUtils = {
     }
     if (typeof (elements === null || elements === void 0 ? void 0 : elements[Symbol.iterator]) === 'function') {
       var i = 0;
-      var _iterator = _createForOfIteratorHelper(elements),
+      var _iterator = _createForOfIteratorHelper$1(elements),
         _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
@@ -820,7 +820,7 @@ var LeUtils = {
               _context.next = 17;
               break;
             }
-            _iterator2 = _createForOfIteratorHelper(elements);
+            _iterator2 = _createForOfIteratorHelper$1(elements);
             _context.prev = 10;
             _iterator2.s();
           case 11:
@@ -852,7 +852,7 @@ var LeUtils = {
               _context.next = 25;
               break;
             }
-            _iterator3 = _createForOfIteratorHelper(elements);
+            _iterator3 = _createForOfIteratorHelper$1(elements);
             _context.prev = 18;
             _iterator3.s();
           case 19:
@@ -904,7 +904,7 @@ var LeUtils = {
               break;
             }
             _i4 = 0;
-            _iterator4 = _createForOfIteratorHelper(elements);
+            _iterator4 = _createForOfIteratorHelper$1(elements);
             _context.prev = 30;
             _iterator4.s();
           case 31:
@@ -999,7 +999,7 @@ var LeUtils = {
    */
   each: function each(elements, callback) {
     var optionalSkipHasOwnPropertyCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    var _iterator5 = _createForOfIteratorHelper(LeUtils.eachIterator(elements, optionalSkipHasOwnPropertyCheck)),
+    var _iterator5 = _createForOfIteratorHelper$1(LeUtils.eachIterator(elements, optionalSkipHasOwnPropertyCheck)),
       _step5;
     try {
       for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
@@ -1149,7 +1149,7 @@ var LeUtils = {
             case 1:
               return _context5.abrupt("return", _context5.sent);
             case 2:
-              _iterator6 = _createForOfIteratorHelper(LeUtils.eachIterator(elements, optionalSkipHasOwnPropertyCheck));
+              _iterator6 = _createForOfIteratorHelper$1(LeUtils.eachIterator(elements, optionalSkipHasOwnPropertyCheck));
               _context5.prev = 3;
               _iterator6.s();
             case 4:
@@ -1333,7 +1333,7 @@ var LeUtils = {
     var optionalSkipHasOwnPropertyCheck = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     var keys = LeUtils.sortKeys(elements, comparator, optionalSkipHasOwnPropertyCheck);
     var result = [];
-    var _iterator7 = _createForOfIteratorHelper(keys),
+    var _iterator7 = _createForOfIteratorHelper$1(keys),
       _step7;
     try {
       for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
@@ -3034,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;
@@ -3048,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
@@ -3588,11 +3425,149 @@ 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 _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _classPrivateFieldInitSpec$2(e, t, a) { _checkPrivateRedeclaration$2(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration$2(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldGet$2(s, a) { return s.get(_assertClassBrand$2(s, a)); }
+function _classPrivateFieldSet$2(s, a, r) { return s.set(_assertClassBrand$2(s, a), r), r; }
+function _assertClassBrand$2(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 _events = /*#__PURE__*/new WeakMap();
+/**
+ * A simple event emitter class that allows you to register listeners for events, emit events, and remove listeners.
+ */
+var EventEmitter = /*#__PURE__*/function () {
+  /**
+   * Creates a new EventEmitter instance.
+   */
+  function EventEmitter() {
+    _classCallCheck(this, EventEmitter);
+    /** @type {Map<string, Set<Function>>} */
+    _classPrivateFieldInitSpec$2(this, _events, void 0);
+    _classPrivateFieldSet$2(_events, this, new Map());
+  }
+
+  /**
+   * Registers a listener for a specific event.
+   *
+   * @param {string} event - The name of the event to listen for.
+   * @param {Function} listener - The function to call when the event is emitted.
+   * @returns {{remove:(()=>void)}}
+   */
+  return _createClass(EventEmitter, [{
+    key: "on",
+    value: function on(event, listener) {
+      var _classPrivateFieldGet2,
+        _this = this;
+      if (!_classPrivateFieldGet$2(_events, this).has(event)) {
+        _classPrivateFieldGet$2(_events, this).set(event, new Set());
+      }
+      (_classPrivateFieldGet2 = _classPrivateFieldGet$2(_events, this).get(event)) === null || _classPrivateFieldGet2 === void 0 || _classPrivateFieldGet2.add(listener);
+      return {
+        remove: function remove() {
+          return _this.off(event, listener);
+        }
+      };
+    }
+
+    /**
+     * Registers a listener for a specific event, this listener will be called only once.
+     *
+     * @param {string} event - The name of the event to listen for.
+     * @param {Function} listener - The function to call when the event is emitted.
+     * @returns {{remove:()=>void}}
+     */
+  }, {
+    key: "once",
+    value: function once(event, listener) {
+      var _this2 = this;
+      var _wrapper = function wrapper() {
+        _this2.off(event, _wrapper);
+        listener.apply(void 0, arguments);
+      };
+      this.on(event, _wrapper);
+      return {
+        remove: function remove() {
+          return _this2.off(event, _wrapper);
+        }
+      };
+    }
+
+    /**
+     * Removes a listener for a specific event.
+     *
+     * @param {string} event - The name of the event to stop listening for.
+     * @param {Function} listener - The function to remove from the event listeners.
+     */
+  }, {
+    key: "off",
+    value: function off(event, listener) {
+      var listeners = _classPrivateFieldGet$2(_events, this).get(event);
+      if (listeners) {
+        listeners["delete"](listener);
+        if (listeners.size === 0) {
+          _classPrivateFieldGet$2(_events, this)["delete"](event);
+        }
+      }
+    }
+
+    /**
+     * Emits an event, calling all registered listeners with the provided arguments.
+     *
+     * @param {string} event - The name of the event to emit.
+     * @param {...*} args - The arguments to pass to the listeners.
+     */
+  }, {
+    key: "emit",
+    value: function emit(event) {
+      var listeners = _classPrivateFieldGet$2(_events, this).get(event);
+      if (listeners) {
+        var snapshot = _toConsumableArray(listeners);
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        var _iterator = _createForOfIteratorHelper(snapshot),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var listener = _step.value;
+            try {
+              listener.apply(void 0, args);
+            } catch (err) {
+              console.error("Error in listener for \"".concat(event, "\":"), err);
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    }
+
+    /**
+     * Clears all listeners for a specific event or all events if no event is specified.
+     *
+     * @param {string} [event] - The name of the event to clear listeners for. If not provided, all events will be cleared.
+     */
+  }, {
+    key: "clear",
+    value: function clear(event) {
+      if (event !== undefined) {
+        _classPrivateFieldGet$2(_events, this)["delete"](event);
+      } else {
+        _classPrivateFieldGet$2(_events, this).clear();
+      }
+    }
+  }]);
+}();
+
+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
@@ -3614,11 +3589,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);
   }
 
   /**
@@ -3629,7 +3604,7 @@ var LinkedList = /*#__PURE__*/function () {
   return _createClass(LinkedList, [{
     key: "size",
     get: function get() {
-      return _classPrivateFieldGet(_size, this);
+      return _classPrivateFieldGet$1(_size, this);
     }
 
     /**
@@ -3642,15 +3617,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));
     }
 
     /**
@@ -3663,15 +3638,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));
     }
 
     /**
@@ -3683,17 +3658,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;
     }
 
@@ -3706,17 +3681,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;
     }
   }]);
@@ -3749,5 +3724,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, EventEmitter, 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