effect 2.0.0-next.38 → 2.0.0-next.39

package/{dist/RedBlackTree-611b3b4c.esm.js → internal/RedBlackTree.esm.js}

@@ -1,255 +1,14 @@
-import { p as prepend, e as empty$2 } from './Chunk-4c1f4599.esm.js';
-import { e as equals, s as symbol$1 } from './Equal-2a99fde3.esm.js';
-import { d as dual } from './Function-12511160.esm.js';
-import { s as symbol, c as combine, h as hash, a as array } from './Hash-7910f34f.esm.js';
-import { t as toString, a as toJSON, N as NodeInspectSymbol } from './Inspectable-b0c51e90.esm.js';
-import { s as some, n as none, i as isSome } from './Option-df40d2b9.esm.js';
-import { S as Stack } from './Stack-765c2298.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-import { i as isObject } from './Predicate-6b61b95b.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);
-}
+import { prepend, empty as empty$1 } from '../Chunk/dist/effect-Chunk.esm.js';
+import { equals, symbol as symbol$1 } from '../Equal/dist/effect-Equal.esm.js';
+import { dual } from '../Function/dist/effect-Function.esm.js';
+import { symbol, combine, hash, array } from '../Hash/dist/effect-Hash.esm.js';
+import { toString, toJSON, NodeInspectSymbol } from '../Inspectable/dist/effect-Inspectable.esm.js';
+import { Direction, RedBlackTreeIterator } from './RedBlackTree/iterator.esm.js';
+import { Node, Color, repaint, recount, swap, clone } from './RedBlackTree/node.esm.js';
+import { Stack } from './Stack.esm.js';
+import { some, none, isSome } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { isObject } from '../Predicate/dist/effect-Predicate.esm.js';
 
 const RedBlackTreeSymbolKey = "effect/RedBlackTree";
 
@@ -264,7 +23,7 @@ const RedBlackTreeProto = {
     return combine(hash(RedBlackTreeSymbolKey))(array(Array.from(this)));
   },
   [symbol$1](that) {
-    if (isRedBlackTree$1(that)) {
+    if (isRedBlackTree(that)) {
       if ((this._root?.count ?? 0) !== (that._root?.count ?? 0)) {
         return false;
       }
@@ -279,7 +38,7 @@ const RedBlackTreeProto = {
       stack.push(n);
       n = n.left;
     }
-    return new RedBlackTreeIterator(this, stack, Direction$1.Forward);
+    return new RedBlackTreeIterator(this, stack, Direction.Forward);
   },
   toString() {
     return toString(this.toJSON());
@@ -305,31 +64,31 @@ const makeImpl = (ord, root) => {
 };
 
 /** @internal */
-const isRedBlackTree$1 = u => isObject(u) && RedBlackTreeTypeId in u;
+const isRedBlackTree = u => isObject(u) && RedBlackTreeTypeId in u;
 
 /** @internal */
-const empty$1 = ord => makeImpl(ord, undefined);
+const empty = ord => makeImpl(ord, undefined);
 
 /** @internal */
-const fromIterable$1 = ord => entries => {
-  let tree = empty$1(ord);
+const fromIterable = ord => entries => {
+  let tree = empty(ord);
   for (const [key, value] of entries) {
-    tree = insert$1(tree, key, value);
+    tree = insert(tree, key, value);
   }
   return tree;
 };
 
 /** @internal */
-const make$1 = ord => (...entries) => {
-  return fromIterable$1(ord)(entries);
+const make = ord => (...entries) => {
+  return fromIterable(ord)(entries);
 };
 
 /** @internal */
-const atBackwards = /*#__PURE__*/dual(2, (self, index) => at$1(self, index, Direction$1.Backward));
+const atBackwards = /*#__PURE__*/dual(2, (self, index) => at(self, index, Direction.Backward));
 
 /** @internal */
-const atForwards = /*#__PURE__*/dual(2, (self, index) => at$1(self, index, Direction$1.Forward));
-const at$1 = (self, index, direction) => {
+const atForwards = /*#__PURE__*/dual(2, (self, index) => at(self, index, Direction.Forward));
+const at = (self, index, direction) => {
   return {
     [Symbol.iterator]: () => {
       if (index < 0) {
@@ -365,10 +124,10 @@ const at$1 = (self, index, direction) => {
 };
 
 /** @internal */
-const findAll$1 = /*#__PURE__*/dual(2, (self, key) => {
+const findAll = /*#__PURE__*/dual(2, (self, key) => {
   const stack = [];
   let node = self._root;
-  let result = empty$2();
+  let result = empty$1();
   while (node !== undefined || stack.length > 0) {
     if (node) {
       stack.push(node);
@@ -385,7 +144,7 @@ const findAll$1 = /*#__PURE__*/dual(2, (self, key) => {
 });
 
 /** @internal */
-const findFirst$1 = /*#__PURE__*/dual(2, (self, key) => {
+const findFirst = /*#__PURE__*/dual(2, (self, key) => {
   const cmp = self._ord;
   let node = self._root;
   while (node !== undefined) {
@@ -403,7 +162,7 @@ const findFirst$1 = /*#__PURE__*/dual(2, (self, key) => {
 });
 
 /** @internal */
-const first$1 = self => {
+const first = self => {
   let node = self._root;
   let current = self._root;
   while (node !== undefined) {
@@ -414,7 +173,7 @@ const first$1 = self => {
 };
 
 /** @internal */
-const getAt$1 = /*#__PURE__*/dual(2, (self, index) => {
+const getAt = /*#__PURE__*/dual(2, (self, index) => {
   if (index < 0) {
     return none();
   }
@@ -446,13 +205,13 @@ const getAt$1 = /*#__PURE__*/dual(2, (self, index) => {
 });
 
 /** @internal */
-const getOrder$1 = tree => tree._ord;
+const getOrder = tree => tree._ord;
 
 /** @internal */
-const has$1 = /*#__PURE__*/dual(2, (self, key) => isSome(findFirst$1(self, key)));
+const has = /*#__PURE__*/dual(2, (self, key) => isSome(findFirst(self, key)));
 
 /** @internal */
-const insert$1 = /*#__PURE__*/dual(3, (self, key, value) => {
+const insert = /*#__PURE__*/dual(3, (self, key, value) => {
   const cmp = self._ord;
   // Find point to insert new node at
   let n = self._root;
@@ -608,19 +367,19 @@ const insert$1 = /*#__PURE__*/dual(3, (self, key, value) => {
 });
 
 /** @internal */
-const keysForward = self => keys$1(self, Direction$1.Forward);
+const keysForward = self => keys(self, Direction.Forward);
 
 /** @internal */
-const keysBackward = self => keys$1(self, Direction$1.Backward);
-const keys$1 = (self, direction) => {
+const keysBackward = self => keys(self, Direction.Backward);
+const keys = (self, direction) => {
   const begin = self[Symbol.iterator]();
   let count = 0;
   return {
-    [Symbol.iterator]: () => keys$1(self, direction),
+    [Symbol.iterator]: () => keys(self, direction),
     next: () => {
       count++;
       const entry = begin.key;
-      if (direction === Direction$1.Forward) {
+      if (direction === Direction.Forward) {
         begin.moveNext();
       } else {
         begin.movePrev();
@@ -646,7 +405,7 @@ const keys$1 = (self, direction) => {
 };
 
 /** @internal */
-const last$1 = self => {
+const last = self => {
   let node = self._root;
   let current = self._root;
   while (node !== undefined) {
@@ -657,7 +416,7 @@ const last$1 = self => {
 };
 
 /** @internal */
-const reversed$1 = self => {
+const reversed = self => {
   return {
     [Symbol.iterator]: () => {
       const stack = [];
@@ -666,17 +425,17 @@ const reversed$1 = self => {
         stack.push(node);
         node = node.right;
       }
-      return new RedBlackTreeIterator(self, stack, Direction$1.Backward);
+      return new RedBlackTreeIterator(self, stack, Direction.Backward);
     }
   };
 };
 
 /** @internal */
-const greaterThanBackwards = /*#__PURE__*/dual(2, (self, key) => greaterThan$1(self, key, Direction$1.Backward));
+const greaterThanBackwards = /*#__PURE__*/dual(2, (self, key) => greaterThan(self, key, Direction.Backward));
 
 /** @internal */
-const greaterThanForwards = /*#__PURE__*/dual(2, (self, key) => greaterThan$1(self, key, Direction$1.Forward));
-const greaterThan$1 = (self, key, direction) => {
+const greaterThanForwards = /*#__PURE__*/dual(2, (self, key) => greaterThan(self, key, Direction.Forward));
+const greaterThan = (self, key, direction) => {
   return {
     [Symbol.iterator]: () => {
       const cmp = self._ord;
@@ -702,11 +461,11 @@ const greaterThan$1 = (self, key, direction) => {
 };
 
 /** @internal */
-const greaterThanEqualBackwards = /*#__PURE__*/dual(2, (self, key) => greaterThanEqual$1(self, key, Direction$1.Backward));
+const greaterThanEqualBackwards = /*#__PURE__*/dual(2, (self, key) => greaterThanEqual(self, key, Direction.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) => {
+const greaterThanEqualForwards = /*#__PURE__*/dual(2, (self, key) => greaterThanEqual(self, key, Direction.Forward));
+const greaterThanEqual = (self, key, direction = Direction.Forward) => {
   return {
     [Symbol.iterator]: () => {
       const cmp = self._ord;
@@ -732,11 +491,11 @@ const greaterThanEqual$1 = (self, key, direction = Direction$1.Forward) => {
 };
 
 /** @internal */
-const lessThanBackwards = /*#__PURE__*/dual(2, (self, key) => lessThan$1(self, key, Direction$1.Backward));
+const lessThanBackwards = /*#__PURE__*/dual(2, (self, key) => lessThan(self, key, Direction.Backward));
 
 /** @internal */
-const lessThanForwards = /*#__PURE__*/dual(2, (self, key) => lessThan$1(self, key, Direction$1.Forward));
-const lessThan$1 = (self, key, direction) => {
+const lessThanForwards = /*#__PURE__*/dual(2, (self, key) => lessThan(self, key, Direction.Forward));
+const lessThan = (self, key, direction) => {
   return {
     [Symbol.iterator]: () => {
       const cmp = self._ord;
@@ -762,11 +521,11 @@ const lessThan$1 = (self, key, direction) => {
 };
 
 /** @internal */
-const lessThanEqualBackwards = /*#__PURE__*/dual(2, (self, key) => lessThanEqual$1(self, key, Direction$1.Backward));
+const lessThanEqualBackwards = /*#__PURE__*/dual(2, (self, key) => lessThanEqual(self, key, Direction.Backward));
 
 /** @internal */
-const lessThanEqualForwards = /*#__PURE__*/dual(2, (self, key) => lessThanEqual$1(self, key, Direction$1.Forward));
-const lessThanEqual$1 = (self, key, direction) => {
+const lessThanEqualForwards = /*#__PURE__*/dual(2, (self, key) => lessThanEqual(self, key, Direction.Forward));
+const lessThanEqual = (self, key, direction) => {
   return {
     [Symbol.iterator]: () => {
       const cmp = self._ord;
@@ -792,7 +551,7 @@ const lessThanEqual$1 = (self, key, direction) => {
 };
 
 /** @internal */
-const forEach$1 = /*#__PURE__*/dual(2, (self, f) => {
+const forEach = /*#__PURE__*/dual(2, (self, f) => {
   const root = self._root;
   if (root !== undefined) {
     visitFull(root, (key, value) => {
@@ -803,7 +562,7 @@ const forEach$1 = /*#__PURE__*/dual(2, (self, f) => {
 });
 
 /** @internal */
-const forEachGreaterThanEqual$1 = /*#__PURE__*/dual(3, (self, min, f) => {
+const forEachGreaterThanEqual = /*#__PURE__*/dual(3, (self, min, f) => {
   const root = self._root;
   const ord = self._ord;
   if (root !== undefined) {
@@ -815,7 +574,7 @@ const forEachGreaterThanEqual$1 = /*#__PURE__*/dual(3, (self, min, f) => {
 });
 
 /** @internal */
-const forEachLessThan$1 = /*#__PURE__*/dual(3, (self, max, f) => {
+const forEachLessThan = /*#__PURE__*/dual(3, (self, max, f) => {
   const root = self._root;
   const ord = self._ord;
   if (root !== undefined) {
@@ -827,7 +586,7 @@ const forEachLessThan$1 = /*#__PURE__*/dual(3, (self, max, f) => {
 });
 
 /** @internal */
-const forEachBetween$1 = /*#__PURE__*/dual(2, (self, {
+const forEachBetween = /*#__PURE__*/dual(2, (self, {
   body,
   max,
   min
@@ -843,7 +602,7 @@ const forEachBetween$1 = /*#__PURE__*/dual(2, (self, {
 });
 
 /** @internal */
-const reduce$1 = /*#__PURE__*/dual(3, (self, zero, f) => {
+const reduce = /*#__PURE__*/dual(3, (self, zero, f) => {
   let accumulator = zero;
   for (const entry of self) {
     accumulator = f(accumulator, entry[1], entry[0]);
@@ -852,8 +611,8 @@ const reduce$1 = /*#__PURE__*/dual(3, (self, zero, f) => {
 });
 
 /** @internal */
-const removeFirst$1 = /*#__PURE__*/dual(2, (self, key) => {
-  if (!has$1(self, key)) {
+const removeFirst = /*#__PURE__*/dual(2, (self, key) => {
+  if (!has(self, key)) {
     return self;
   }
   const ord = self._ord;
@@ -960,24 +719,24 @@ const removeFirst$1 = /*#__PURE__*/dual(2, (self, key) => {
 });
 
 /** @internal */
-const size$1 = self => self._root?.count ?? 0;
+const size = self => self._root?.count ?? 0;
 
 /** @internal */
-const valuesForward = self => values$1(self, Direction$1.Forward);
+const valuesForward = self => values(self, Direction.Forward);
 
 /** @internal */
-const valuesBackward = self => values$1(self, Direction$1.Backward);
+const valuesBackward = self => values(self, Direction.Backward);
 
 /** @internal */
-const values$1 = (self, direction) => {
+const values = (self, direction) => {
   const begin = self[Symbol.iterator]();
   let count = 0;
   return {
-    [Symbol.iterator]: () => values$1(self, direction),
+    [Symbol.iterator]: () => values(self, direction),
     next: () => {
       count++;
       const entry = begin.value;
-      if (direction === Direction$1.Forward) {
+      if (direction === Direction.Forward) {
         begin.moveNext();
       } else {
         begin.movePrev();
@@ -1280,353 +1039,4 @@ const fixDoubleBlack = stack => {
   }
 };
 
-/**
- * @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;
-
-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 };
+export { RedBlackTreeTypeId, atBackwards, atForwards, empty, findAll, findFirst, first, forEach, forEachBetween, forEachGreaterThanEqual, forEachLessThan, fromIterable, getAt, getOrder, greaterThanBackwards, greaterThanEqualBackwards, greaterThanEqualForwards, greaterThanForwards, has, insert, isRedBlackTree, keysBackward, keysForward, last, lessThanBackwards, lessThanEqualBackwards, lessThanEqualForwards, lessThanForwards, make, reduce, removeFirst, reversed, size, valuesBackward, valuesForward };