effect 2.0.0-next.37 → 2.0.0-next.39

package/dist/RedBlackTree-98a93ec6.cjs.dev.js

@@ -1,1669 +0,0 @@
-'use strict';
-
-var Chunk_dist_effectChunk = require('./Chunk-937f4423.cjs.dev.js');
-var Equal_dist_effectEqual = require('./Equal-8654b1af.cjs.dev.js');
-var Function_dist_effectFunction = require('./Function-fd10bde3.cjs.dev.js');
-var Hash_dist_effectHash = require('./Hash-9d5502e5.cjs.dev.js');
-var Inspectable_dist_effectInspectable = require('./Inspectable-654412c2.cjs.dev.js');
-var Option_dist_effectOption = require('./Option-837ae0da.cjs.dev.js');
-var Stack = require('./Stack-ada2d201.cjs.dev.js');
-var Pipeable_dist_effectPipeable = require('./Pipeable-ef202667.cjs.dev.js');
-var Predicate_dist_effectPredicate = require('./Predicate-54d8c8de.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 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
-});
-
-exports.Direction = Direction;
-exports.RedBlackTree = RedBlackTree;
-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;