effect 2.0.0-next.35 → 2.0.0-next.37

package/dist/RedBlackTree-22839235.esm.js

@@ -0,0 +1,1632 @@
+import { p as prepend, e as empty$2 } from './Chunk-98371336.esm.js';
+import { e as equals, s as symbol$1 } from './Equal-7d4ae7e7.esm.js';
+import { d as dual } from './Function-52fb7d21.esm.js';
+import { s as symbol, c as combine, h as hash, a as array } from './Hash-039222d1.esm.js';
+import { t as toString, a as toJSON, N as NodeInspectSymbol } from './Inspectable-bda84223.esm.js';
+import { s as some, n as none, i as isSome } from './Option-1d073850.esm.js';
+import { S as Stack } from './Stack-765c2298.esm.js';
+import { p as pipeArguments } from './Pipeable-fe51dc02.esm.js';
+import { i as isObject } from './Predicate-52271838.esm.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 some(this.stack[this.stack.length - 1].key);
+    }
+    return none();
+  }
+
+  /**
+   * Returns the value
+   */
+  get value() {
+    if (this.stack.length > 0) {
+      return some(this.stack[this.stack.length - 1].value);
+    }
+    return none();
+  }
+
+  /**
+   * Returns the key
+   */
+  get entry() {
+    if (this.stack.length > 0) {
+      return some([this.stack[this.stack.length - 1].key, this.stack[this.stack.length - 1].value]);
+    }
+    return 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,
+  [symbol]() {
+    return combine(hash(RedBlackTreeSymbolKey))(array(Array.from(this)));
+  },
+  [symbol$1](that) {
+    if (isRedBlackTree$1(that)) {
+      if ((this._root?.count ?? 0) !== (that._root?.count ?? 0)) {
+        return false;
+      }
+      return 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 toString(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "RedBlackTree",
+      values: Array.from(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return 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 => 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__*/dual(2, (self, index) => at$1(self, index, Direction$1.Backward));
+
+/** @internal */
+const atForwards = /*#__PURE__*/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__*/dual(2, (self, key) => {
+  const stack = [];
+  let node = self._root;
+  let result = empty$2();
+  while (node !== undefined || stack.length > 0) {
+    if (node) {
+      stack.push(node);
+      node = node.left;
+    } else {
+      const current = stack.pop();
+      if (equals(key, current.key)) {
+        result = prepend(current.value)(result);
+      }
+      node = current.right;
+    }
+  }
+  return result;
+});
+
+/** @internal */
+const findFirst$1 = /*#__PURE__*/dual(2, (self, key) => {
+  const cmp = self._ord;
+  let node = self._root;
+  while (node !== undefined) {
+    const d = cmp(key, node.key);
+    if (equals(key, node.key)) {
+      return some(node.value);
+    }
+    if (d <= 0) {
+      node = node.left;
+    } else {
+      node = node.right;
+    }
+  }
+  return none();
+});
+
+/** @internal */
+const first$1 = self => {
+  let node = self._root;
+  let current = self._root;
+  while (node !== undefined) {
+    current = node;
+    node = node.left;
+  }
+  return current ? some([current.key, current.value]) : none();
+};
+
+/** @internal */
+const getAt$1 = /*#__PURE__*/dual(2, (self, index) => {
+  if (index < 0) {
+    return 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 some([node.key, node.value]);
+    }
+    index -= 1;
+    if (root.right) {
+      if (index >= root.right.count) {
+        break;
+      }
+      root = root.right;
+    } else {
+      break;
+    }
+  }
+  return none();
+});
+
+/** @internal */
+const getOrder$1 = tree => tree._ord;
+
+/** @internal */
+const has$1 = /*#__PURE__*/dual(2, (self, key) => isSome(findFirst$1(self, key)));
+
+/** @internal */
+const insert$1 = /*#__PURE__*/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 ? some([current.key, current.value]) : 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__*/dual(2, (self, key) => greaterThan$1(self, key, Direction$1.Backward));
+
+/** @internal */
+const greaterThanForwards = /*#__PURE__*/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__*/dual(2, (self, key) => greaterThanEqual$1(self, key, Direction$1.Backward));
+
+/** @internal */
+const greaterThanEqualForwards = /*#__PURE__*/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__*/dual(2, (self, key) => lessThan$1(self, key, Direction$1.Backward));
+
+/** @internal */
+const lessThanForwards = /*#__PURE__*/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__*/dual(2, (self, key) => lessThanEqual$1(self, key, Direction$1.Backward));
+
+/** @internal */
+const lessThanEqualForwards = /*#__PURE__*/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__*/dual(2, (self, f) => {
+  const root = self._root;
+  if (root !== undefined) {
+    visitFull(root, (key, value) => {
+      f(key, value);
+      return none();
+    });
+  }
+});
+
+/** @internal */
+const forEachGreaterThanEqual$1 = /*#__PURE__*/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 none();
+    });
+  }
+});
+
+/** @internal */
+const forEachLessThan$1 = /*#__PURE__*/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 none();
+    });
+  }
+});
+
+/** @internal */
+const forEachBetween$1 = /*#__PURE__*/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 none();
+    });
+  }
+});
+
+/** @internal */
+const reduce$1 = /*#__PURE__*/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__*/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 (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(current, stack);
+      current = current.left;
+    } else if (stack != null) {
+      const value = visit(stack.value.key, stack.value.value);
+      if (isSome(value)) {
+        return value;
+      }
+      current = stack.value.right;
+      stack = stack.previous;
+    } else {
+      done = true;
+    }
+  }
+  return none();
+};
+const visitGreaterThanEqual = (node, min, ord, visit) => {
+  let current = node;
+  let stack = undefined;
+  let done = false;
+  while (!done) {
+    if (current !== undefined) {
+      stack = new 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 (isSome(value)) {
+          return value;
+        }
+      }
+      current = stack.value.right;
+      stack = stack.previous;
+    } else {
+      done = true;
+    }
+  }
+  return none();
+};
+const visitLessThan = (node, max, ord, visit) => {
+  let current = node;
+  let stack = undefined;
+  let done = false;
+  while (!done) {
+    if (current !== undefined) {
+      stack = new 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 (isSome(value)) {
+        return value;
+      }
+      current = stack.value.right;
+      stack = stack.previous;
+    } else {
+      done = true;
+    }
+  }
+  return 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(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 (isSome(value)) {
+          return value;
+        }
+      }
+      current = stack.value.right;
+      stack = stack.previous;
+    } else {
+      done = true;
+    }
+  }
+  return 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 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category symbol
+ */
+
+/**
+ * @since 1.0.0
+ * @category constants
+ */
+const Direction = Direction$1;
+
+/**
+ * A Red-Black Tree.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+const isRedBlackTree = isRedBlackTree$1;
+
+/**
+ * Creates an empty `RedBlackTree`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const empty = empty$1;
+
+/**
+ * Constructs a new tree from an iterable of key-value pairs.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const fromIterable = fromIterable$1;
+
+/**
+ * Constructs a new `RedBlackTree` from the specified entries.
+ *
+ * @since 1.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 1.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 1.0.0
+ * @category traversing
+ */
+const atReversed = atBackwards;
+
+/**
+ * Finds all values in the tree associated with the specified key.
+ *
+ * @since 1.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 1.0.0
+ */
+const findFirst = findFirst$1;
+
+/**
+ * Returns the first entry in the tree, if it exists.
+ *
+ * @since 1.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 1.0.0
+ * @category elements
+ */
+const getAt = getAt$1;
+
+/**
+ * Gets the `Order<K>` that the `RedBlackTree<K, V>` is using.
+ *
+ * @since 1.0.0
+ * @category getters
+ */
+const getOrder = getOrder$1;
+
+/**
+ * Returns an iterator that traverse entries in order with keys greater than the
+ * specified key.
+ *
+ * @since 1.0.0
+ * @category traversing
+ */
+const greaterThan = greaterThanForwards;
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys greater
+ * than the specified key.
+ *
+ * @since 1.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 1.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 1.0.0
+ * @category traversing
+ */
+const greaterThanEqualReversed = greaterThanEqualBackwards;
+
+/**
+ * Finds the item with key, if it exists.
+ *
+ * @since 1.0.0
+ * @category elements
+ */
+const has = has$1;
+
+/**
+ * Insert a new item into the tree.
+ *
+ * @since 1.0.0
+ */
+const insert = insert$1;
+
+/**
+ * Get all the keys present in the tree in order.
+ *
+ * @since 1.0.0
+ * @category getters
+ */
+const keys = keysForward;
+
+/**
+ * Get all the keys present in the tree in reverse order.
+ *
+ * @since 1.0.0
+ * @category getters
+ */
+const keysReversed = keysBackward;
+
+/**
+ * Returns the last entry in the tree, if it exists.
+ *
+ * @since 1.0.0
+ * @category getters
+ */
+const last = last$1;
+
+/**
+ * Returns an iterator that traverse entries in order with keys less than the
+ * specified key.
+ *
+ * @since 1.0.0
+ * @category traversing
+ */
+const lessThan = lessThanForwards;
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys less
+ * than the specified key.
+ *
+ * @since 1.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 1.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 1.0.0
+ * @category traversing
+ */
+const lessThanEqualReversed = lessThanEqualBackwards;
+
+/**
+ * Execute the specified function for each node of the tree, in order.
+ *
+ * @since 1.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 1.0.0
+ * @category traversing
+ */
+const forEachGreaterThanEqual = forEachGreaterThanEqual$1;
+
+/**
+ * Visit each node of the tree in order with key lower then max.
+ *
+ * @since 1.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 1.0.0
+ * @category traversing
+ */
+const forEachBetween = forEachBetween$1;
+
+/**
+ * Reduce a state over the entries of the tree.
+ *
+ * @since 1.0.0
+ * @category folding
+ */
+const reduce = reduce$1;
+
+/**
+ * Removes the entry with the specified key, if it exists.
+ *
+ * @since 1.0.0
+ */
+const removeFirst = removeFirst$1;
+
+/**
+ * Traverse the tree in reverse order.
+ *
+ * @since 1.0.0
+ * @category traversing
+ */
+const reversed = reversed$1;
+
+/**
+ * Returns the size of the tree.
+ *
+ * @since 1.0.0
+ * @category getters
+ */
+const size = size$1;
+
+/**
+ * Get all values present in the tree in order.
+ *
+ * @since 1.0.0
+ * @category getters
+ */
+const values = valuesForward;
+
+/**
+ * Get all values present in the tree in reverse order.
+ *
+ * @since 1.0.0
+ * @category getters
+ */
+const valuesReversed = valuesBackward;
+
+var RedBlackTree = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Direction: Direction,
+  isRedBlackTree: isRedBlackTree,
+  empty: empty,
+  fromIterable: fromIterable,
+  make: make,
+  at: at,
+  atReversed: atReversed,
+  findAll: findAll,
+  findFirst: findFirst,
+  first: first,
+  getAt: getAt,
+  getOrder: getOrder,
+  greaterThan: greaterThan,
+  greaterThanReversed: greaterThanReversed,
+  greaterThanEqual: greaterThanEqual,
+  greaterThanEqualReversed: greaterThanEqualReversed,
+  has: has,
+  insert: insert,
+  keys: keys,
+  keysReversed: keysReversed,
+  last: last,
+  lessThan: lessThan,
+  lessThanReversed: lessThanReversed,
+  lessThanEqual: lessThanEqual,
+  lessThanEqualReversed: lessThanEqualReversed,
+  forEach: forEach,
+  forEachGreaterThanEqual: forEachGreaterThanEqual,
+  forEachLessThan: forEachLessThan,
+  forEachBetween: forEachBetween,
+  reduce: reduce,
+  removeFirst: removeFirst,
+  reversed: reversed,
+  size: size,
+  values: values,
+  valuesReversed: valuesReversed
+});
+
+export { lessThanReversed as A, lessThanEqual as B, lessThanEqualReversed as C, Direction as D, forEachGreaterThanEqual as E, forEachLessThan as F, forEachBetween as G, reversed as H, valuesReversed as I, RedBlackTree as R, forEach as a, findFirst as b, first as c, reduce as d, empty as e, fromIterable as f, getOrder as g, has as h, insert as i, isRedBlackTree as j, keys as k, at as l, make as m, atReversed as n, findAll as o, getAt as p, greaterThan as q, removeFirst as r, size as s, greaterThanReversed as t, greaterThanEqual as u, values as v, greaterThanEqualReversed as w, keysReversed as x, last as y, lessThan as z };