@rimbu/common 1.0.0 → 2.0.0

package/dist/cjs/comp.cjs

@@ -32,31 +32,31 @@ var CollectFun;
 
 // src/eq.mts
 var Eq;
-((Eq4) => {
+((Eq2) => {
   function convertAnyToString(value) {
     if (typeof value !== "object" || null === value || !("toString" in value) || typeof value.toString !== "function" || value.toString !== Object.prototype.toString) {
       return String(value);
     }
     return JSON.stringify(value);
   }
-  Eq4.convertAnyToString = convertAnyToString;
+  Eq2.convertAnyToString = convertAnyToString;
   const _anyFlatEq = createAnyEq("FLAT");
   const _anyShallowEq = createAnyEq("SHALLOW");
   const _anyDeepEq = createAnyEq("DEEP");
   function defaultEq() {
     return _anyDeepEq;
   }
-  Eq4.defaultEq = defaultEq;
-  Eq4.objectIs = Object.is;
+  Eq2.defaultEq = defaultEq;
+  Eq2.objectIs = Object.is;
   const _valueOfEq = (v1, v2) => Object.is(v1.valueOf(), v2.valueOf());
   function valueOfEq() {
     return _valueOfEq;
   }
-  Eq4.valueOfEq = valueOfEq;
+  Eq2.valueOfEq = valueOfEq;
   function dateEq() {
     return _valueOfEq;
   }
-  Eq4.dateEq = dateEq;
+  Eq2.dateEq = dateEq;
   function createIterableEq(itemEq) {
     return (v1, v2) => {
       if (Object.is(v1, v2))
@@ -79,7 +79,7 @@ var Eq;
       return _iterableAnyEq;
     return createIterableEq(itemEq);
   }
-  Eq4.iterableEq = iterableEq;
+  Eq2.iterableEq = iterableEq;
   function createObjectEq(valueEq) {
     return (v1, v2) => {
       if (Object.is(v1, v2))
@@ -109,7 +109,7 @@ var Eq;
       return _objectEq;
     return createObjectEq(valueEq);
   }
-  Eq4.objectEq = objectEq;
+  Eq2.objectEq = objectEq;
   function createAnyEq(mode) {
     const result = (v1, v2) => {
       if (Object.is(v1, v2))
@@ -157,15 +157,15 @@ var Eq;
   function anyFlatEq() {
     return _anyFlatEq;
   }
-  Eq4.anyFlatEq = anyFlatEq;
+  Eq2.anyFlatEq = anyFlatEq;
   function anyShallowEq() {
     return _anyShallowEq;
   }
-  Eq4.anyShallowEq = anyShallowEq;
+  Eq2.anyShallowEq = anyShallowEq;
   function anyDeepEq() {
     return _anyDeepEq;
   }
-  Eq4.anyDeepEq = anyDeepEq;
+  Eq2.anyDeepEq = anyDeepEq;
   const _defaultCollator = Intl.Collator("und");
   const _defaultStringCollatorEq = (v1, v2) => _defaultCollator.compare(v1, v2) === 0;
   function createStringCollatorEq(...args) {
@@ -174,14 +174,14 @@ var Eq;
     const collator = Intl.Collator(...args);
     return (v1, v2) => collator.compare(v1, v2) === 0;
   }
-  Eq4.createStringCollatorEq = createStringCollatorEq;
+  Eq2.createStringCollatorEq = createStringCollatorEq;
   const _stringCaseInsensitiveEq = createStringCollatorEq("und", {
     sensitivity: "accent"
   });
   function stringCaseInsentitiveEq() {
     return _stringCaseInsensitiveEq;
   }
-  Eq4.stringCaseInsentitiveEq = stringCaseInsentitiveEq;
+  Eq2.stringCaseInsentitiveEq = stringCaseInsentitiveEq;
   const _stringCharCodeEq = (v1, v2) => {
     const len = v1.length;
     if (len !== v2.length)
@@ -196,21 +196,21 @@ var Eq;
   function stringCharCodeEq() {
     return _stringCharCodeEq;
   }
-  Eq4.stringCharCodeEq = stringCharCodeEq;
+  Eq2.stringCharCodeEq = stringCharCodeEq;
   const _anyToStringEq = (v1, v2) => convertAnyToString(v1) === convertAnyToString(v2);
   function anyToStringEq() {
     return _anyToStringEq;
   }
-  Eq4.anyToStringEq = anyToStringEq;
+  Eq2.anyToStringEq = anyToStringEq;
   const _anyJsonEq = (v1, v2) => JSON.stringify(v1) === JSON.stringify(v2);
   function anyJsonEq() {
     return _anyJsonEq;
   }
-  Eq4.anyJsonEq = anyJsonEq;
+  Eq2.anyJsonEq = anyJsonEq;
   function tupleSymmetric(eq = defaultEq()) {
     return (tup1, tup2) => eq(tup1[0], tup2[0]) && eq(tup1[1], tup2[1]) || eq(tup1[0], tup2[1]) && eq(tup1[1], tup2[0]);
   }
-  Eq4.tupleSymmetric = tupleSymmetric;
+  Eq2.tupleSymmetric = tupleSymmetric;
 })(Eq || (Eq = {}));
 
 // src/err.mts
@@ -323,13 +323,6 @@ var IndexRange;
   IndexRange2.getIndicesFor = getIndicesFor;
 })(IndexRange || (IndexRange = {}));
 
-// src/optlazy.mts
-function OptLazy(optLazy) {
-  if (optLazy instanceof Function)
-    return optLazy();
-  return optLazy;
-}
-
 // src/range.mts
 var Range;
 ((Range2) => {
@@ -355,906 +348,23 @@ var Range;
   Range2.getNormalizedRange = getNormalizedRange;
 })(Range || (Range = {}));
 
-// src/reducer.mts
-function identity(value) {
-  return value;
-}
-var Reducer;
-((Reducer3) => {
-  class Base {
-    constructor(init, next, stateToResult) {
-      this.init = init;
-      this.next = next;
-      this.stateToResult = stateToResult;
-    }
-    filterInput(pred) {
-      return create(
-        () => ({
-          nextIndex: 0,
-          state: OptLazy(this.init)
-        }),
-        (state, elem, index, halt) => {
-          if (pred(elem, index, halt)) {
-            state.state = this.next(state.state, elem, state.nextIndex++, halt);
-          }
-          return state;
-        },
-        (state) => this.stateToResult(state.state)
-      );
-    }
-    mapInput(mapFun) {
-      return create(
-        this.init,
-        (state, elem, index, halt) => this.next(state, mapFun(elem, index), index, halt),
-        this.stateToResult
-      );
-    }
-    collectInput(collectFun) {
-      return create(
-        () => ({
-          nextIndex: 0,
-          state: OptLazy(this.init)
-        }),
-        (state, elem, index, halt) => {
-          const nextElem = collectFun(elem, index, CollectFun.Skip, halt);
-          if (CollectFun.Skip !== nextElem) {
-            state.state = this.next(
-              state.state,
-              nextElem,
-              state.nextIndex++,
-              halt
-            );
-          }
-          return state;
-        },
-        (state) => this.stateToResult(state.state)
-      );
-    }
-    mapOutput(mapFun) {
-      return create(
-        this.init,
-        this.next,
-        (state) => mapFun(this.stateToResult(state))
-      );
-    }
-    takeInput(amount) {
-      if (amount <= 0) {
-        return create(this.init, identity, this.stateToResult);
-      }
-      return this.filterInput((_, i, halt) => {
-        const more = i < amount;
-        if (!more)
-          halt();
-        return more;
-      });
-    }
-    dropInput(amount) {
-      if (amount <= 0)
-        return this;
-      return this.filterInput((_, i) => i >= amount);
-    }
-    sliceInput(from = 0, amount) {
-      if (void 0 === amount)
-        return this.dropInput(from);
-      if (amount <= 0)
-        return create(this.init, identity, this.stateToResult);
-      if (from <= 0)
-        return this.takeInput(amount);
-      return this.takeInput(amount).dropInput(from);
-    }
-  }
-  Reducer3.Base = Base;
-  function create(init, next, stateToResult) {
-    return new Reducer3.Base(init, next, stateToResult);
-  }
-  Reducer3.create = create;
-  function createMono(init, next, stateToResult) {
-    return create(init, next, stateToResult ?? identity);
-  }
-  Reducer3.createMono = createMono;
-  function createOutput(init, next, stateToResult) {
-    return create(init, next, stateToResult ?? identity);
-  }
-  Reducer3.createOutput = createOutput;
-  Reducer3.sum = createMono(0, (state, next) => state + next);
-  Reducer3.product = createMono(1, (state, next, _, halt) => {
-    if (0 === next)
-      halt();
-    return state * next;
-  });
-  Reducer3.average = createMono(
-    0,
-    (avg, value, index) => avg + (value - avg) / (index + 1)
-  );
-  Reducer3.minBy = (compFun, otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      (state, next) => {
-        if (token === state)
-          return next;
-        return compFun(state, next) < 0 ? state : next;
-      },
-      (state) => token === state ? OptLazy(otherwise) : state
-    );
-  };
-  Reducer3.min = (otherwise) => {
-    return create(
-      void 0,
-      (state, next) => void 0 !== state && state < next ? state : next,
-      (state) => state ?? OptLazy(otherwise)
-    );
-  };
-  Reducer3.maxBy = (compFun, otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      (state, next) => {
-        if (token === state)
-          return next;
-        return compFun(state, next) > 0 ? state : next;
-      },
-      (state) => token === state ? OptLazy(otherwise) : state
-    );
-  };
-  Reducer3.max = (otherwise) => {
-    return create(
-      void 0,
-      (state, next) => void 0 !== state && state > next ? state : next,
-      (state) => state ?? OptLazy(otherwise)
-    );
-  };
-  function join({
-    sep = "",
-    start = "",
-    end = "",
-    valueToString = String
-  } = {}) {
-    let curSep = "";
-    let curStart = start;
-    return create(
-      "",
-      (state, next) => {
-        const result = curStart.concat(state, curSep, valueToString(next));
-        curSep = sep;
-        curStart = "";
-        return result;
-      },
-      (state) => state.concat(end)
-    );
-  }
-  Reducer3.join = join;
-  Reducer3.count = (pred) => {
-    if (void 0 === pred)
-      return createOutput(0, (_, __, i) => i + 1);
-    return createOutput(0, (state, next, i) => {
-      if (pred?.(next, i))
-        return state + 1;
-      return state;
-    });
-  };
-  Reducer3.firstWhere = (pred, otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      (state, next, i, halt) => {
-        if (token === state && pred(next, i)) {
-          halt();
-          return next;
-        }
-        return state;
-      },
-      (state) => token === state ? OptLazy(otherwise) : state
-    );
-  };
-  Reducer3.first = (otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      (state, next, _, halt) => {
-        halt();
-        if (token === state)
-          return next;
-        return state;
-      },
-      (state) => token === state ? OptLazy(otherwise) : state
-    );
-  };
-  Reducer3.lastWhere = (pred, otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      (state, next, i) => {
-        if (pred(next, i))
-          return next;
-        return state;
-      },
-      (state) => token === state ? OptLazy(otherwise) : state
-    );
-  };
-  Reducer3.last = (otherwise) => {
-    const token = Symbol();
-    return create(
-      () => token,
-      (_, next) => next,
-      (state) => token === state ? OptLazy(otherwise) : state
-    );
-  };
-  function some(pred) {
-    return createOutput(false, (state, next, i, halt) => {
-      if (state)
-        return state;
-      const satisfies = pred(next, i);
-      if (satisfies) {
-        halt();
-      }
-      return satisfies;
-    });
-  }
-  Reducer3.some = some;
-  function every(pred) {
-    return createOutput(true, (state, next, i, halt) => {
-      if (!state)
-        return state;
-      const satisfies = pred(next, i);
-      if (!satisfies) {
-        halt();
-      }
-      return satisfies;
-    });
-  }
-  Reducer3.every = every;
-  function contains(elem, eq = Object.is) {
-    return createOutput(false, (state, next, _, halt) => {
-      if (state)
-        return state;
-      const satisfies = eq(next, elem);
-      if (satisfies) {
-        halt();
-      }
-      return satisfies;
-    });
-  }
-  Reducer3.contains = contains;
-  Reducer3.and = createMono(true, (state, next, _, halt) => {
-    if (!state)
-      return state;
-    if (!next)
-      halt();
-    return next;
-  });
-  Reducer3.or = createMono(false, (state, next, _, halt) => {
-    if (state)
-      return state;
-    if (next)
-      halt();
-    return next;
-  });
-  Reducer3.isEmpty = createOutput(
-    true,
-    (_, __, ___, halt) => {
-      halt();
-      return false;
-    }
-  );
-  Reducer3.nonEmpty = createOutput(
-    false,
-    (_, __, ___, halt) => {
-      halt();
-      return true;
-    }
-  );
-  function toArray() {
-    return create(
-      () => [],
-      (state, next) => {
-        state.push(next);
-        return state;
-      },
-      (state) => state.slice()
-    );
-  }
-  Reducer3.toArray = toArray;
-  function toJSMap() {
-    return create(
-      () => /* @__PURE__ */ new Map(),
-      (state, next) => {
-        state.set(next[0], next[1]);
-        return state;
-      },
-      (s) => new Map(s)
-    );
-  }
-  Reducer3.toJSMap = toJSMap;
-  function toJSSet() {
-    return create(
-      () => /* @__PURE__ */ new Set(),
-      (state, next) => {
-        state.add(next);
-        return state;
-      },
-      (s) => new Set(s)
-    );
-  }
-  Reducer3.toJSSet = toJSSet;
-  function toJSObject() {
-    return create(
-      () => ({}),
-      (state, entry) => {
-        state[entry[0]] = entry[1];
-        return state;
-      },
-      (s) => ({ ...s })
-    );
-  }
-  Reducer3.toJSObject = toJSObject;
-  function combineArr(...reducers) {
-    const createState = () => {
-      return reducers.map((reducer) => {
-        const result = {
-          reducer,
-          halted: false,
-          halt() {
-            result.halted = true;
-          },
-          state: OptLazy(reducer.init)
-        };
-        return result;
-      });
-    };
-    return create(
-      createState,
-      (allState, next, index, halt) => {
-        let anyNotHalted = false;
-        let i = -1;
-        const len = allState.length;
-        while (++i < len) {
-          const red = allState[i];
-          if (red.halted) {
-            continue;
-          }
-          red.state = red.reducer.next(red.state, next, index, red.halt);
-          if (!red.halted) {
-            anyNotHalted = true;
-          }
-        }
-        if (!anyNotHalted) {
-          halt();
-        }
-        return allState;
-      },
-      (allState) => allState.map((st) => st.reducer.stateToResult(st.state))
-    );
-  }
-  Reducer3.combineArr = combineArr;
-  function combineObj(reducerObj) {
-    const createState = () => {
-      const allState = {};
-      for (const key in reducerObj) {
-        const reducer = reducerObj[key];
-        const result = {
-          reducer,
-          halted: false,
-          halt() {
-            result.halted = true;
-          },
-          state: OptLazy(reducer.init)
-        };
-        allState[key] = result;
-      }
-      return allState;
-    };
-    return create(
-      createState,
-      (allState, next, index, halt) => {
-        let anyNotHalted = false;
-        for (const key in allState) {
-          const red = allState[key];
-          if (red.halted) {
-            continue;
-          }
-          red.state = red.reducer.next(red.state, next, index, red.halt);
-          if (!red.halted) {
-            anyNotHalted = true;
-          }
-        }
-        if (!anyNotHalted) {
-          halt();
-        }
-        return allState;
-      },
-      (allState) => {
-        const result = {};
-        for (const key in allState) {
-          const st = allState[key];
-          result[key] = st.reducer.stateToResult(st.state);
-        }
-        return result;
-      }
-    );
-  }
-  Reducer3.combineObj = combineObj;
-})(Reducer || (Reducer = {}));
-
 // src/async-optlazy.mts
 var AsyncOptLazy;
 ((AsyncOptLazy2) => {
-  function toMaybePromise(optLazy) {
+  function toMaybePromise(optLazy, ...args) {
     if (optLazy instanceof Function)
-      return optLazy();
+      return optLazy(...args);
     return optLazy;
   }
   AsyncOptLazy2.toMaybePromise = toMaybePromise;
-  async function toPromise(optLazy) {
+  async function toPromise(optLazy, ...args) {
     if (optLazy instanceof Function)
-      return optLazy();
+      return optLazy(...args);
     return optLazy;
   }
   AsyncOptLazy2.toPromise = toPromise;
 })(AsyncOptLazy || (AsyncOptLazy = {}));
 
-// src/async-reducer.mts
-function identity2(value) {
-  return value;
-}
-var AsyncReducer;
-((AsyncReducer2) => {
-  class Base {
-    constructor(init, next, stateToResult, onClose) {
-      this.init = init;
-      this.next = next;
-      this.stateToResult = stateToResult;
-      this.onClose = onClose;
-    }
-    filterInput(pred) {
-      return create(
-        async () => ({
-          nextIndex: 0,
-          state: await AsyncOptLazy.toMaybePromise(this.init)
-        }),
-        async (state, elem, index, halt) => {
-          if (pred(elem, index, halt)) {
-            state.state = await this.next(
-              state.state,
-              elem,
-              state.nextIndex++,
-              halt
-            );
-          }
-          return state;
-        },
-        (state) => this.stateToResult(state.state),
-        (state, error) => this.onClose?.(state.state, error)
-      );
-    }
-    mapInput(mapFun) {
-      return create(
-        this.init,
-        async (state, elem, index, halt) => this.next(state, await mapFun(elem, index), index, halt),
-        this.stateToResult,
-        this.onClose
-      );
-    }
-    collectInput(collectFun) {
-      return create(
-        async () => ({
-          nextIndex: 0,
-          state: await AsyncOptLazy.toMaybePromise(this.init)
-        }),
-        async (state, elem, index, halt) => {
-          const nextElem = await collectFun(elem, index, CollectFun.Skip, halt);
-          if (CollectFun.Skip !== nextElem) {
-            state.state = await this.next(
-              state.state,
-              nextElem,
-              state.nextIndex++,
-              halt
-            );
-          }
-          return state;
-        },
-        (state) => this.stateToResult(state.state),
-        (state, error) => this.onClose?.(state.state, error)
-      );
-    }
-    mapOutput(mapFun) {
-      return create(
-        this.init,
-        this.next,
-        async (state) => mapFun(await this.stateToResult(state)),
-        this.onClose
-      );
-    }
-    takeInput(amount) {
-      if (amount <= 0) {
-        return create(this.init, identity2, this.stateToResult);
-      }
-      return this.filterInput((_, i, halt) => {
-        const more = i < amount;
-        if (!more)
-          halt();
-        return more;
-      });
-    }
-    dropInput(amount) {
-      if (amount <= 0) {
-        return this;
-      }
-      return this.filterInput((_, i) => i >= amount);
-    }
-    sliceInput(from2 = 0, amount) {
-      if (void 0 === amount)
-        return this.dropInput(from2);
-      if (amount <= 0)
-        return create(this.init, identity2, this.stateToResult);
-      if (from2 <= 0)
-        return this.takeInput(amount);
-      return this.takeInput(amount).dropInput(from2);
-    }
-  }
-  AsyncReducer2.Base = Base;
-  function create(init, next, stateToResult, onClose) {
-    return new AsyncReducer2.Base(
-      init,
-      next,
-      stateToResult,
-      onClose
-    );
-  }
-  AsyncReducer2.create = create;
-  function createMono(init, next, stateToResult, onClose) {
-    return create(init, next, stateToResult ?? identity2, onClose);
-  }
-  AsyncReducer2.createMono = createMono;
-  function createOutput(init, next, stateToResult, onClose) {
-    return create(init, next, stateToResult ?? identity2, onClose);
-  }
-  AsyncReducer2.createOutput = createOutput;
-  function from(reducer) {
-    return AsyncReducer2.create(
-      reducer.init,
-      reducer.next,
-      reducer.stateToResult
-    );
-  }
-  AsyncReducer2.from = from;
-  AsyncReducer2.sum = createMono(0, (state, next) => state + next);
-  AsyncReducer2.product = createMono(1, (state, next, _, halt) => {
-    if (0 === next)
-      halt();
-    return state * next;
-  });
-  AsyncReducer2.average = createMono(
-    0,
-    (avg, value, index) => avg + (value - avg) / (index + 1)
-  );
-  AsyncReducer2.minBy = (compFun, otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      async (state, next) => {
-        if (token === state)
-          return next;
-        return await compFun(state, next) < 0 ? state : next;
-      },
-      (state) => token === state ? AsyncOptLazy.toMaybePromise(otherwise) : state
-    );
-  };
-  AsyncReducer2.min = (otherwise) => {
-    return create(
-      void 0,
-      (state, next) => void 0 !== state && state < next ? state : next,
-      (state) => state ?? AsyncOptLazy.toMaybePromise(otherwise)
-    );
-  };
-  AsyncReducer2.maxBy = (compFun, otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      async (state, next) => {
-        if (token === state)
-          return next;
-        return await compFun(state, next) > 0 ? state : next;
-      },
-      (state) => token === state ? AsyncOptLazy.toMaybePromise(otherwise) : state
-    );
-  };
-  AsyncReducer2.max = (otherwise) => {
-    return create(
-      void 0,
-      (state, next) => void 0 !== state && state > next ? state : next,
-      (state) => state ?? AsyncOptLazy.toMaybePromise(otherwise)
-    );
-  };
-  function join({
-    sep = "",
-    start = "",
-    end = "",
-    valueToString = String
-  } = {}) {
-    let curSep = "";
-    let curStart = start;
-    return create(
-      "",
-      (state, next) => {
-        const result = curStart.concat(state, curSep, valueToString(next));
-        curSep = sep;
-        curStart = "";
-        return result;
-      },
-      (state) => state.concat(end)
-    );
-  }
-  AsyncReducer2.join = join;
-  AsyncReducer2.count = (pred) => {
-    if (void 0 === pred)
-      return createOutput(0, (_, __, i) => i + 1);
-    return createOutput(0, async (state, next, i) => {
-      if (await pred?.(next, i))
-        return state + 1;
-      return state;
-    });
-  };
-  AsyncReducer2.firstWhere = (pred, otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      async (state, next, i, halt) => {
-        if (token === state && await pred(next, i)) {
-          halt();
-          return next;
-        }
-        return state;
-      },
-      (state) => token === state ? AsyncOptLazy.toMaybePromise(otherwise) : state
-    );
-  };
-  AsyncReducer2.first = (otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      (state, next, _, halt) => {
-        halt();
-        if (token === state)
-          return next;
-        return state;
-      },
-      (state) => token === state ? AsyncOptLazy.toMaybePromise(otherwise) : state
-    );
-  };
-  AsyncReducer2.lastWhere = (pred, otherwise) => {
-    const token = Symbol();
-    return create(
-      token,
-      async (state, next, i) => {
-        if (await pred(next, i))
-          return next;
-        return state;
-      },
-      (state) => token === state ? AsyncOptLazy.toMaybePromise(otherwise) : state
-    );
-  };
-  AsyncReducer2.last = (otherwise) => {
-    const token = Symbol();
-    return create(
-      () => token,
-      (_, next) => next,
-      (state) => token === state ? AsyncOptLazy.toMaybePromise(otherwise) : state
-    );
-  };
-  function some(pred) {
-    return createOutput(
-      false,
-      async (state, next, i, halt) => {
-        if (state)
-          return state;
-        const satisfies = await pred(next, i);
-        if (satisfies) {
-          halt();
-        }
-        return satisfies;
-      }
-    );
-  }
-  AsyncReducer2.some = some;
-  function every(pred) {
-    return createOutput(
-      true,
-      async (state, next, i, halt) => {
-        if (!state)
-          return state;
-        const satisfies = await pred(next, i);
-        if (!satisfies) {
-          halt();
-        }
-        return satisfies;
-      }
-    );
-  }
-  AsyncReducer2.every = every;
-  function contains(elem, eq = Object.is) {
-    return createOutput(false, (state, next, _, halt) => {
-      if (state)
-        return state;
-      const satisfies = eq(next, elem);
-      if (satisfies) {
-        halt();
-      }
-      return satisfies;
-    });
-  }
-  AsyncReducer2.contains = contains;
-  AsyncReducer2.and = createMono(true, (state, next, _, halt) => {
-    if (!state)
-      return state;
-    if (!next)
-      halt();
-    return next;
-  });
-  AsyncReducer2.or = createMono(false, (state, next, _, halt) => {
-    if (state)
-      return state;
-    if (next)
-      halt();
-    return next;
-  });
-  AsyncReducer2.isEmpty = createOutput(
-    true,
-    (_, __, ___, halt) => {
-      halt();
-      return false;
-    }
-  );
-  AsyncReducer2.nonEmpty = createOutput(
-    false,
-    (_, __, ___, halt) => {
-      halt();
-      return true;
-    }
-  );
-  function toArray() {
-    return create(
-      () => [],
-      (state, next) => {
-        state.push(next);
-        return state;
-      },
-      (state) => state.slice()
-    );
-  }
-  AsyncReducer2.toArray = toArray;
-  function toJSMap() {
-    return create(
-      () => /* @__PURE__ */ new Map(),
-      (state, next) => {
-        state.set(next[0], next[1]);
-        return state;
-      },
-      (s) => new Map(s)
-    );
-  }
-  AsyncReducer2.toJSMap = toJSMap;
-  function toJSSet() {
-    return create(
-      () => /* @__PURE__ */ new Set(),
-      (state, next) => {
-        state.add(next);
-        return state;
-      },
-      (s) => new Set(s)
-    );
-  }
-  AsyncReducer2.toJSSet = toJSSet;
-  function toJSObject() {
-    return create(
-      () => ({}),
-      (state, entry) => {
-        state[entry[0]] = entry[1];
-        return state;
-      },
-      (s) => ({ ...s })
-    );
-  }
-  AsyncReducer2.toJSObject = toJSObject;
-  function combineArr(...reducers) {
-    const createState = () => {
-      return Promise.all(
-        reducers.map(async (reducer) => {
-          const result = {
-            reducer,
-            halted: false,
-            halt() {
-              result.halted = true;
-            },
-            state: await AsyncOptLazy.toMaybePromise(reducer.init)
-          };
-          return result;
-        })
-      );
-    };
-    return create(
-      createState,
-      async (allState, next, index, halt) => {
-        let anyNotHalted = false;
-        await Promise.all(
-          allState.map(async (red) => {
-            if (red.halted)
-              return;
-            red.state = await red.reducer.next(
-              red.state,
-              next,
-              index,
-              red.halt
-            );
-            if (!red.halted)
-              anyNotHalted = true;
-          })
-        );
-        if (!anyNotHalted)
-          halt();
-        return allState;
-      },
-      (allState) => Promise.all(
-        allState.map((st) => st.reducer.stateToResult(st.state))
-      )
-    );
-  }
-  AsyncReducer2.combineArr = combineArr;
-  function combineObj(reducerObj) {
-    const createState = async () => {
-      const entries = await Promise.all(
-        Object.entries(reducerObj).map(async ([key, reducer]) => {
-          const result = {
-            reducer,
-            halted: false,
-            halt() {
-              result.halted = true;
-            },
-            state: await AsyncOptLazy.toMaybePromise(reducer.init)
-          };
-          return [key, result];
-        })
-      );
-      return Object.fromEntries(entries);
-    };
-    return create(
-      createState,
-      async (allState, next, index, halt) => {
-        let anyNotHalted = false;
-        await Promise.all(
-          Object.values(allState).map(async (red) => {
-            if (red.halted) {
-              return;
-            }
-            red.state = await red.reducer.next(
-              red.state,
-              next,
-              index,
-              red.halt
-            );
-            if (!red.halted) {
-              anyNotHalted = true;
-            }
-          })
-        );
-        if (!anyNotHalted) {
-          halt();
-        }
-        return allState;
-      },
-      async (allState) => {
-        const entries = await Promise.all(
-          Object.entries(allState).map(
-            async ([key, st]) => [key, await st.reducer.stateToResult(st.state)]
-          )
-        );
-        return Object.fromEntries(entries);
-      }
-    );
-  }
-  AsyncReducer2.combineObj = combineObj;
-})(AsyncReducer || (AsyncReducer = {}));
-
 // src/comp.mts
 var Comp;
 ((Comp2) => {