directed-graph-typed 2.1.2 → 2.2.1

package/dist/cjs/index.cjs

@@ -1,9 +1,7 @@
 'use strict';
 
 var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/utils/utils.ts
 var uuidV4 = /* @__PURE__ */ __name(function() {
@@ -59,7 +57,10 @@ function isComparable(value, isForceObjectComparable = false) {
 __name(isComparable, "isComparable");
 
 // src/data-structures/base/iterable-entry-base.ts
-var _IterableEntryBase = class _IterableEntryBase {
+var IterableEntryBase = class {
+  static {
+    __name(this, "IterableEntryBase");
+  }
   /**
    * Default iterator yielding `[key, value]` entries.
    * @returns Iterator of `[K, V]`.
@@ -108,7 +109,7 @@ var _IterableEntryBase = class _IterableEntryBase {
   every(predicate, thisArg) {
     let index = 0;
     for (const item of this) {
-      if (!predicate.call(thisArg, item[0], item[1], index++, this)) {
+      if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
         return false;
       }
     }
@@ -124,7 +125,7 @@ var _IterableEntryBase = class _IterableEntryBase {
   some(predicate, thisArg) {
     let index = 0;
     for (const item of this) {
-      if (predicate.call(thisArg, item[0], item[1], index++, this)) {
+      if (predicate.call(thisArg, item[1], item[0], index++, this)) {
         return true;
       }
     }
@@ -140,7 +141,7 @@ var _IterableEntryBase = class _IterableEntryBase {
     let index = 0;
     for (const item of this) {
       const [key, value] = item;
-      callbackfn.call(thisArg, key, value, index++, this);
+      callbackfn.call(thisArg, value, key, index++, this);
     }
   }
   /**
@@ -154,7 +155,7 @@ var _IterableEntryBase = class _IterableEntryBase {
     let index = 0;
     for (const item of this) {
       const [key, value] = item;
-      if (callbackfn.call(thisArg, key, value, index++, this)) return item;
+      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
     }
     return;
   }
@@ -228,11 +229,12 @@ var _IterableEntryBase = class _IterableEntryBase {
     console.log(this.toVisual());
   }
 };
-__name(_IterableEntryBase, "IterableEntryBase");
-var IterableEntryBase = _IterableEntryBase;
 
 // src/data-structures/base/iterable-element-base.ts
-var _IterableElementBase = class _IterableElementBase {
+var IterableElementBase = class {
+  static {
+    __name(this, "IterableElementBase");
+  }
   /**
    * Create a new iterable base.
    *
@@ -243,19 +245,19 @@ var _IterableElementBase = class _IterableElementBase {
    * Time O(1), Space O(1).
    */
   constructor(options) {
-    /**
-     * The converter used to transform a raw element (`R`) into a public element (`E`).
-     *
-     * @remarks
-     * Time O(1), Space O(1).
-     */
-    __publicField(this, "_toElementFn");
     if (options) {
       const { toElementFn } = options;
       if (typeof toElementFn === "function") this._toElementFn = toElementFn;
       else if (toElementFn) throw new TypeError("toElementFn must be a function type");
     }
   }
+  /**
+   * The converter used to transform a raw element (`R`) into a public element (`E`).
+   *
+   * @remarks
+   * Time O(1), Space O(1).
+   */
+  _toElementFn;
   /**
    * Exposes the current `toElementFn`, if configured.
    *
@@ -450,11 +452,13 @@ var _IterableElementBase = class _IterableElementBase {
     console.log(this.toVisual());
   }
 };
-__name(_IterableElementBase, "IterableElementBase");
-var IterableElementBase = _IterableElementBase;
 
 // src/data-structures/heap/heap.ts
-var _Heap = class _Heap extends IterableElementBase {
+var Heap = class _Heap extends IterableElementBase {
+  static {
+    __name(this, "Heap");
+  }
+  _equals = Object.is;
   /**
    * Create a Heap and optionally bulk-insert elements.
    * @remarks Time O(N), Space O(N)
@@ -464,23 +468,13 @@ var _Heap = class _Heap extends IterableElementBase {
    */
   constructor(elements = [], options) {
     super(options);
-    __publicField(this, "_equals", Object.is);
-    __publicField(this, "_elements", []);
-    __publicField(this, "_DEFAULT_COMPARATOR", /* @__PURE__ */ __name((a, b) => {
-      if (typeof a === "object" || typeof b === "object") {
-        throw TypeError("When comparing object types, define a custom comparator in options.");
-      }
-      if (a > b) return 1;
-      if (a < b) return -1;
-      return 0;
-    }, "_DEFAULT_COMPARATOR"));
-    __publicField(this, "_comparator", this._DEFAULT_COMPARATOR);
     if (options) {
       const { comparator } = options;
       if (comparator) this._comparator = comparator;
     }
     this.addMany(elements);
   }
+  _elements = [];
   /**
    * Get the backing array of the heap.
    * @remarks Time O(1), Space O(1)
@@ -503,8 +497,7 @@ var _Heap = class _Heap extends IterableElementBase {
    * @returns Last element or undefined.
    */
   get leaf() {
-    var _a;
-    return (_a = this.elements[this.size - 1]) != null ? _a : void 0;
+    return this.elements[this.size - 1] ?? void 0;
   }
   /**
    * Create a heap of the same class from an iterable.
@@ -777,7 +770,7 @@ var _Heap = class _Heap extends IterableElementBase {
    * @returns A new heap with mapped elements.
    */
   map(callback, options, thisArg) {
-    const { comparator, toElementFn, ...rest } = options != null ? options : {};
+    const { comparator, toElementFn, ...rest } = options ?? {};
     if (!comparator) throw new TypeError("Heap.map requires options.comparator for EM");
     const out = this._createLike([], { ...rest, comparator, toElementFn });
     let i = 0;
@@ -803,6 +796,15 @@ var _Heap = class _Heap extends IterableElementBase {
     }
     return out;
   }
+  _DEFAULT_COMPARATOR = /* @__PURE__ */ __name((a, b) => {
+    if (typeof a === "object" || typeof b === "object") {
+      throw TypeError("When comparing object types, define a custom comparator in options.");
+    }
+    if (a > b) return 1;
+    if (a < b) return -1;
+    return 0;
+  }, "_DEFAULT_COMPARATOR");
+  _comparator = this._DEFAULT_COMPARATOR;
   /**
   * Get the comparator used to order elements.
   * @remarks Time O(1), Space O(1)
@@ -856,7 +858,7 @@ var _Heap = class _Heap extends IterableElementBase {
    */
   _createInstance(options) {
     const Ctor = this.constructor;
-    const next = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options != null ? options : {} });
+    const next = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options ?? {} });
     return next;
   }
   /**
@@ -884,11 +886,12 @@ var _Heap = class _Heap extends IterableElementBase {
     return this._createLike([], options);
   }
 };
-__name(_Heap, "Heap");
-var Heap = _Heap;
 
 // src/data-structures/base/linear-base.ts
-var _LinearBase = class _LinearBase extends IterableElementBase {
+var LinearBase = class _LinearBase extends IterableElementBase {
+  static {
+    __name(this, "LinearBase");
+  }
   /**
    * Construct a linear container with runtime options.
    * @param options - `{ maxLen?, ... }` bounds/behavior options.
@@ -896,12 +899,12 @@ var _LinearBase = class _LinearBase extends IterableElementBase {
    */
   constructor(options) {
     super(options);
-    __publicField(this, "_maxLen", -1);
     if (options) {
       const { maxLen } = options;
       if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
     }
   }
+  _maxLen = -1;
   /**
    * Upper bound for length (if positive), or `-1` when unbounded.
    * @returns Maximum allowed length.
@@ -1034,7 +1037,7 @@ var _LinearBase = class _LinearBase extends IterableElementBase {
     return array;
   }
   reduceRight(callbackfn, initialValue) {
-    let accumulator = initialValue != null ? initialValue : 0;
+    let accumulator = initialValue ?? 0;
     for (let i = this.length - 1; i >= 0; i--) {
       accumulator = callbackfn(accumulator, this.at(i), i, this);
     }
@@ -1076,11 +1079,12 @@ var _LinearBase = class _LinearBase extends IterableElementBase {
     return this;
   }
 };
-__name(_LinearBase, "LinearBase");
-var LinearBase = _LinearBase;
 
 // src/data-structures/queue/queue.ts
-var _Queue = class _Queue extends LinearBase {
+var Queue = class _Queue extends LinearBase {
+  static {
+    __name(this, "Queue");
+  }
   /**
    * Create a Queue and optionally bulk-insert elements.
    * @remarks Time O(N), Space O(N)
@@ -1090,15 +1094,13 @@ var _Queue = class _Queue extends LinearBase {
    */
   constructor(elements = [], options) {
     super(options);
-    __publicField(this, "_elements", []);
-    __publicField(this, "_offset", 0);
-    __publicField(this, "_autoCompactRatio", 0.5);
     if (options) {
       const { autoCompactRatio = 0.5 } = options;
       this._autoCompactRatio = autoCompactRatio;
     }
     this.pushMany(elements);
   }
+  _elements = [];
   /**
    * Get the underlying array buffer.
    * @remarks Time O(1), Space O(1)
@@ -1107,6 +1109,7 @@ var _Queue = class _Queue extends LinearBase {
   get elements() {
     return this._elements;
   }
+  _offset = 0;
   /**
    * Get the current start offset into the array.
    * @remarks Time O(1), Space O(1)
@@ -1115,6 +1118,7 @@ var _Queue = class _Queue extends LinearBase {
   get offset() {
     return this._offset;
   }
+  _autoCompactRatio = 0.5;
   /**
    * Get the compaction threshold (offset/size).
    * @remarks Time O(1), Space O(1)
@@ -1359,11 +1363,10 @@ var _Queue = class _Queue extends LinearBase {
    * @returns A new Queue with mapped elements.
    */
   map(callback, options, thisArg) {
-    var _a, _b;
     const out = new this.constructor([], {
-      toElementFn: options == null ? void 0 : options.toElementFn,
-      maxLen: (_a = options == null ? void 0 : options.maxLen) != null ? _a : this._maxLen,
-      autoCompactRatio: (_b = options == null ? void 0 : options.autoCompactRatio) != null ? _b : this._autoCompactRatio
+      toElementFn: options?.toElementFn,
+      maxLen: options?.maxLen ?? this._maxLen,
+      autoCompactRatio: options?.autoCompactRatio ?? this._autoCompactRatio
     });
     let index = 0;
     for (const v of this)
@@ -1378,14 +1381,13 @@ var _Queue = class _Queue extends LinearBase {
    * @returns A new queue with mapped elements (same element type).
    */
   mapSame(callback, thisArg) {
-    var _a;
     const Ctor = this.constructor;
     const out = new Ctor([], {
       toElementFn: this.toElementFn,
       maxLen: this._maxLen,
       autoCompactRatio: this._autoCompactRatio
     });
-    (_a = out._setAutoCompactRatio) == null ? void 0 : _a.call(out, this._autoCompactRatio);
+    out._setAutoCompactRatio?.(this._autoCompactRatio);
     let index = 0;
     for (const v of this) {
       const mv = thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);
@@ -1445,36 +1447,39 @@ var _Queue = class _Queue extends LinearBase {
     return new Ctor(elements, options);
   }
 };
-__name(_Queue, "Queue");
-var Queue = _Queue;
 
 // src/data-structures/graph/abstract-graph.ts
-var _AbstractVertex = class _AbstractVertex {
+var AbstractVertex = class {
+  static {
+    __name(this, "AbstractVertex");
+  }
+  key;
+  value;
   constructor(key, value) {
-    __publicField(this, "key");
-    __publicField(this, "value");
     this.key = key;
     this.value = value;
   }
 };
-__name(_AbstractVertex, "AbstractVertex");
-var AbstractVertex = _AbstractVertex;
-var _AbstractEdge = class _AbstractEdge {
+var AbstractEdge = class {
+  static {
+    __name(this, "AbstractEdge");
+  }
+  value;
+  weight;
   constructor(weight, value) {
-    __publicField(this, "value");
-    __publicField(this, "weight");
-    __publicField(this, "_hashCode");
     this.weight = weight !== void 0 ? weight : 1;
     this.value = value;
     this._hashCode = uuidV4();
   }
+  _hashCode;
   get hashCode() {
     return this._hashCode;
   }
 };
-__name(_AbstractEdge, "AbstractEdge");
-var AbstractEdge = _AbstractEdge;
-var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
+var AbstractGraph = class extends IterableEntryBase {
+  static {
+    __name(this, "AbstractGraph");
+  }
   /**
    * Construct a graph with runtime defaults.
    * @param options - `GraphOptions<V>` in `options.graph` (e.g. `vertexValueInitializer`, `defaultEdgeWeight`).
@@ -1482,14 +1487,14 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
    */
   constructor(options) {
     super();
-    __publicField(this, "_options", { defaultEdgeWeight: 1 });
-    __publicField(this, "_vertexMap", /* @__PURE__ */ new Map());
-    const graph = options == null ? void 0 : options.graph;
-    this._options = { defaultEdgeWeight: 1, ...graph != null ? graph : {} };
+    const graph = options?.graph;
+    this._options = { defaultEdgeWeight: 1, ...graph ?? {} };
   }
+  _options = { defaultEdgeWeight: 1 };
   get options() {
     return this._options;
   }
+  _vertexMap = /* @__PURE__ */ new Map();
   get vertexMap() {
     return this._vertexMap;
   }
@@ -1647,10 +1652,9 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
    * @remarks Time O(L), Space O(1) where L is path length
    */
   getPathSumWeight(path) {
-    var _a;
     let sum = 0;
     for (let i = 0; i < path.length; i++) {
-      sum += ((_a = this.getEdge(path[i], path[i + 1])) == null ? void 0 : _a.weight) || 0;
+      sum += this.getEdge(path[i], path[i + 1])?.weight || 0;
     }
     return sum;
   }
@@ -1712,7 +1716,6 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
    * @remarks Time O((V + E) log V) weighted / O(V + E) unweighted, Space O(V + E)
    */
   getMinPathBetween(v1, v2, isWeight, isDFS = false) {
-    var _a, _b;
     if (isWeight === void 0) isWeight = false;
     if (isWeight) {
       if (isDFS) {
@@ -1730,7 +1733,7 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
         }
         return allPaths[minIndex] || void 0;
       } else {
-        return (_b = (_a = this.dijkstra(v1, v2, true, true)) == null ? void 0 : _a.minPath) != null ? _b : [];
+        return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
       }
     } else {
       let minPath = [];
@@ -1859,7 +1862,6 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
     return { distMap, preMap, seen, paths, minDist, minPath };
   }
   dijkstra(src, dest = void 0, getMinDist = false, genPaths = false) {
-    var _a;
     let minDist = Number.MAX_SAFE_INTEGER;
     let minDest = void 0;
     let minPath = [];
@@ -1897,8 +1899,8 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
     }, "getPaths");
     while (heap.size > 0) {
       const curHeapNode = heap.poll();
-      const dist = curHeapNode == null ? void 0 : curHeapNode.key;
-      const cur = curHeapNode == null ? void 0 : curHeapNode.value;
+      const dist = curHeapNode?.key;
+      const cur = curHeapNode?.value;
       if (dist !== void 0) {
         if (cur) {
           seen.add(cur);
@@ -1914,7 +1916,7 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
           const neighbors = this.getNeighbors(cur);
           for (const neighbor of neighbors) {
             if (!seen.has(neighbor)) {
-              const weight = (_a = this.getEdge(cur, neighbor)) == null ? void 0 : _a.weight;
+              const weight = this.getEdge(cur, neighbor)?.weight;
               if (typeof weight === "number") {
                 const distSrcToNeighbor = distMap.get(neighbor);
                 if (distSrcToNeighbor !== void 0) {
@@ -2037,7 +2039,6 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
    * @remarks Time O(V^3), Space O(V^2)
    */
   floydWarshall() {
-    var _a;
     const idAndVertices = [...this._vertexMap];
     const n = idAndVertices.length;
     const costs = [];
@@ -2051,7 +2052,7 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
     }
     for (let i = 0; i < n; i++) {
       for (let j = 0; j < n; j++) {
-        costs[i][j] = ((_a = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])) == null ? void 0 : _a.weight) || Number.MAX_SAFE_INTEGER;
+        costs[i][j] = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])?.weight || Number.MAX_SAFE_INTEGER;
       }
     }
     for (let k = 0; k < n; k++) {
@@ -2115,7 +2116,7 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
     const filtered = [];
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index, this)) {
+      if (predicate.call(thisArg, value, key, index, this)) {
         filtered.push([key, value]);
       }
       index++;
@@ -2130,7 +2131,7 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
     const filtered = [];
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index, this)) {
+      if (predicate.call(thisArg, value, key, index, this)) {
         filtered.push([key, value]);
       }
       index++;
@@ -2141,7 +2142,7 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
     const mapped = [];
     let index = 0;
     for (const [key, value] of this) {
-      mapped.push(callback.call(thisArg, key, value, index, this));
+      mapped.push(callback.call(thisArg, value, key, index, this));
       index++;
     }
     return mapped;
@@ -2194,7 +2195,7 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
   _createInstance(_options) {
     const Ctor = this.constructor;
     const instance = new Ctor();
-    const graph = _options == null ? void 0 : _options.graph;
+    const graph = _options?.graph;
     if (graph) instance._options = { ...instance._options, ...graph };
     else instance._options = { ...instance._options, ...this._options };
     return instance;
@@ -2273,29 +2274,32 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
     return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
   }
 };
-__name(_AbstractGraph, "AbstractGraph");
-var AbstractGraph = _AbstractGraph;
 
 // src/data-structures/graph/directed-graph.ts
-var _DirectedVertex = class _DirectedVertex extends AbstractVertex {
+var DirectedVertex = class extends AbstractVertex {
+  static {
+    __name(this, "DirectedVertex");
+  }
   constructor(key, value) {
     super(key, value);
   }
 };
-__name(_DirectedVertex, "DirectedVertex");
-var DirectedVertex = _DirectedVertex;
-var _DirectedEdge = class _DirectedEdge extends AbstractEdge {
+var DirectedEdge = class extends AbstractEdge {
+  static {
+    __name(this, "DirectedEdge");
+  }
+  src;
+  dest;
   constructor(src, dest, weight, value) {
     super(weight, value);
-    __publicField(this, "src");
-    __publicField(this, "dest");
     this.src = src;
     this.dest = dest;
   }
 };
-__name(_DirectedEdge, "DirectedEdge");
-var DirectedEdge = _DirectedEdge;
-var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
+var DirectedGraph = class _DirectedGraph extends AbstractGraph {
+  static {
+    __name(this, "DirectedGraph");
+  }
   /**
    * Construct a directed graph with runtime defaults.
    * @param options - `GraphOptions<V>` (e.g. `vertexValueInitializer`, `defaultEdgeWeight`).
@@ -2303,15 +2307,15 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
    */
   constructor(options) {
     super(options);
-    __publicField(this, "_outEdgeMap", /* @__PURE__ */ new Map());
-    __publicField(this, "_inEdgeMap", /* @__PURE__ */ new Map());
   }
+  _outEdgeMap = /* @__PURE__ */ new Map();
   get outEdgeMap() {
     return this._outEdgeMap;
   }
   set outEdgeMap(v) {
     this._outEdgeMap = v;
   }
+  _inEdgeMap = /* @__PURE__ */ new Map();
   get inEdgeMap() {
     return this._inEdgeMap;
   }
@@ -2364,8 +2368,7 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
    * @remarks Time O(1), Space O(1)
    */
   createEdge(src, dest, weight, value) {
-    var _a;
-    return new DirectedEdge(src, dest, (_a = weight != null ? weight : this.options.defaultEdgeWeight) != null ? _a : 1, value);
+    return new DirectedEdge(src, dest, weight ?? this.options.defaultEdgeWeight ?? 1, value);
   }
   /**
    * Get the unique edge from `src` to `dest`, if present.
@@ -2436,7 +2439,7 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     if (src && dest) {
       const srcOutEdges = this._outEdgeMap.get(src);
       if (srcOutEdges && srcOutEdges.length > 0) {
-        arrayRemove(srcOutEdges, (edge) => edge.src === src.key && edge.dest === (dest == null ? void 0 : dest.key));
+        arrayRemove(srcOutEdges, (edge) => edge.src === src.key && edge.dest === dest?.key);
       }
       const destInEdges = this._inEdgeMap.get(dest);
       if (destInEdges && destInEdges.length > 0) {
@@ -2558,7 +2561,7 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
    * @remarks Time O(V + E), Space O(V)
    */
   topologicalSort(propertyName) {
-    propertyName = propertyName != null ? propertyName : "key";
+    propertyName = propertyName ?? "key";
     const statusMap = /* @__PURE__ */ new Map();
     for (const entry of this.vertexMap) {
       statusMap.set(entry[1], 0);
@@ -2751,8 +2754,6 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     }
   }
 };
-__name(_DirectedGraph, "DirectedGraph");
-var DirectedGraph = _DirectedGraph;
 
 // src/common/index.ts
 var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
@@ -2760,7 +2761,7 @@ var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
   DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
   return DFSOperation2;
 })(DFSOperation || {});
-var _Range = class _Range {
+var Range = class {
   constructor(low, high, includeLow = true, includeHigh = true) {
     this.low = low;
     this.high = high;
@@ -2769,6 +2770,9 @@ var _Range = class _Range {
     if (!(isComparable(low) && isComparable(high))) throw new RangeError("low or high is not comparable");
     if (low > high) throw new RangeError("low must be less than or equal to high");
   }
+  static {
+    __name(this, "Range");
+  }
   // Determine whether a key is within the range
   isInRange(key, comparator) {
     const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
@@ -2776,8 +2780,6 @@ var _Range = class _Range {
     return lowCheck && highCheck;
   }
 };
-__name(_Range, "Range");
-var Range = _Range;
 /**
  * data-structure-typed
  *