@fncts/base 0.0.20 → 0.0.21

package/_cjs/collection/immutable/SortedMap/api.cjs

@@ -3,24 +3,24 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.find_ = void 0;
-exports.forEachBetween_ = forEachBetween_;
-exports.forEachGt_ = forEachGt_;
-exports.forEachGte_ = forEachGte_;
-exports.forEachLt_ = forEachLt_;
-exports.forEachLte_ = forEachLte_;
-exports.forEach_ = forEach_;
-exports.getGt_ = getGt_;
-exports.getGte_ = getGte_;
-exports.getLt_ = getLt_;
-exports.getLte_ = getLte_;
-exports.get_ = get_;
-exports.insertWith_ = insertWith_;
-exports.insert_ = insert_;
+exports.find = void 0;
+exports.forEach = forEach;
+exports.forEachBetween = forEachBetween;
+exports.forEachGt = forEachGt;
+exports.forEachGte = forEachGte;
+exports.forEachLt = forEachLt;
+exports.forEachLte = forEachLte;
+exports.get = get;
+exports.getGt = getGt;
+exports.getGte = getGte;
+exports.getLt = getLt;
+exports.getLte = getLte;
+exports.insert = insert;
+exports.insertWith = insertWith;
 exports.isEmpty = isEmpty;
 exports.isNonEmpty = isNonEmpty;
 exports.make = make;
-exports.remove_ = remove_;
+exports.remove = remove;
 exports.visitLte = exports.visitLt = exports.visitGte = exports.visitGt = exports.visitFull = exports.visitBetween = void 0;
 
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
@@ -41,8 +41,8 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const find_ = find_1;
-exports.find_ = find_;
+const find = find_1;
+exports.find = find;
 const visitFull = visitFull_1;
 exports.visitFull = visitFull;
 const visitLte = visitLte_1;
@@ -57,316 +57,342 @@ const visitBetween = visitBetween_1;
 exports.visitBetween = visitBetween;
 
 /**
- * @tsplus fluent fncts.SortedMap find
+ * @tsplus pipeable fncts.SortedMap find
  */
-function find_1(m, key, direction = 0) {
-  return {
-    ord: m.ord,
-
-    [Symbol.iterator]() {
-      const cmp = m.ord.compare;
-      let n = m.root;
-      const stack = [];
-
-      while (n) {
-        const d = cmp(key, n.key);
-        stack.push(n);
-
-        switch (d) {
-          case 0:
-            {
-              return new _iterator.SortedMapIterator(m, stack, direction);
-            }
-
-          case -1:
-            {
-              n = n.left;
-              break;
-            }
-
-          case 1:
-            {
-              n = n.right;
-              break;
-            }
+function find_1(key, direction = 0) {
+  return m => {
+    return {
+      ord: m.ord,
+
+      [Symbol.iterator]() {
+        const cmp = m.ord.compare;
+        let n = m.root;
+        const stack = [];
+
+        while (n) {
+          const d = cmp(key, n.key);
+          stack.push(n);
+
+          switch (d) {
+            case 0:
+              {
+                return new _iterator.SortedMapIterator(m, stack, direction);
+              }
+
+            case -1:
+              {
+                n = n.left;
+                break;
+              }
+
+            case 1:
+              {
+                n = n.right;
+                break;
+              }
+          }
         }
-      }
 
-      return new _iterator.SortedMapIterator(m, [], direction);
-    }
+        return new _iterator.SortedMapIterator(m, [], direction);
+      }
 
+    };
   };
 }
 /**
  * Iterates through the elements of the map inorder, performing the given function for each element
  *
- * @tsplus fluent fncts.SortedMap forEach
+ * @tsplus pipeable fncts.SortedMap forEach
  */
 
 
-function forEach_(m, visit) {
-  if (m.root) {
-    visitFull_1(m, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+function forEach(visit) {
+  return m => {
+    if (m.root) {
+      visitFull_1((k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachBetween
+ * @tsplus pipeable fncts.SortedMap forEachBetween
  */
 
 
-function forEachBetween_(m, min, max, visit) {
-  if (m.root) {
-    visitBetween_1(m, min, max, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+function forEachBetween(min, max, visit) {
+  return m => {
+    if (m.root) {
+      visitBetween_1(min, max, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachLte
+ * @tsplus pipeable fncts.SortedMap forEachLte
  */
 
 
-function forEachLte_(m, max, visit) {
-  if (m.root) {
-    visitLte_1(m, max, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+function forEachLte(max, visit) {
+  return m => {
+    if (m.root) {
+      visitLte_1(max, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachLt
+ * @tsplus pipeable fncts.SortedMap forEachLt
  */
 
 
-function forEachLt_(m, max, visit) {
-  if (m.root) {
-    visitLt_1(m, max, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+function forEachLt(max, visit) {
+  return m => {
+    if (m.root) {
+      visitLt_1(max, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachGte
+ * @tsplus pipeable fncts.SortedMap forEachGte
  */
 
 
-function forEachGte_(m, min, visit) {
-  if (m.root) {
-    visitGte_1(m, min, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+function forEachGte(min, visit) {
+  return m => {
+    if (m.root) {
+      visitGte_1(min, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachGt
+ * @tsplus pipeable fncts.SortedMap forEachGt
  */
 
 
-function forEachGt_(m, min, visit) {
-  if (m.root) {
-    visitGt_1(m, min, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+function forEachGt(min, visit) {
+  return m => {
+    if (m.root) {
+      visitGt_1(min, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
  * Searches the map for a given key, returning it's value, if it exists
  *
- * @tsplus fluent fncts.SortedMap get
+ * @tsplus pipeable fncts.SortedMap get
  */
 
 
-function get_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
+function get(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
 
-  while (n) {
-    const d = cmp(key, n.key);
+    while (n) {
+      const d = cmp(key, n.key);
 
-    switch (d) {
-      case 0:
-        {
-          return tsplus_module_1.just(n.value);
-        }
+      switch (d) {
+        case 0:
+          {
+            return tsplus_module_1.just(n.value);
+          }
 
-      case -1:
-        {
-          n = n.left;
-          break;
-        }
+        case -1:
+          {
+            n = n.left;
+            break;
+          }
 
-      case 1:
-        {
-          n = n.right;
-          break;
-        }
+        case 1:
+          {
+            n = n.right;
+            break;
+          }
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
  * Searches the map and returns the first value in sorted order that is > key, if it exists
  *
- * @tsplus fluent fncts.SortedMap getGt
+ * @tsplus pipeable fncts.SortedMap getGt
  */
 
 
-function getGt_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
-  let lastValue = tsplus_module_1.nothing();
+function getGt(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
+    let lastValue = tsplus_module_1.nothing();
 
-  while (n) {
-    const d = cmp(key, n.key);
+    while (n) {
+      const d = cmp(key, n.key);
 
-    if (d < 0) {
-      lastValue = tsplus_module_1.just(n.value);
-      n = n.left;
-    } else {
-      if (tsplus_module_2.isJust(lastValue)) {
-        break;
-      }
+      if (d < 0) {
+        lastValue = tsplus_module_1.just(n.value);
+        n = n.left;
+      } else {
+        if (tsplus_module_2.isJust(lastValue)) {
+          break;
+        }
 
-      n = n.right;
+        n = n.right;
+      }
     }
-  }
 
-  return lastValue;
+    return lastValue;
+  };
 }
 /**
  * Searches the map and returns the first value in sorted order that is < key, if it exists
  *
- * @tsplus fluent fncts.SortedMap getLt
+ * @tsplus pipeable fncts.SortedMap getLt
  */
 
 
-function getLt_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
-  let lastValue = tsplus_module_1.nothing();
+function getLt(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
+    let lastValue = tsplus_module_1.nothing();
 
-  while (n) {
-    const d = cmp(key, n.key);
+    while (n) {
+      const d = cmp(key, n.key);
 
-    if (d > 0) {
-      lastValue = tsplus_module_1.just(n.value);
-    }
+      if (d > 0) {
+        lastValue = tsplus_module_1.just(n.value);
+      }
 
-    if (d <= 0) {
-      n = n.left;
-    } else {
-      n = n.right;
+      if (d <= 0) {
+        n = n.left;
+      } else {
+        n = n.right;
+      }
     }
-  }
 
-  return lastValue;
+    return lastValue;
+  };
 }
 /**
  * Searches the map and returns the first value in sorted order that is <= key, if it exists
  *
- * @tsplus fluent fncts.SortedMap getLte
+ * @tsplus pipeable fncts.SortedMap getLte
  */
 
 
-function getLte_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
-  let lastValue = tsplus_module_1.nothing();
+function getLte(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
+    let lastValue = tsplus_module_1.nothing();
 
-  while (n) {
-    const d = cmp(key, n.key);
+    while (n) {
+      const d = cmp(key, n.key);
 
-    if (d > 0) {
-      if (tsplus_module_2.isJust(lastValue)) {
-        break;
-      }
+      if (d > 0) {
+        if (tsplus_module_2.isJust(lastValue)) {
+          break;
+        }
 
-      n = n.right;
-    } else {
-      lastValue = tsplus_module_1.just(n.value);
-      n = n.left;
+        n = n.right;
+      } else {
+        lastValue = tsplus_module_1.just(n.value);
+        n = n.left;
+      }
     }
-  }
 
-  return lastValue;
+    return lastValue;
+  };
 }
 /**
  * Searches the map and returns the first value in sorted order that is >= key, if it exists
  *
- * @tsplus fluent fncts.SortedMap getGte
+ * @tsplus pipeable fncts.SortedMap getGte
  */
 
 
-function getGte_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
-  let lastValue = tsplus_module_1.nothing();
+function getGte(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
+    let lastValue = tsplus_module_1.nothing();
 
-  while (n) {
-    const d = cmp(key, n.key);
+    while (n) {
+      const d = cmp(key, n.key);
 
-    if (d <= 0) {
-      lastValue = tsplus_module_1.just(n.value);
-      n = n.left;
-    } else {
-      if (tsplus_module_2.isJust(lastValue)) {
-        break;
-      }
+      if (d <= 0) {
+        lastValue = tsplus_module_1.just(n.value);
+        n = n.left;
+      } else {
+        if (tsplus_module_2.isJust(lastValue)) {
+          break;
+        }
 
-      n = n.right;
+        n = n.right;
+      }
     }
-  }
 
-  return lastValue;
+    return lastValue;
+  };
 }
 /**
  * Inserts an element into the correct position in the map.
  * This function inserts duplicate keys. For one that combines duplicate key's values,
  * see `insertWith_`
  *
- * @tsplus fluent fncts.SortedMap insert
+ * @tsplus pipeable fncts.SortedMap insert
  */
 
 
-function insert_(m, key, value) {
-  if ((0, _internal.isEmptyNode)(m.root)) {
-    return new _definition2.SortedMap(m.ord, new _node.Node(0
-    /* Color.R */
-    , _node.Leaf, key, value, _node.Leaf, 1));
-  }
+function insert(key, value) {
+  return m => {
+    if ((0, _internal.isEmptyNode)(m.root)) {
+      return new _definition2.SortedMap(m.ord, new _node.Node(0
+      /* Color.R */
+      , _node.Leaf, key, value, _node.Leaf, 1));
+    }
 
-  const cmp = m.ord.compare;
-  const nodeStack = [];
-  const orderStack = [];
-  let n = m.root;
+    const cmp = m.ord.compare;
+    const nodeStack = [];
+    const orderStack = [];
+    let n = m.root;
 
-  while (n) {
-    const d = cmp(key, n.key);
-    nodeStack.push(n);
-    orderStack.push(d);
+    while (n) {
+      const d = cmp(key, n.key);
+      nodeStack.push(n);
+      orderStack.push(d);
 
-    if (d <= 0) {
-      n = n.left;
-    } else {
-      n = n.right;
+      if (d <= 0) {
+        n = n.left;
+      } else {
+        n = n.right;
+      }
     }
-  }
 
-  nodeStack.push(new _node.Node(0
-  /* Color.R */
-  , _node.Leaf, key, value, _node.Leaf, 1));
-  (0, _internal.rebuildModifiedPath)(nodeStack, orderStack);
-  (0, _internal.balanceModifiedPath)(nodeStack);
-  return new _definition2.SortedMap(m.ord, nodeStack[0]);
+    nodeStack.push(new _node.Node(0
+    /* Color.R */
+    , _node.Leaf, key, value, _node.Leaf, 1));
+    (0, _internal.rebuildModifiedPath)(nodeStack, orderStack);
+    (0, _internal.balanceModifiedPath)(nodeStack);
+    return new _definition2.SortedMap(m.ord, nodeStack[0]);
+  };
 }
 /**
  * Inserts an element into the correct position in the map, combining the values of keys of equal ordering
@@ -374,7 +400,7 @@ function insert_(m, key, value) {
  */
 
 
-function insertWith_(m, key, value,
+function insertWith(m, key, value,
 /** @tsplus auto */
 S) {
   if ((0, _internal.isEmptyNode)(m.root)) {
@@ -459,233 +485,247 @@ function make(ord) {
 /**
  * Removes an element from the map
  *
- * @tsplus fluent fncts.SortedMap remove
+ * @tsplus pipeable fncts.SortedMap remove
  */
 
 
-function remove_(m, key) {
-  const iter = find_1(m, key)[Symbol.iterator]();
-  return iter.isEmpty ? m : iter.remove();
+function remove(key) {
+  return m => {
+    const iter = find_1(key)(m)[Symbol.iterator]();
+    return iter.isEmpty ? m : iter.remove();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitFull
+ * @tsplus pipeable fncts.SortedMap visitFull
  */
 
 
-function visitFull_1(m, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
+function visitFull_1(visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    let done = false;
 
-  while (!done) {
-    if (current) {
-      stack.push(current);
-      current = current.left;
-    } else if (stack.hasNext) {
-      const value = stack.pop();
-      const v = visit(value.key, value.value);
+    while (!done) {
+      if (current) {
+        stack.push(current);
+        current = current.left;
+      } else if (stack.hasNext) {
+        const value = stack.pop();
+        const v = visit(value.key, value.value);
 
-      if (tsplus_module_2.isJust(v)) {
-        return v;
-      }
+        if (tsplus_module_2.isJust(v)) {
+          return v;
+        }
 
-      current = value.right;
-    } else {
-      done = true;
+        current = value.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitLte
+ * @tsplus pipeable fncts.SortedMap visitLte
  */
 
 
-function visitLte_1(m, max, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitLte_1(max, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    let done = false;
+    const cmp = m.ord.compare;
 
-  while (!done) {
-    if (current) {
-      stack.push(current);
-      current = current.left;
-    } else if (stack.hasNext) {
-      const next = stack.pop();
+    while (!done) {
+      if (current) {
+        stack.push(current);
+        current = current.left;
+      } else if (stack.hasNext) {
+        const next = stack.pop();
 
-      if (cmp(next.key, max) > 0) {
-        break;
-      }
+        if (cmp(next.key, max) > 0) {
+          break;
+        }
 
-      const v = visit(next.key, next.value);
+        const v = visit(next.key, next.value);
 
-      if (tsplus_module_2.isJust(v)) {
-        return v;
-      }
+        if (tsplus_module_2.isJust(v)) {
+          return v;
+        }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitLt
+ * @tsplus pipeable fncts.SortedMap visitLt
  */
 
 
-function visitLt_1(m, max, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitLt_1(max, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    let done = false;
+    const cmp = m.ord.compare;
 
-  while (!done) {
-    if (current) {
-      stack.push(current);
-      current = current.left;
-    } else if (stack.hasNext) {
-      const next = stack.pop();
+    while (!done) {
+      if (current) {
+        stack.push(current);
+        current = current.left;
+      } else if (stack.hasNext) {
+        const next = stack.pop();
 
-      if (cmp(next.key, max) >= 0) {
-        break;
-      }
+        if (cmp(next.key, max) >= 0) {
+          break;
+        }
 
-      const v = visit(next.key, next.value);
+        const v = visit(next.key, next.value);
 
-      if (tsplus_module_2.isJust(v)) {
-        return v;
-      }
+        if (tsplus_module_2.isJust(v)) {
+          return v;
+        }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitGte
+ * @tsplus pipeable fncts.SortedMap visitGte
  */
 
 
-function visitGte_1(m, min, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitGte_1(min, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    let done = false;
+    const cmp = m.ord.compare;
 
-  while (!done) {
-    if (current) {
-      stack.push(current);
+    while (!done) {
+      if (current) {
+        stack.push(current);
 
-      if (cmp(current.key, min) >= 0) {
-        current = current.left;
-      } else {
-        current = null;
-      }
-    } else if (stack.hasNext) {
-      const next = stack.pop();
+        if (cmp(current.key, min) >= 0) {
+          current = current.left;
+        } else {
+          current = null;
+        }
+      } else if (stack.hasNext) {
+        const next = stack.pop();
 
-      if (cmp(next.key, min) >= 0) {
-        const v = visit(next.key, next.value);
+        if (cmp(next.key, min) >= 0) {
+          const v = visit(next.key, next.value);
 
-        if (tsplus_module_2.isJust(v)) {
-          return v;
+          if (tsplus_module_2.isJust(v)) {
+            return v;
+          }
         }
-      }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitGt
+ * @tsplus pipeable fncts.SortedMap visitGt
  */
 
 
-function visitGt_1(m, min, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitGt_1(min, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    let done = false;
+    const cmp = m.ord.compare;
 
-  while (!done) {
-    if (current) {
-      stack.push(current);
+    while (!done) {
+      if (current) {
+        stack.push(current);
 
-      if (cmp(current.key, min) > 0) {
-        current = current.left;
-      } else {
-        current = null;
-      }
-    } else if (stack.hasNext) {
-      const next = stack.pop();
+        if (cmp(current.key, min) > 0) {
+          current = current.left;
+        } else {
+          current = null;
+        }
+      } else if (stack.hasNext) {
+        const next = stack.pop();
 
-      if (cmp(next.key, min) > 0) {
-        const v = visit(next.key, next.value);
+        if (cmp(next.key, min) > 0) {
+          const v = visit(next.key, next.value);
 
-        if (tsplus_module_2.isJust(v)) {
-          return v;
+          if (tsplus_module_2.isJust(v)) {
+            return v;
+          }
         }
-      }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitBetween
+ * @tsplus pipeable fncts.SortedMap visitBetween
  */
 
 
-function visitBetween_1(m, min, max, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitBetween_1(min, max, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    let done = false;
+    const cmp = m.ord.compare;
 
-  while (!done) {
-    if (current) {
-      stack.push(current);
+    while (!done) {
+      if (current) {
+        stack.push(current);
 
-      if (cmp(current.key, min) > 0) {
-        current = current.left;
-      } else {
-        current = null;
-      }
-    } else if (stack.hasNext) {
-      const next = stack.pop();
+        if (cmp(current.key, min) > 0) {
+          current = current.left;
+        } else {
+          current = null;
+        }
+      } else if (stack.hasNext) {
+        const next = stack.pop();
 
-      if (cmp(next.key, max) >= 0) {
-        break;
-      }
+        if (cmp(next.key, max) >= 0) {
+          break;
+        }
 
-      const v = visit(next.key, next.value);
+        const v = visit(next.key, next.value);
 
-      if (tsplus_module_2.isJust(v)) {
-        return v;
-      }
+        if (tsplus_module_2.isJust(v)) {
+          return v;
+        }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 //# sourceMappingURL=api.cjs.map