effect 2.0.0-next.41 → 2.0.0-next.43

package/RedBlackTree/dist/effect-RedBlackTree.cjs.dev.js

@@ -2,63 +2,1642 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var RedBlackTree_dist_effectRedBlackTree = require('../../dist/RedBlackTree-e6bd147c.cjs.dev.js');
-require('../../dist/Chunk-bd290b8e.cjs.dev.js');
-require('../../dist/Equal-281b6ca8.cjs.dev.js');
-require('../../dist/Hash-bd154268.cjs.dev.js');
-require('../../dist/Function-41ce433d.cjs.dev.js');
-require('../../dist/GlobalValue-81ab6908.cjs.dev.js');
-require('../../dist/Utils-b0c14d1b.cjs.dev.js');
-require('../../dist/Predicate-9e859c9c.cjs.dev.js');
-require('../../dist/Equivalence-de7a0d51.cjs.dev.js');
-require('../../dist/Inspectable-ac929af4.cjs.dev.js');
-require('../../dist/Option-03997d77.cjs.dev.js');
-require('../../dist/Either-9c349424.cjs.dev.js');
-require('../../dist/Effectable-a6403e5f.cjs.dev.js');
-require('../../dist/Data-85559fb3.cjs.dev.js');
-require('../../dist/Pipeable-4698db72.cjs.dev.js');
-require('../../dist/Number-588f6483.cjs.dev.js');
-require('../../dist/Order-28bdebd2.cjs.dev.js');
-require('../../dist/ReadonlyArray-48949ee7.cjs.dev.js');
-require('../../dist/Either-a806809d.cjs.dev.js');
+var Chunk_dist_effectChunk = require('../../Chunk/dist/effect-Chunk.cjs.dev.js');
+var Equal_dist_effectEqual = require('../../Equal/dist/effect-Equal.cjs.dev.js');
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.dev.js');
+var Hash_dist_effectHash = require('../../Hash/dist/effect-Hash.cjs.dev.js');
+var Inspectable_dist_effectInspectable = require('../../Inspectable/dist/effect-Inspectable.cjs.dev.js');
+var Option_dist_effectOption = require('../../Option/dist/effect-Option.cjs.dev.js');
+var Stack = require('../../dist/Stack-ada2d201.cjs.dev.js');
+var Pipeable_dist_effectPipeable = require('../../Pipeable/dist/effect-Pipeable.cjs.dev.js');
+var Predicate_dist_effectPredicate = require('../../Predicate/dist/effect-Predicate.cjs.dev.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.dev.js');
+require('../../Order/dist/effect-Order.cjs.dev.js');
+require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
+require('../../Either/dist/effect-Either.cjs.dev.js');
+require('../../dist/Either-12bbe00c.cjs.dev.js');
+require('../../dist/Effectable-2f022879.cjs.dev.js');
+require('../../Data/dist/effect-Data.cjs.dev.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
+require('../../Utils/dist/effect-Utils.cjs.dev.js');
 require('../../dist/ReadonlyArray-9a1474f6.cjs.dev.js');
-require('../../dist/ReadonlyRecord-605a625b.cjs.dev.js');
-require('../../dist/Stack-ada2d201.cjs.dev.js');
-
-
-
-exports.Direction = RedBlackTree_dist_effectRedBlackTree.Direction;
-exports.at = RedBlackTree_dist_effectRedBlackTree.at;
-exports.atReversed = RedBlackTree_dist_effectRedBlackTree.atReversed;
-exports.empty = RedBlackTree_dist_effectRedBlackTree.empty;
-exports.findAll = RedBlackTree_dist_effectRedBlackTree.findAll;
-exports.findFirst = RedBlackTree_dist_effectRedBlackTree.findFirst;
-exports.first = RedBlackTree_dist_effectRedBlackTree.first;
-exports.forEach = RedBlackTree_dist_effectRedBlackTree.forEach;
-exports.forEachBetween = RedBlackTree_dist_effectRedBlackTree.forEachBetween;
-exports.forEachGreaterThanEqual = RedBlackTree_dist_effectRedBlackTree.forEachGreaterThanEqual;
-exports.forEachLessThan = RedBlackTree_dist_effectRedBlackTree.forEachLessThan;
-exports.fromIterable = RedBlackTree_dist_effectRedBlackTree.fromIterable;
-exports.getAt = RedBlackTree_dist_effectRedBlackTree.getAt;
-exports.getOrder = RedBlackTree_dist_effectRedBlackTree.getOrder;
-exports.greaterThan = RedBlackTree_dist_effectRedBlackTree.greaterThan;
-exports.greaterThanEqual = RedBlackTree_dist_effectRedBlackTree.greaterThanEqual;
-exports.greaterThanEqualReversed = RedBlackTree_dist_effectRedBlackTree.greaterThanEqualReversed;
-exports.greaterThanReversed = RedBlackTree_dist_effectRedBlackTree.greaterThanReversed;
-exports.has = RedBlackTree_dist_effectRedBlackTree.has;
-exports.insert = RedBlackTree_dist_effectRedBlackTree.insert;
-exports.isRedBlackTree = RedBlackTree_dist_effectRedBlackTree.isRedBlackTree;
-exports.keys = RedBlackTree_dist_effectRedBlackTree.keys;
-exports.keysReversed = RedBlackTree_dist_effectRedBlackTree.keysReversed;
-exports.last = RedBlackTree_dist_effectRedBlackTree.last;
-exports.lessThan = RedBlackTree_dist_effectRedBlackTree.lessThan;
-exports.lessThanEqual = RedBlackTree_dist_effectRedBlackTree.lessThanEqual;
-exports.lessThanEqualReversed = RedBlackTree_dist_effectRedBlackTree.lessThanEqualReversed;
-exports.lessThanReversed = RedBlackTree_dist_effectRedBlackTree.lessThanReversed;
-exports.make = RedBlackTree_dist_effectRedBlackTree.make;
-exports.reduce = RedBlackTree_dist_effectRedBlackTree.reduce;
-exports.removeFirst = RedBlackTree_dist_effectRedBlackTree.removeFirst;
-exports.reversed = RedBlackTree_dist_effectRedBlackTree.reversed;
-exports.size = RedBlackTree_dist_effectRedBlackTree.size;
-exports.values = RedBlackTree_dist_effectRedBlackTree.values;
-exports.valuesReversed = RedBlackTree_dist_effectRedBlackTree.valuesReversed;
+require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.dev.js');
+require('../../Number/dist/effect-Number.cjs.dev.js');
+
+/** @internal */
+const Direction$1 = {
+  Forward: 0,
+  Backward: 1 << 0
+};
+
+/** @internal */
+class RedBlackTreeIterator {
+  count = 0;
+  constructor(self, stack, direction) {
+    this.self = self;
+    this.stack = stack;
+    this.direction = direction;
+  }
+
+  /**
+   * Clones the iterator
+   */
+  clone() {
+    return new RedBlackTreeIterator(this.self, this.stack.slice(), this.direction);
+  }
+
+  /**
+   * Reverse the traversal direction
+   */
+  reversed() {
+    return new RedBlackTreeIterator(this.self, this.stack.slice(), this.direction === Direction$1.Forward ? Direction$1.Backward : Direction$1.Forward);
+  }
+
+  /**
+   * Iterator next
+   */
+  next() {
+    const entry = this.entry;
+    this.count++;
+    if (this.direction === Direction$1.Forward) {
+      this.moveNext();
+    } else {
+      this.movePrev();
+    }
+    switch (entry._tag) {
+      case "None":
+        {
+          return {
+            done: true,
+            value: this.count
+          };
+        }
+      case "Some":
+        {
+          return {
+            done: false,
+            value: entry.value
+          };
+        }
+    }
+  }
+
+  /**
+   * Returns the key
+   */
+  get key() {
+    if (this.stack.length > 0) {
+      return Option_dist_effectOption.some(this.stack[this.stack.length - 1].key);
+    }
+    return Option_dist_effectOption.none();
+  }
+
+  /**
+   * Returns the value
+   */
+  get value() {
+    if (this.stack.length > 0) {
+      return Option_dist_effectOption.some(this.stack[this.stack.length - 1].value);
+    }
+    return Option_dist_effectOption.none();
+  }
+
+  /**
+   * Returns the key
+   */
+  get entry() {
+    if (this.stack.length > 0) {
+      return Option_dist_effectOption.some([this.stack[this.stack.length - 1].key, this.stack[this.stack.length - 1].value]);
+    }
+    return Option_dist_effectOption.none();
+  }
+
+  /**
+   * Returns the position of this iterator in the sorted list
+   */
+  get index() {
+    let idx = 0;
+    const stack = this.stack;
+    if (stack.length === 0) {
+      const r = this.self._root;
+      if (r != null) {
+        return r.count;
+      }
+      return 0;
+    } else if (stack[stack.length - 1].left != null) {
+      idx = stack[stack.length - 1].left.count;
+    }
+    for (let s = stack.length - 2; s >= 0; --s) {
+      if (stack[s + 1] === stack[s].right) {
+        ++idx;
+        if (stack[s].left != null) {
+          idx += stack[s].left.count;
+        }
+      }
+    }
+    return idx;
+  }
+
+  /**
+   * Advances iterator to next element in list
+   */
+  moveNext() {
+    const stack = this.stack;
+    if (stack.length === 0) {
+      return;
+    }
+    let n = stack[stack.length - 1];
+    if (n.right != null) {
+      n = n.right;
+      while (n != null) {
+        stack.push(n);
+        n = n.left;
+      }
+    } else {
+      stack.pop();
+      while (stack.length > 0 && stack[stack.length - 1].right === n) {
+        n = stack[stack.length - 1];
+        stack.pop();
+      }
+    }
+  }
+
+  /**
+   * Checks if there is a next element
+   */
+  get hasNext() {
+    const stack = this.stack;
+    if (stack.length === 0) {
+      return false;
+    }
+    if (stack[stack.length - 1].right != null) {
+      return true;
+    }
+    for (let s = stack.length - 1; s > 0; --s) {
+      if (stack[s - 1].left === stack[s]) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Advances iterator to previous element in list
+   */
+  movePrev() {
+    const stack = this.stack;
+    if (stack.length === 0) {
+      return;
+    }
+    let n = stack[stack.length - 1];
+    if (n != null && n.left != null) {
+      n = n.left;
+      while (n != null) {
+        stack.push(n);
+        n = n.right;
+      }
+    } else {
+      stack.pop();
+      while (stack.length > 0 && stack[stack.length - 1].left === n) {
+        n = stack[stack.length - 1];
+        stack.pop();
+      }
+    }
+  }
+
+  /**
+   * Checks if there is a previous element
+   */
+  get hasPrev() {
+    const stack = this.stack;
+    if (stack.length === 0) {
+      return false;
+    }
+    if (stack[stack.length - 1].left != null) {
+      return true;
+    }
+    for (let s = stack.length - 1; s > 0; --s) {
+      if (stack[s - 1].right === stack[s]) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/** @internal */
+const Color = {
+  Red: 0,
+  Black: 1 << 0
+};
+/** @internal */
+class Node {
+  constructor(color, key, value, left, right, count) {
+    this.color = color;
+    this.key = key;
+    this.value = value;
+    this.left = left;
+    this.right = right;
+    this.count = count;
+  }
+}
+
+/** @internal */
+function clone(node) {
+  return new Node(node.color, node.key, node.value, node.left, node.right, node.count);
+}
+
+/** @internal */
+function swap(n, v) {
+  n.key = v.key;
+  n.value = v.value;
+  n.left = v.left;
+  n.right = v.right;
+  n.color = v.color;
+  n.count = v.count;
+}
+
+/** @internal */
+function repaint(node, color) {
+  return new Node(color, node.key, node.value, node.left, node.right, node.count);
+}
+
+/** @internal */
+function recount(node) {
+  node.count = 1 + (node.left?.count ?? 0) + (node.right?.count ?? 0);
+}
+
+const RedBlackTreeSymbolKey = "effect/RedBlackTree";
+
+/** @internal */
+const RedBlackTreeTypeId = /*#__PURE__*/Symbol.for(RedBlackTreeSymbolKey);
+
+/** @internal */
+
+const RedBlackTreeProto = {
+  [RedBlackTreeTypeId]: RedBlackTreeTypeId,
+  [Hash_dist_effectHash.symbol]() {
+    return Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(RedBlackTreeSymbolKey))(Hash_dist_effectHash.array(Array.from(this)));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    if (isRedBlackTree$1(that)) {
+      if ((this._root?.count ?? 0) !== (that._root?.count ?? 0)) {
+        return false;
+      }
+      return Equal_dist_effectEqual.equals(Array.from(this), Array.from(that));
+    }
+    return false;
+  },
+  [Symbol.iterator]() {
+    const stack = [];
+    let n = this._root;
+    while (n != null) {
+      stack.push(n);
+      n = n.left;
+    }
+    return new RedBlackTreeIterator(this, stack, Direction$1.Forward);
+  },
+  toString() {
+    return Inspectable_dist_effectInspectable.toString(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "RedBlackTree",
+      values: Array.from(this).map(Inspectable_dist_effectInspectable.toJSON)
+    };
+  },
+  [Inspectable_dist_effectInspectable.NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  }
+};
+const makeImpl = (ord, root) => {
+  const tree = Object.create(RedBlackTreeProto);
+  tree._ord = ord;
+  tree._root = root;
+  return tree;
+};
+
+/** @internal */
+const isRedBlackTree$1 = u => Predicate_dist_effectPredicate.isObject(u) && RedBlackTreeTypeId in u;
+
+/** @internal */
+const empty$1 = ord => makeImpl(ord, undefined);
+
+/** @internal */
+const fromIterable$1 = ord => entries => {
+  let tree = empty$1(ord);
+  for (const [key, value] of entries) {
+    tree = insert$1(tree, key, value);
+  }
+  return tree;
+};
+
+/** @internal */
+const make$1 = ord => (...entries) => {
+  return fromIterable$1(ord)(entries);
+};
+
+/** @internal */
+const atBackwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, index) => at$1(self, index, Direction$1.Backward));
+
+/** @internal */
+const atForwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, index) => at$1(self, index, Direction$1.Forward));
+const at$1 = (self, index, direction) => {
+  return {
+    [Symbol.iterator]: () => {
+      if (index < 0) {
+        return new RedBlackTreeIterator(self, [], direction);
+      }
+      let node = self._root;
+      const stack = [];
+      while (node !== undefined) {
+        stack.push(node);
+        if (node.left !== undefined) {
+          if (index < node.left.count) {
+            node = node.left;
+            continue;
+          }
+          index -= node.left.count;
+        }
+        if (!index) {
+          return new RedBlackTreeIterator(self, stack, direction);
+        }
+        index -= 1;
+        if (node.right !== undefined) {
+          if (index >= node.right.count) {
+            break;
+          }
+          node = node.right;
+        } else {
+          break;
+        }
+      }
+      return new RedBlackTreeIterator(self, [], direction);
+    }
+  };
+};
+
+/** @internal */
+const findAll$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => {
+  const stack = [];
+  let node = self._root;
+  let result = Chunk_dist_effectChunk.empty();
+  while (node !== undefined || stack.length > 0) {
+    if (node) {
+      stack.push(node);
+      node = node.left;
+    } else {
+      const current = stack.pop();
+      if (Equal_dist_effectEqual.equals(key, current.key)) {
+        result = Chunk_dist_effectChunk.prepend(current.value)(result);
+      }
+      node = current.right;
+    }
+  }
+  return result;
+});
+
+/** @internal */
+const findFirst$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => {
+  const cmp = self._ord;
+  let node = self._root;
+  while (node !== undefined) {
+    const d = cmp(key, node.key);
+    if (Equal_dist_effectEqual.equals(key, node.key)) {
+      return Option_dist_effectOption.some(node.value);
+    }
+    if (d <= 0) {
+      node = node.left;
+    } else {
+      node = node.right;
+    }
+  }
+  return Option_dist_effectOption.none();
+});
+
+/** @internal */
+const first$1 = self => {
+  let node = self._root;
+  let current = self._root;
+  while (node !== undefined) {
+    current = node;
+    node = node.left;
+  }
+  return current ? Option_dist_effectOption.some([current.key, current.value]) : Option_dist_effectOption.none();
+};
+
+/** @internal */
+const getAt$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, index) => {
+  if (index < 0) {
+    return Option_dist_effectOption.none();
+  }
+  let root = self._root;
+  let node = undefined;
+  while (root !== undefined) {
+    node = root;
+    if (root.left) {
+      if (index < root.left.count) {
+        root = root.left;
+        continue;
+      }
+      index -= root.left.count;
+    }
+    if (!index) {
+      return Option_dist_effectOption.some([node.key, node.value]);
+    }
+    index -= 1;
+    if (root.right) {
+      if (index >= root.right.count) {
+        break;
+      }
+      root = root.right;
+    } else {
+      break;
+    }
+  }
+  return Option_dist_effectOption.none();
+});
+
+/** @internal */
+const getOrder$1 = tree => tree._ord;
+
+/** @internal */
+const has$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => Option_dist_effectOption.isSome(findFirst$1(self, key)));
+
+/** @internal */
+const insert$1 = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, key, value) => {
+  const cmp = self._ord;
+  // Find point to insert new node at
+  let n = self._root;
+  const n_stack = [];
+  const d_stack = [];
+  while (n != null) {
+    const d = cmp(key, n.key);
+    n_stack.push(n);
+    d_stack.push(d);
+    if (d <= 0) {
+      n = n.left;
+    } else {
+      n = n.right;
+    }
+  }
+  // Rebuild path to leaf node
+  n_stack.push(new Node(Color.Red, key, value, undefined, undefined, 1));
+  for (let s = n_stack.length - 2; s >= 0; --s) {
+    const n2 = n_stack[s];
+    if (d_stack[s] <= 0) {
+      n_stack[s] = new Node(n2.color, n2.key, n2.value, n_stack[s + 1], n2.right, n2.count + 1);
+    } else {
+      n_stack[s] = new Node(n2.color, n2.key, n2.value, n2.left, n_stack[s + 1], n2.count + 1);
+    }
+  }
+  // Rebalance tree using rotations
+  for (let s = n_stack.length - 1; s > 1; --s) {
+    const p = n_stack[s - 1];
+    const n3 = n_stack[s];
+    if (p.color === Color.Black || n3.color === Color.Black) {
+      break;
+    }
+    const pp = n_stack[s - 2];
+    if (pp.left === p) {
+      if (p.left === n3) {
+        const y = pp.right;
+        if (y && y.color === Color.Red) {
+          p.color = Color.Black;
+          pp.right = repaint(y, Color.Black);
+          pp.color = Color.Red;
+          s -= 1;
+        } else {
+          pp.color = Color.Red;
+          pp.left = p.right;
+          p.color = Color.Black;
+          p.right = pp;
+          n_stack[s - 2] = p;
+          n_stack[s - 1] = n3;
+          recount(pp);
+          recount(p);
+          if (s >= 3) {
+            const ppp = n_stack[s - 3];
+            if (ppp.left === pp) {
+              ppp.left = p;
+            } else {
+              ppp.right = p;
+            }
+          }
+          break;
+        }
+      } else {
+        const y = pp.right;
+        if (y && y.color === Color.Red) {
+          p.color = Color.Black;
+          pp.right = repaint(y, Color.Black);
+          pp.color = Color.Red;
+          s -= 1;
+        } else {
+          p.right = n3.left;
+          pp.color = Color.Red;
+          pp.left = n3.right;
+          n3.color = Color.Black;
+          n3.left = p;
+          n3.right = pp;
+          n_stack[s - 2] = n3;
+          n_stack[s - 1] = p;
+          recount(pp);
+          recount(p);
+          recount(n3);
+          if (s >= 3) {
+            const ppp = n_stack[s - 3];
+            if (ppp.left === pp) {
+              ppp.left = n3;
+            } else {
+              ppp.right = n3;
+            }
+          }
+          break;
+        }
+      }
+    } else {
+      if (p.right === n3) {
+        const y = pp.left;
+        if (y && y.color === Color.Red) {
+          p.color = Color.Black;
+          pp.left = repaint(y, Color.Black);
+          pp.color = Color.Red;
+          s -= 1;
+        } else {
+          pp.color = Color.Red;
+          pp.right = p.left;
+          p.color = Color.Black;
+          p.left = pp;
+          n_stack[s - 2] = p;
+          n_stack[s - 1] = n3;
+          recount(pp);
+          recount(p);
+          if (s >= 3) {
+            const ppp = n_stack[s - 3];
+            if (ppp.right === pp) {
+              ppp.right = p;
+            } else {
+              ppp.left = p;
+            }
+          }
+          break;
+        }
+      } else {
+        const y = pp.left;
+        if (y && y.color === Color.Red) {
+          p.color = Color.Black;
+          pp.left = repaint(y, Color.Black);
+          pp.color = Color.Red;
+          s -= 1;
+        } else {
+          p.left = n3.right;
+          pp.color = Color.Red;
+          pp.right = n3.left;
+          n3.color = Color.Black;
+          n3.right = p;
+          n3.left = pp;
+          n_stack[s - 2] = n3;
+          n_stack[s - 1] = p;
+          recount(pp);
+          recount(p);
+          recount(n3);
+          if (s >= 3) {
+            const ppp = n_stack[s - 3];
+            if (ppp.right === pp) {
+              ppp.right = n3;
+            } else {
+              ppp.left = n3;
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  // Return new tree
+  n_stack[0].color = Color.Black;
+  return makeImpl(self._ord, n_stack[0]);
+});
+
+/** @internal */
+const keysForward = self => keys$1(self, Direction$1.Forward);
+
+/** @internal */
+const keysBackward = self => keys$1(self, Direction$1.Backward);
+const keys$1 = (self, direction) => {
+  const begin = self[Symbol.iterator]();
+  let count = 0;
+  return {
+    [Symbol.iterator]: () => keys$1(self, direction),
+    next: () => {
+      count++;
+      const entry = begin.key;
+      if (direction === Direction$1.Forward) {
+        begin.moveNext();
+      } else {
+        begin.movePrev();
+      }
+      switch (entry._tag) {
+        case "None":
+          {
+            return {
+              done: true,
+              value: count
+            };
+          }
+        case "Some":
+          {
+            return {
+              done: false,
+              value: entry.value
+            };
+          }
+      }
+    }
+  };
+};
+
+/** @internal */
+const last$1 = self => {
+  let node = self._root;
+  let current = self._root;
+  while (node !== undefined) {
+    current = node;
+    node = node.right;
+  }
+  return current ? Option_dist_effectOption.some([current.key, current.value]) : Option_dist_effectOption.none();
+};
+
+/** @internal */
+const reversed$1 = self => {
+  return {
+    [Symbol.iterator]: () => {
+      const stack = [];
+      let node = self._root;
+      while (node !== undefined) {
+        stack.push(node);
+        node = node.right;
+      }
+      return new RedBlackTreeIterator(self, stack, Direction$1.Backward);
+    }
+  };
+};
+
+/** @internal */
+const greaterThanBackwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => greaterThan$1(self, key, Direction$1.Backward));
+
+/** @internal */
+const greaterThanForwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => greaterThan$1(self, key, Direction$1.Forward));
+const greaterThan$1 = (self, key, direction) => {
+  return {
+    [Symbol.iterator]: () => {
+      const cmp = self._ord;
+      let node = self._root;
+      const stack = [];
+      let last_ptr = 0;
+      while (node !== undefined) {
+        const d = cmp(key, node.key);
+        stack.push(node);
+        if (d < 0) {
+          last_ptr = stack.length;
+        }
+        if (d < 0) {
+          node = node.left;
+        } else {
+          node = node.right;
+        }
+      }
+      stack.length = last_ptr;
+      return new RedBlackTreeIterator(self, stack, direction);
+    }
+  };
+};
+
+/** @internal */
+const greaterThanEqualBackwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => greaterThanEqual$1(self, key, Direction$1.Backward));
+
+/** @internal */
+const greaterThanEqualForwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => greaterThanEqual$1(self, key, Direction$1.Forward));
+const greaterThanEqual$1 = (self, key, direction = Direction$1.Forward) => {
+  return {
+    [Symbol.iterator]: () => {
+      const cmp = self._ord;
+      let node = self._root;
+      const stack = [];
+      let last_ptr = 0;
+      while (node !== undefined) {
+        const d = cmp(key, node.key);
+        stack.push(node);
+        if (d <= 0) {
+          last_ptr = stack.length;
+        }
+        if (d <= 0) {
+          node = node.left;
+        } else {
+          node = node.right;
+        }
+      }
+      stack.length = last_ptr;
+      return new RedBlackTreeIterator(self, stack, direction);
+    }
+  };
+};
+
+/** @internal */
+const lessThanBackwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => lessThan$1(self, key, Direction$1.Backward));
+
+/** @internal */
+const lessThanForwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => lessThan$1(self, key, Direction$1.Forward));
+const lessThan$1 = (self, key, direction) => {
+  return {
+    [Symbol.iterator]: () => {
+      const cmp = self._ord;
+      let node = self._root;
+      const stack = [];
+      let last_ptr = 0;
+      while (node !== undefined) {
+        const d = cmp(key, node.key);
+        stack.push(node);
+        if (d > 0) {
+          last_ptr = stack.length;
+        }
+        if (d <= 0) {
+          node = node.left;
+        } else {
+          node = node.right;
+        }
+      }
+      stack.length = last_ptr;
+      return new RedBlackTreeIterator(self, stack, direction);
+    }
+  };
+};
+
+/** @internal */
+const lessThanEqualBackwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => lessThanEqual$1(self, key, Direction$1.Backward));
+
+/** @internal */
+const lessThanEqualForwards = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => lessThanEqual$1(self, key, Direction$1.Forward));
+const lessThanEqual$1 = (self, key, direction) => {
+  return {
+    [Symbol.iterator]: () => {
+      const cmp = self._ord;
+      let node = self._root;
+      const stack = [];
+      let last_ptr = 0;
+      while (node !== undefined) {
+        const d = cmp(key, node.key);
+        stack.push(node);
+        if (d >= 0) {
+          last_ptr = stack.length;
+        }
+        if (d < 0) {
+          node = node.left;
+        } else {
+          node = node.right;
+        }
+      }
+      stack.length = last_ptr;
+      return new RedBlackTreeIterator(self, stack, direction);
+    }
+  };
+};
+
+/** @internal */
+const forEach$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const root = self._root;
+  if (root !== undefined) {
+    visitFull(root, (key, value) => {
+      f(key, value);
+      return Option_dist_effectOption.none();
+    });
+  }
+});
+
+/** @internal */
+const forEachGreaterThanEqual$1 = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, min, f) => {
+  const root = self._root;
+  const ord = self._ord;
+  if (root !== undefined) {
+    visitGreaterThanEqual(root, min, ord, (key, value) => {
+      f(key, value);
+      return Option_dist_effectOption.none();
+    });
+  }
+});
+
+/** @internal */
+const forEachLessThan$1 = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, max, f) => {
+  const root = self._root;
+  const ord = self._ord;
+  if (root !== undefined) {
+    visitLessThan(root, max, ord, (key, value) => {
+      f(key, value);
+      return Option_dist_effectOption.none();
+    });
+  }
+});
+
+/** @internal */
+const forEachBetween$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  body,
+  max,
+  min
+}) => {
+  const root = self._root;
+  const ord = self._ord;
+  if (root) {
+    visitBetween(root, min, max, ord, (key, value) => {
+      body(key, value);
+      return Option_dist_effectOption.none();
+    });
+  }
+});
+
+/** @internal */
+const reduce$1 = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, f) => {
+  let accumulator = zero;
+  for (const entry of self) {
+    accumulator = f(accumulator, entry[1], entry[0]);
+  }
+  return accumulator;
+});
+
+/** @internal */
+const removeFirst$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => {
+  if (!has$1(self, key)) {
+    return self;
+  }
+  const ord = self._ord;
+  const cmp = ord;
+  let node = self._root;
+  const stack = [];
+  while (node !== undefined) {
+    const d = cmp(key, node.key);
+    stack.push(node);
+    if (Equal_dist_effectEqual.equals(key, node.key)) {
+      node = undefined;
+    } else if (d <= 0) {
+      node = node.left;
+    } else {
+      node = node.right;
+    }
+  }
+  if (stack.length === 0) {
+    return self;
+  }
+  const cstack = new Array(stack.length);
+  let n = stack[stack.length - 1];
+  cstack[cstack.length - 1] = new Node(n.color, n.key, n.value, n.left, n.right, n.count);
+  for (let i = stack.length - 2; i >= 0; --i) {
+    n = stack[i];
+    if (n.left === stack[i + 1]) {
+      cstack[i] = new Node(n.color, n.key, n.value, cstack[i + 1], n.right, n.count);
+    } else {
+      cstack[i] = new Node(n.color, n.key, n.value, n.left, cstack[i + 1], n.count);
+    }
+  }
+  // Get node
+  n = cstack[cstack.length - 1];
+  // If not leaf, then swap with previous node
+  if (n.left !== undefined && n.right !== undefined) {
+    // First walk to previous leaf
+    const split = cstack.length;
+    n = n.left;
+    while (n.right != null) {
+      cstack.push(n);
+      n = n.right;
+    }
+    // Copy path to leaf
+    const v = cstack[split - 1];
+    cstack.push(new Node(n.color, v.key, v.value, n.left, n.right, n.count));
+    cstack[split - 1].key = n.key;
+    cstack[split - 1].value = n.value;
+    // Fix up stack
+    for (let i = cstack.length - 2; i >= split; --i) {
+      n = cstack[i];
+      cstack[i] = new Node(n.color, n.key, n.value, n.left, cstack[i + 1], n.count);
+    }
+    cstack[split - 1].left = cstack[split];
+  }
+
+  // Remove leaf node
+  n = cstack[cstack.length - 1];
+  if (n.color === Color.Red) {
+    // Easy case: removing red leaf
+    const p = cstack[cstack.length - 2];
+    if (p.left === n) {
+      p.left = undefined;
+    } else if (p.right === n) {
+      p.right = undefined;
+    }
+    cstack.pop();
+    for (let i = 0; i < cstack.length; ++i) {
+      cstack[i].count--;
+    }
+    return makeImpl(ord, cstack[0]);
+  } else {
+    if (n.left !== undefined || n.right !== undefined) {
+      // Second easy case:  Single child black parent
+      if (n.left !== undefined) {
+        swap(n, n.left);
+      } else if (n.right !== undefined) {
+        swap(n, n.right);
+      }
+      // Child must be red, so repaint it black to balance color
+      n.color = Color.Black;
+      for (let i = 0; i < cstack.length - 1; ++i) {
+        cstack[i].count--;
+      }
+      return makeImpl(ord, cstack[0]);
+    } else if (cstack.length === 1) {
+      // Third easy case: root
+      return makeImpl(ord, undefined);
+    } else {
+      // Hard case: Repaint n, and then do some nasty stuff
+      for (let i = 0; i < cstack.length; ++i) {
+        cstack[i].count--;
+      }
+      const parent = cstack[cstack.length - 2];
+      fixDoubleBlack(cstack);
+      // Fix up links
+      if (parent.left === n) {
+        parent.left = undefined;
+      } else {
+        parent.right = undefined;
+      }
+    }
+  }
+  return makeImpl(ord, cstack[0]);
+});
+
+/** @internal */
+const size$1 = self => self._root?.count ?? 0;
+
+/** @internal */
+const valuesForward = self => values$1(self, Direction$1.Forward);
+
+/** @internal */
+const valuesBackward = self => values$1(self, Direction$1.Backward);
+
+/** @internal */
+const values$1 = (self, direction) => {
+  const begin = self[Symbol.iterator]();
+  let count = 0;
+  return {
+    [Symbol.iterator]: () => values$1(self, direction),
+    next: () => {
+      count++;
+      const entry = begin.value;
+      if (direction === Direction$1.Forward) {
+        begin.moveNext();
+      } else {
+        begin.movePrev();
+      }
+      switch (entry._tag) {
+        case "None":
+          {
+            return {
+              done: true,
+              value: count
+            };
+          }
+        case "Some":
+          {
+            return {
+              done: false,
+              value: entry.value
+            };
+          }
+      }
+    }
+  };
+};
+const visitFull = (node, visit) => {
+  let current = node;
+  let stack = undefined;
+  let done = false;
+  while (!done) {
+    if (current != null) {
+      stack = new Stack.Stack(current, stack);
+      current = current.left;
+    } else if (stack != null) {
+      const value = visit(stack.value.key, stack.value.value);
+      if (Option_dist_effectOption.isSome(value)) {
+        return value;
+      }
+      current = stack.value.right;
+      stack = stack.previous;
+    } else {
+      done = true;
+    }
+  }
+  return Option_dist_effectOption.none();
+};
+const visitGreaterThanEqual = (node, min, ord, visit) => {
+  let current = node;
+  let stack = undefined;
+  let done = false;
+  while (!done) {
+    if (current !== undefined) {
+      stack = new Stack.Stack(current, stack);
+      if (ord(min, current.key) <= 0) {
+        current = current.left;
+      } else {
+        current = undefined;
+      }
+    } else if (stack !== undefined) {
+      if (ord(min, stack.value.key) <= 0) {
+        const value = visit(stack.value.key, stack.value.value);
+        if (Option_dist_effectOption.isSome(value)) {
+          return value;
+        }
+      }
+      current = stack.value.right;
+      stack = stack.previous;
+    } else {
+      done = true;
+    }
+  }
+  return Option_dist_effectOption.none();
+};
+const visitLessThan = (node, max, ord, visit) => {
+  let current = node;
+  let stack = undefined;
+  let done = false;
+  while (!done) {
+    if (current !== undefined) {
+      stack = new Stack.Stack(current, stack);
+      current = current.left;
+    } else if (stack !== undefined && ord(max, stack.value.key) > 0) {
+      const value = visit(stack.value.key, stack.value.value);
+      if (Option_dist_effectOption.isSome(value)) {
+        return value;
+      }
+      current = stack.value.right;
+      stack = stack.previous;
+    } else {
+      done = true;
+    }
+  }
+  return Option_dist_effectOption.none();
+};
+const visitBetween = (node, min, max, ord, visit) => {
+  let current = node;
+  let stack = undefined;
+  let done = false;
+  while (!done) {
+    if (current !== undefined) {
+      stack = new Stack.Stack(current, stack);
+      if (ord(min, current.key) <= 0) {
+        current = current.left;
+      } else {
+        current = undefined;
+      }
+    } else if (stack !== undefined && ord(max, stack.value.key) > 0) {
+      if (ord(min, stack.value.key) <= 0) {
+        const value = visit(stack.value.key, stack.value.value);
+        if (Option_dist_effectOption.isSome(value)) {
+          return value;
+        }
+      }
+      current = stack.value.right;
+      stack = stack.previous;
+    } else {
+      done = true;
+    }
+  }
+  return Option_dist_effectOption.none();
+};
+
+/**
+ * Fix up a double black node in a Red-Black Tree.
+ */
+const fixDoubleBlack = stack => {
+  let n, p, s, z;
+  for (let i = stack.length - 1; i >= 0; --i) {
+    n = stack[i];
+    if (i === 0) {
+      n.color = Color.Black;
+      return;
+    }
+    p = stack[i - 1];
+    if (p.left === n) {
+      s = p.right;
+      if (s !== undefined && s.right !== undefined && s.right.color === Color.Red) {
+        s = p.right = clone(s);
+        z = s.right = clone(s.right);
+        p.right = s.left;
+        s.left = p;
+        s.right = z;
+        s.color = p.color;
+        n.color = Color.Black;
+        p.color = Color.Black;
+        z.color = Color.Black;
+        recount(p);
+        recount(s);
+        if (i > 1) {
+          const pp = stack[i - 2];
+          if (pp.left === p) {
+            pp.left = s;
+          } else {
+            pp.right = s;
+          }
+        }
+        stack[i - 1] = s;
+        return;
+      } else if (s !== undefined && s.left !== undefined && s.left.color === Color.Red) {
+        s = p.right = clone(s);
+        z = s.left = clone(s.left);
+        p.right = z.left;
+        s.left = z.right;
+        z.left = p;
+        z.right = s;
+        z.color = p.color;
+        p.color = Color.Black;
+        s.color = Color.Black;
+        n.color = Color.Black;
+        recount(p);
+        recount(s);
+        recount(z);
+        if (i > 1) {
+          const pp = stack[i - 2];
+          if (pp.left === p) {
+            pp.left = z;
+          } else {
+            pp.right = z;
+          }
+        }
+        stack[i - 1] = z;
+        return;
+      }
+      if (s !== undefined && s.color === Color.Black) {
+        if (p.color === Color.Red) {
+          p.color = Color.Black;
+          p.right = repaint(s, Color.Red);
+          return;
+        } else {
+          p.right = repaint(s, Color.Red);
+          continue;
+        }
+      } else if (s !== undefined) {
+        s = clone(s);
+        p.right = s.left;
+        s.left = p;
+        s.color = p.color;
+        p.color = Color.Red;
+        recount(p);
+        recount(s);
+        if (i > 1) {
+          const pp = stack[i - 2];
+          if (pp.left === p) {
+            pp.left = s;
+          } else {
+            pp.right = s;
+          }
+        }
+        stack[i - 1] = s;
+        stack[i] = p;
+        if (i + 1 < stack.length) {
+          stack[i + 1] = n;
+        } else {
+          stack.push(n);
+        }
+        i = i + 2;
+      }
+    } else {
+      s = p.left;
+      if (s !== undefined && s.left !== undefined && s.left.color === Color.Red) {
+        s = p.left = clone(s);
+        z = s.left = clone(s.left);
+        p.left = s.right;
+        s.right = p;
+        s.left = z;
+        s.color = p.color;
+        n.color = Color.Black;
+        p.color = Color.Black;
+        z.color = Color.Black;
+        recount(p);
+        recount(s);
+        if (i > 1) {
+          const pp = stack[i - 2];
+          if (pp.right === p) {
+            pp.right = s;
+          } else {
+            pp.left = s;
+          }
+        }
+        stack[i - 1] = s;
+        return;
+      } else if (s !== undefined && s.right !== undefined && s.right.color === Color.Red) {
+        s = p.left = clone(s);
+        z = s.right = clone(s.right);
+        p.left = z.right;
+        s.right = z.left;
+        z.right = p;
+        z.left = s;
+        z.color = p.color;
+        p.color = Color.Black;
+        s.color = Color.Black;
+        n.color = Color.Black;
+        recount(p);
+        recount(s);
+        recount(z);
+        if (i > 1) {
+          const pp = stack[i - 2];
+          if (pp.right === p) {
+            pp.right = z;
+          } else {
+            pp.left = z;
+          }
+        }
+        stack[i - 1] = z;
+        return;
+      }
+      if (s !== undefined && s.color === Color.Black) {
+        if (p.color === Color.Red) {
+          p.color = Color.Black;
+          p.left = repaint(s, Color.Red);
+          return;
+        } else {
+          p.left = repaint(s, Color.Red);
+          continue;
+        }
+      } else if (s !== undefined) {
+        s = clone(s);
+        p.left = s.right;
+        s.right = p;
+        s.color = p.color;
+        p.color = Color.Red;
+        recount(p);
+        recount(s);
+        if (i > 1) {
+          const pp = stack[i - 2];
+          if (pp.right === p) {
+            pp.right = s;
+          } else {
+            pp.left = s;
+          }
+        }
+        stack[i - 1] = s;
+        stack[i] = p;
+        if (i + 1 < stack.length) {
+          stack[i + 1] = n;
+        } else {
+          stack.push(n);
+        }
+        i = i + 2;
+      }
+    }
+  }
+};
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+
+/**
+ * @since 2.0.0
+ * @category constants
+ */
+const Direction = Direction$1;
+
+/**
+ * A Red-Black Tree.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+const isRedBlackTree = isRedBlackTree$1;
+
+/**
+ * Creates an empty `RedBlackTree`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty = empty$1;
+
+/**
+ * Constructs a new tree from an iterable of key-value pairs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIterable = fromIterable$1;
+
+/**
+ * Constructs a new `RedBlackTree` from the specified entries.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * Returns an iterator that points to the element at the specified index of the
+ * tree.
+ *
+ * **Note**: The iterator will run through elements in order.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const at = atForwards;
+
+/**
+ * Returns an iterator that points to the element at the specified index of the
+ * tree.
+ *
+ * **Note**: The iterator will run through elements in reverse order.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const atReversed = atBackwards;
+
+/**
+ * Finds all values in the tree associated with the specified key.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const findAll = findAll$1;
+
+/**
+ * Finds the first value in the tree associated with the specified key, if it exists.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const findFirst = findFirst$1;
+
+/**
+ * Returns the first entry in the tree, if it exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const first = first$1;
+
+/**
+ * Returns the element at the specified index within the tree or `None` if the
+ * specified index does not exist.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const getAt = getAt$1;
+
+/**
+ * Gets the `Order<K>` that the `RedBlackTree<K, V>` is using.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const getOrder = getOrder$1;
+
+/**
+ * Returns an iterator that traverse entries in order with keys greater than the
+ * specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const greaterThan = greaterThanForwards;
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys greater
+ * than the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const greaterThanReversed = greaterThanBackwards;
+
+/**
+ * Returns an iterator that traverse entries in order with keys greater than or
+ * equal to the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const greaterThanEqual = greaterThanEqualForwards;
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys greater
+ * than or equal to the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const greaterThanEqualReversed = greaterThanEqualBackwards;
+
+/**
+ * Finds the item with key, if it exists.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const has = has$1;
+
+/**
+ * Insert a new item into the tree.
+ *
+ * @since 2.0.0
+ */
+const insert = insert$1;
+
+/**
+ * Get all the keys present in the tree in order.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const keys = keysForward;
+
+/**
+ * Get all the keys present in the tree in reverse order.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const keysReversed = keysBackward;
+
+/**
+ * Returns the last entry in the tree, if it exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const last = last$1;
+
+/**
+ * Returns an iterator that traverse entries in order with keys less than the
+ * specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const lessThan = lessThanForwards;
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys less
+ * than the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const lessThanReversed = lessThanBackwards;
+
+/**
+ * Returns an iterator that traverse entries in order with keys less than or
+ * equal to the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const lessThanEqual = lessThanEqualForwards;
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys less
+ * than or equal to the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const lessThanEqualReversed = lessThanEqualBackwards;
+
+/**
+ * Execute the specified function for each node of the tree, in order.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const forEach = forEach$1;
+
+/**
+ * Visit each node of the tree in order with key greater then or equal to max.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const forEachGreaterThanEqual = forEachGreaterThanEqual$1;
+
+/**
+ * Visit each node of the tree in order with key lower then max.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const forEachLessThan = forEachLessThan$1;
+
+/**
+ * Visit each node of the tree in order with key lower than max and greater
+ * than or equal to min.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const forEachBetween = forEachBetween$1;
+
+/**
+ * Reduce a state over the entries of the tree.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduce = reduce$1;
+
+/**
+ * Removes the entry with the specified key, if it exists.
+ *
+ * @since 2.0.0
+ */
+const removeFirst = removeFirst$1;
+
+/**
+ * Traverse the tree in reverse order.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const reversed = reversed$1;
+
+/**
+ * Returns the size of the tree.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const size = size$1;
+
+/**
+ * Get all values present in the tree in order.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const values = valuesForward;
+
+/**
+ * Get all values present in the tree in reverse order.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const valuesReversed = valuesBackward;
+
+exports.Direction = Direction;
+exports.at = at;
+exports.atReversed = atReversed;
+exports.empty = empty;
+exports.findAll = findAll;
+exports.findFirst = findFirst;
+exports.first = first;
+exports.forEach = forEach;
+exports.forEachBetween = forEachBetween;
+exports.forEachGreaterThanEqual = forEachGreaterThanEqual;
+exports.forEachLessThan = forEachLessThan;
+exports.fromIterable = fromIterable;
+exports.getAt = getAt;
+exports.getOrder = getOrder;
+exports.greaterThan = greaterThan;
+exports.greaterThanEqual = greaterThanEqual;
+exports.greaterThanEqualReversed = greaterThanEqualReversed;
+exports.greaterThanReversed = greaterThanReversed;
+exports.has = has;
+exports.insert = insert;
+exports.isRedBlackTree = isRedBlackTree;
+exports.keys = keys;
+exports.keysReversed = keysReversed;
+exports.last = last;
+exports.lessThan = lessThan;
+exports.lessThanEqual = lessThanEqual;
+exports.lessThanEqualReversed = lessThanEqualReversed;
+exports.lessThanReversed = lessThanReversed;
+exports.make = make;
+exports.reduce = reduce;
+exports.removeFirst = removeFirst;
+exports.reversed = reversed;
+exports.size = size;
+exports.values = values;
+exports.valuesReversed = valuesReversed;