@rimbu/common 2.0.0 → 2.0.1

package/dist/cjs/internal.cjs

@@ -1,798 +1,15 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/internal.mts
-var internal_exports = {};
-__export(internal_exports, {
-  AsyncOptLazy: () => AsyncOptLazy,
-  CollectFun: () => CollectFun,
-  Comp: () => Comp,
-  Eq: () => Eq,
-  Err: () => Err,
-  ErrBase: () => ErrBase,
-  IndexRange: () => IndexRange,
-  OptLazy: () => OptLazy,
-  OptLazyOr: () => OptLazyOr,
-  Range: () => Range,
-  TraverseState: () => TraverseState,
-  Update: () => Update
-});
-module.exports = __toCommonJS(internal_exports);
-
-// src/collect.mts
-var CollectFun;
-((CollectFun2) => {
-  CollectFun2.Skip = Symbol("Skip");
-})(CollectFun || (CollectFun = {}));
-
-// src/comp.mts
-var Comp;
-((Comp2) => {
-  const _anyFlatComp = createAnyComp("FLAT");
-  const _anyShallowComp = createAnyComp("SHALLOW");
-  const _anyDeepComp = createAnyComp("DEEP");
-  function defaultComp() {
-    return _anyDeepComp;
-  }
-  Comp2.defaultComp = defaultComp;
-  const _numberComp = {
-    isComparable(obj) {
-      return typeof obj === "number";
-    },
-    compare(v1, v2) {
-      if (Number.isFinite(v1) && Number.isFinite(v2)) {
-        return v1 - v2;
-      }
-      if (Number.isNaN(v1)) {
-        if (Number.isNaN(v2))
-          return 0;
-        if (v2 === Number.POSITIVE_INFINITY)
-          return 1;
-        if (v2 === Number.NEGATIVE_INFINITY)
-          return -1;
-        return -1;
-      }
-      if (v1 === Number.POSITIVE_INFINITY) {
-        return v2 === Number.POSITIVE_INFINITY ? 0 : 1;
-      }
-      return v2 === Number.NEGATIVE_INFINITY ? 0 : -1;
-    }
-  };
-  function numberComp() {
-    return _numberComp;
-  }
-  Comp2.numberComp = numberComp;
-  const _booleanComp = {
-    isComparable(obj) {
-      return typeof obj === "boolean";
-    },
-    compare(v1, v2) {
-      return v1 === v2 ? 0 : v1 ? 1 : -1;
-    }
-  };
-  function booleanComp() {
-    return _booleanComp;
-  }
-  Comp2.booleanComp = booleanComp;
-  const _bigIntComp = {
-    isComparable(obj) {
-      return typeof obj === "bigint";
-    },
-    compare(v1, v2) {
-      const res = v1 - v2;
-      if (res > 0)
-        return 1;
-      if (res < 0)
-        return -1;
-      return 0;
-    }
-  };
-  function bigIntComp() {
-    return _bigIntComp;
-  }
-  Comp2.bigIntComp = bigIntComp;
-  const _defaultCollator = Intl.Collator("und");
-  const _stringComp = {
-    isComparable(obj) {
-      return typeof obj === "string";
-    },
-    compare: _defaultCollator.compare
-  };
-  const _anyStringJSONComp = {
-    isComparable(obj) {
-      return true;
-    },
-    compare(v1, v2) {
-      return _defaultCollator.compare(JSON.stringify(v1), JSON.stringify(v2));
-    }
-  };
-  function anyStringJSONComp() {
-    return _anyStringJSONComp;
-  }
-  Comp2.anyStringJSONComp = anyStringJSONComp;
-  function stringComp(...args) {
-    if (args.length === 0)
-      return _stringComp;
-    const collator = Intl.Collator(...args);
-    return {
-      isComparable(obj) {
-        return typeof obj === "string";
-      },
-      compare: collator.compare
-    };
-  }
-  Comp2.stringComp = stringComp;
-  function stringCaseInsensitiveComp() {
-    return stringComp("und", { sensitivity: "accent" });
-  }
-  Comp2.stringCaseInsensitiveComp = stringCaseInsensitiveComp;
-  const _stringCharCodeComp = {
-    isComparable(obj) {
-      return typeof obj === "string";
-    },
-    compare(v1, v2) {
-      const len = Math.min(v1.length, v2.length);
-      let i = -1;
-      while (++i < len) {
-        const diff = v1.charCodeAt(i) - v2.charCodeAt(i);
-        if (diff !== 0)
-          return diff;
-      }
-      return v1.length - v2.length;
-    }
-  };
-  function stringCharCodeComp() {
-    return _stringCharCodeComp;
-  }
-  Comp2.stringCharCodeComp = stringCharCodeComp;
-  const _anyToStringComp = {
-    isComparable(obj) {
-      return true;
-    },
-    compare(v1, v2) {
-      return _defaultCollator.compare(
-        Eq.convertAnyToString(v1),
-        Eq.convertAnyToString(v2)
-      );
-    }
-  };
-  function anyToStringComp() {
-    return _anyToStringComp;
-  }
-  Comp2.anyToStringComp = anyToStringComp;
-  function createValueOfComp(cls, valueComp = anyShallowComp()) {
-    return {
-      isComparable(obj) {
-        return obj instanceof cls;
-      },
-      compare(v1, v2) {
-        return valueComp.compare(v1.valueOf(), v2.valueOf());
-      }
-    };
-  }
-  Comp2.createValueOfComp = createValueOfComp;
-  const _DateComp = createValueOfComp(Date, _numberComp);
-  function dateComp() {
-    return _DateComp;
-  }
-  Comp2.dateComp = dateComp;
-  function createIterableComp(itemComp) {
-    return {
-      isComparable(obj) {
-        return typeof obj === "object" && obj !== null && Symbol.iterator in obj;
-      },
-      compare(v1, v2) {
-        const iter1 = v1[Symbol.iterator]();
-        const iter2 = v2[Symbol.iterator]();
-        while (true) {
-          const value1 = iter1.next();
-          const value2 = iter2.next();
-          if (value1.done)
-            return value2.done ? 0 : -1;
-          if (value2.done)
-            return 1;
-          const result = itemComp.compare(value1.value, value2.value);
-          if (result !== 0)
-            return result;
-        }
-      }
-    };
-  }
-  const _iterableAnyComp = createIterableComp(
-    Comp2.defaultComp()
-  );
-  function iterableComp(itemComp) {
-    if (void 0 === itemComp)
-      return _iterableAnyComp;
-    return createIterableComp(itemComp);
-  }
-  Comp2.iterableComp = iterableComp;
-  const _BooleanComp = createValueOfComp(Boolean, _booleanComp);
-  const _NumberComp = createValueOfComp(Number, _numberComp);
-  const _StringComp = createValueOfComp(String, _stringComp);
-  const _wrappedComps = [
-    _BooleanComp,
-    _DateComp,
-    _NumberComp,
-    _StringComp
-  ];
-  function tryWrappedComp(v1, v2) {
-    let i = -1;
-    const len = _wrappedComps.length;
-    while (++i < len) {
-      const comp = _wrappedComps[i];
-      if (comp.isComparable(v1) && comp.isComparable(v2)) {
-        return comp.compare(v1, v2);
-      }
-    }
-    return void 0;
-  }
-  function createObjectComp(keyComp = anyFlatComp(), valueComp = defaultComp()) {
-    return {
-      isComparable(obj) {
-        return true;
-      },
-      compare(v1, v2) {
-        const keys1 = Object.keys(v1);
-        const keys2 = Object.keys(v2);
-        if (keys1.length === 0) {
-          return keys2.length === 0 ? 0 : -1;
-        }
-        if (keys2.length === 0) {
-          return keys1.length === 0 ? 0 : 1;
-        }
-        keys1.sort(keyComp.compare);
-        keys2.sort(keyComp.compare);
-        const length = Math.min(keys1.length, keys2.length);
-        for (let index = 0; index < length; index++) {
-          const key1 = keys1[index];
-          const key2 = keys2[index];
-          const keyResult = keyComp.compare(key1, key2);
-          if (keyResult !== 0)
-            return keyResult;
-          const value1 = v1[key1];
-          const value2 = v2[key2];
-          const valueResult = valueComp.compare(value1, value2);
-          if (valueResult !== 0)
-            return valueResult;
-        }
-        const keyDiff = keys1.length - keys2.length;
-        return keyDiff;
-      }
-    };
-  }
-  const _objectAnyComp = createObjectComp();
-  function objectComp(options) {
-    if (void 0 === options)
-      return _objectAnyComp;
-    return createObjectComp(options.keyComp, options.valueComp);
-  }
-  Comp2.objectComp = objectComp;
-  function createAnyComp(mode) {
-    return {
-      isComparable(obj) {
-        return true;
-      },
-      compare(v1, v2) {
-        if (Object.is(v1, v2))
-          return 0;
-        const type1 = typeof v1;
-        const type2 = typeof v2;
-        if (type1 !== type2) {
-          return _anyToStringComp.compare(v1, v2);
-        }
-        switch (type1) {
-          case "bigint":
-            return _bigIntComp.compare(v1, v2);
-          case "boolean":
-            return _booleanComp.compare(v1, v2);
-          case "number":
-            return _numberComp.compare(v1, v2);
-          case "string":
-            return _stringComp.compare(v1, v2);
-          case "object": {
-            if (null === v1) {
-              if (null === v2)
-                return 0;
-              return -1;
-            }
-            if (null === v2) {
-              return 1;
-            }
-            const wrappedComp = tryWrappedComp(v1, v2);
-            if (void 0 !== wrappedComp)
-              return wrappedComp;
-            if (mode !== "FLAT") {
-              if (_iterableAnyComp.isComparable(v1) && _iterableAnyComp.isComparable(v2)) {
-                if (mode === "SHALLOW") {
-                  return iterableComp(_anyFlatComp).compare(v1, v2);
-                }
-                return iterableComp(this).compare(v1, v2);
-              }
-              if (mode === "SHALLOW") {
-                return createObjectComp(_anyFlatComp, _anyFlatComp).compare(
-                  v1,
-                  v2
-                );
-              }
-              return _objectAnyComp.compare(v1, v2);
-            }
-          }
-        }
-        return _anyToStringComp.compare(v1, v2);
-      }
-    };
-  }
-  function anyFlatComp() {
-    return _anyFlatComp;
-  }
-  Comp2.anyFlatComp = anyFlatComp;
-  function anyShallowComp() {
-    return _anyShallowComp;
-  }
-  Comp2.anyShallowComp = anyShallowComp;
-  function anyDeepComp() {
-    return _anyDeepComp;
-  }
-  Comp2.anyDeepComp = anyDeepComp;
-  function withUndefined(comp) {
-    return {
-      isComparable(obj) {
-        return void 0 === obj || comp.isComparable(obj);
-      },
-      compare(v1, v2) {
-        if (void 0 === v1) {
-          if (void 0 === v2)
-            return 0;
-          return -1;
-        }
-        if (void 0 === v2)
-          return 1;
-        return comp.compare(v1, v2);
-      }
-    };
-  }
-  Comp2.withUndefined = withUndefined;
-  function withNull(comp) {
-    return {
-      isComparable(obj) {
-        return null === obj || comp.isComparable(obj);
-      },
-      compare(v1, v2) {
-        if (null === v1) {
-          if (null === v2)
-            return 0;
-          return -1;
-        }
-        if (null === v2)
-          return 1;
-        return comp.compare(v1, v2);
-      }
-    };
-  }
-  Comp2.withNull = withNull;
-  function invert(comp) {
-    return {
-      compare(v1, v2) {
-        return comp.compare(v2, v1);
-      },
-      isComparable: comp.isComparable
-    };
-  }
-  Comp2.invert = invert;
-  function toEq(comp) {
-    return (v1, v2) => comp.compare(v1, v2) === 0;
-  }
-  Comp2.toEq = toEq;
-})(Comp || (Comp = {}));
-
-// src/eq.mts
-var Eq;
-((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);
-  }
-  Eq2.convertAnyToString = convertAnyToString;
-  const _anyFlatEq = createAnyEq("FLAT");
-  const _anyShallowEq = createAnyEq("SHALLOW");
-  const _anyDeepEq = createAnyEq("DEEP");
-  function defaultEq() {
-    return _anyDeepEq;
-  }
-  Eq2.defaultEq = defaultEq;
-  Eq2.objectIs = Object.is;
-  const _valueOfEq = (v1, v2) => Object.is(v1.valueOf(), v2.valueOf());
-  function valueOfEq() {
-    return _valueOfEq;
-  }
-  Eq2.valueOfEq = valueOfEq;
-  function dateEq() {
-    return _valueOfEq;
-  }
-  Eq2.dateEq = dateEq;
-  function createIterableEq(itemEq) {
-    return (v1, v2) => {
-      if (Object.is(v1, v2))
-        return true;
-      const iter1 = v1[Symbol.iterator]();
-      const iter2 = v2[Symbol.iterator]();
-      while (true) {
-        const value1 = iter1.next();
-        const value2 = iter2.next();
-        if (value1.done || value2.done)
-          return value1.done === value2.done;
-        if (!itemEq(value1.value, value2.value))
-          return false;
-      }
-    };
-  }
-  const _iterableAnyEq = createIterableEq(defaultEq());
-  function iterableEq(itemEq) {
-    if (void 0 === itemEq)
-      return _iterableAnyEq;
-    return createIterableEq(itemEq);
-  }
-  Eq2.iterableEq = iterableEq;
-  function createObjectEq(valueEq) {
-    return (v1, v2) => {
-      if (Object.is(v1, v2))
-        return true;
-      if (v1.constructor !== v2.constructor)
-        return false;
-      for (const key in v1) {
-        if (!(key in v2))
-          return false;
-      }
-      for (const key in v2) {
-        if (!(key in v1))
-          return false;
-      }
-      for (const key in v1) {
-        const value1 = v1[key];
-        const value2 = v2[key];
-        if (!valueEq(value1, value2))
-          return false;
-      }
-      return true;
-    };
-  }
-  const _objectEq = createObjectEq(defaultEq());
-  function objectEq(valueEq) {
-    if (void 0 === valueEq)
-      return _objectEq;
-    return createObjectEq(valueEq);
-  }
-  Eq2.objectEq = objectEq;
-  function createAnyEq(mode) {
-    const result = (v1, v2) => {
-      if (Object.is(v1, v2))
-        return true;
-      const type1 = typeof v1;
-      const type2 = typeof v2;
-      if (type1 !== type2)
-        return false;
-      switch (type1) {
-        case "undefined":
-        case "bigint":
-        case "boolean":
-        case "number":
-        case "string":
-        case "symbol":
-        case "function":
-          return Object.is(v1, v2);
-        case "object": {
-          if (v1 === null || v2 === null)
-            return false;
-          if (v1.constructor !== v2.constructor) {
-            return false;
-          }
-          if (v1 instanceof Boolean || v1 instanceof Date || v1 instanceof Number || v1 instanceof String) {
-            return _valueOfEq(v1, v2);
-          }
-          if (mode !== "FLAT") {
-            if (Symbol.iterator in v1 && Symbol.iterator in v2) {
-              if (mode === "SHALLOW") {
-                return createIterableEq(_anyFlatEq)(v1, v2);
-              }
-              return createIterableEq(result)(v1, v2);
-            }
-            if (mode === "SHALLOW") {
-              return createObjectEq(_anyFlatEq)(v1, v2);
-            }
-            return _objectEq(v1, v2);
-          }
-          return false;
-        }
-      }
-    };
-    return result;
-  }
-  function anyFlatEq() {
-    return _anyFlatEq;
-  }
-  Eq2.anyFlatEq = anyFlatEq;
-  function anyShallowEq() {
-    return _anyShallowEq;
-  }
-  Eq2.anyShallowEq = anyShallowEq;
-  function anyDeepEq() {
-    return _anyDeepEq;
-  }
-  Eq2.anyDeepEq = anyDeepEq;
-  const _defaultCollator = Intl.Collator("und");
-  const _defaultStringCollatorEq = (v1, v2) => _defaultCollator.compare(v1, v2) === 0;
-  function createStringCollatorEq(...args) {
-    if (args.length === 0)
-      return _defaultStringCollatorEq;
-    const collator = Intl.Collator(...args);
-    return (v1, v2) => collator.compare(v1, v2) === 0;
-  }
-  Eq2.createStringCollatorEq = createStringCollatorEq;
-  const _stringCaseInsensitiveEq = createStringCollatorEq("und", {
-    sensitivity: "accent"
-  });
-  function stringCaseInsentitiveEq() {
-    return _stringCaseInsensitiveEq;
-  }
-  Eq2.stringCaseInsentitiveEq = stringCaseInsentitiveEq;
-  const _stringCharCodeEq = (v1, v2) => {
-    const len = v1.length;
-    if (len !== v2.length)
-      return false;
-    let i = -1;
-    while (++i < len) {
-      if (v1.charCodeAt(i) !== v2.charCodeAt(i))
-        return false;
-    }
-    return true;
-  };
-  function stringCharCodeEq() {
-    return _stringCharCodeEq;
-  }
-  Eq2.stringCharCodeEq = stringCharCodeEq;
-  const _anyToStringEq = (v1, v2) => convertAnyToString(v1) === convertAnyToString(v2);
-  function anyToStringEq() {
-    return _anyToStringEq;
-  }
-  Eq2.anyToStringEq = anyToStringEq;
-  const _anyJsonEq = (v1, v2) => JSON.stringify(v1) === JSON.stringify(v2);
-  function anyJsonEq() {
-    return _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]);
-  }
-  Eq2.tupleSymmetric = tupleSymmetric;
-})(Eq || (Eq = {}));
-
-// src/err.mts
-function Err() {
-  return ErrBase.msg("Err: Forced to throw error")();
-}
-var ErrBase;
-((ErrBase2) => {
-  class CustomError {
-    constructor(message) {
-      this.message = message;
-    }
-    get name() {
-      return this.constructor.name;
-    }
-  }
-  ErrBase2.CustomError = CustomError;
-  class ForcedError extends CustomError {
-  }
-  ErrBase2.ForcedError = ForcedError;
-  function msg(message) {
-    return function() {
-      throw new ErrBase2.ForcedError(message);
-    };
-  }
-  ErrBase2.msg = msg;
-})(ErrBase || (ErrBase = {}));
-
-// src/index-range.mts
-var IndexRange;
-((IndexRange2) => {
-  function getIndexRangeIndices(range) {
-    if (void 0 !== range.amount) {
-      if (void 0 === range.start)
-        return [0, range.amount - 1];
-      if (Array.isArray(range.start)) {
-        const [start2, includeStart] = range.start;
-        if (includeStart)
-          return [start2, start2 + range.amount - 1];
-        return [start2 + 1, start2 + 1 + range.amount - 1];
-      }
-      return [range.start, range.start + range.amount - 1];
-    }
-    let start = 0;
-    let end = void 0;
-    if (`start` in range) {
-      if (Array.isArray(range.start)) {
-        if (range.start[1])
-          start = range.start[0];
-        else
-          start = range.start[0] + 1;
-      } else
-        start = range.start ?? 0;
-    }
-    if (`end` in range) {
-      if (Array.isArray(range.end)) {
-        if (range.end[1])
-          end = range.end[0];
-        else
-          end = range.end[0] - 1;
-      } else
-        end = range.end;
-    }
-    return [start, end];
-  }
-  IndexRange2.getIndexRangeIndices = getIndexRangeIndices;
-  function getIndicesFor(range, length) {
-    if (length <= 0)
-      return "empty";
-    let start = 0;
-    let end = length - 1;
-    if (void 0 !== range.start) {
-      if (Array.isArray(range.start)) {
-        start = range.start[0];
-        if (!range.start[1])
-          start++;
-      } else
-        start = range.start;
-      if (start >= length || -start > length)
-        return "empty";
-      if (start < 0)
-        start = length + start;
-    }
-    if (void 0 !== range.amount) {
-      if (range.amount <= 0)
-        return "empty";
-      if (void 0 === range.start) {
-        if (range.amount >= length)
-          return "all";
-        return [0, Math.min(end, range.amount - 1)];
-      }
-      end = start + range.amount - 1;
-    } else if (void 0 !== range.end) {
-      if (Array.isArray(range.end)) {
-        end = range.end[0];
-        if (!range.end[1]) {
-          if (end === 0)
-            return "empty";
-          end--;
-        }
-      } else
-        end = range.end;
-      if (end < 0)
-        end = length + end;
-    }
-    if (end < start)
-      return "empty";
-    end = Math.min(length - 1, end);
-    if (start === 0 && end === length - 1)
-      return "all";
-    return [start, end];
-  }
-  IndexRange2.getIndicesFor = getIndicesFor;
-})(IndexRange || (IndexRange = {}));
-
-// src/optlazy.mts
-function OptLazy(optLazy, ...args) {
-  if (optLazy instanceof Function)
-    return optLazy(...args);
-  return optLazy;
-}
-function OptLazyOr(optLazyOr, otherValue) {
-  if (optLazyOr instanceof Function)
-    return optLazyOr(otherValue);
-  return optLazyOr;
-}
-
-// src/range.mts
-var Range;
-((Range2) => {
-  function getNormalizedRange(range) {
-    let start = void 0;
-    let end = void 0;
-    if (`start` in range && void 0 !== range.start) {
-      if (Array.isArray(range.start) && range.start.length === 2 && typeof range.start[1] === "boolean") {
-        start = range.start;
-      } else {
-        start = [range.start, true];
-      }
-    }
-    if (`end` in range && void 0 !== range.end) {
-      if (Array.isArray(range.end) && range.end.length === 2 && typeof range.end[1] === "boolean") {
-        end = range.end;
-      } else {
-        end = [range.end, true];
-      }
-    }
-    return { start, end };
-  }
-  Range2.getNormalizedRange = getNormalizedRange;
-})(Range || (Range = {}));
-
-// src/traverse-state.mts
-var TraverseStateImpl = class {
-  constructor(startIndex) {
-    this.startIndex = startIndex;
-    this.halted = false;
-    this.halt = () => {
-      this.halted = true;
-    };
-    this.currentIndex = startIndex;
-  }
-  nextIndex() {
-    return this.currentIndex++;
-  }
-  reset() {
-    this.currentIndex = this.startIndex;
-    this.halted = false;
-  }
-};
-function TraverseState(startIndex = 0) {
-  return new TraverseStateImpl(startIndex);
-}
-
-// src/update.mts
-function Update(value, update) {
-  if (typeof update === "function") {
-    return update(value);
-  }
-  return update;
-}
-
-// src/async-optlazy.mts
-var AsyncOptLazy;
-((AsyncOptLazy2) => {
-  function toMaybePromise(optLazy, ...args) {
-    if (optLazy instanceof Function)
-      return optLazy(...args);
-    return optLazy;
-  }
-  AsyncOptLazy2.toMaybePromise = toMaybePromise;
-  async function toPromise(optLazy, ...args) {
-    if (optLazy instanceof Function)
-      return optLazy(...args);
-    return optLazy;
-  }
-  AsyncOptLazy2.toPromise = toPromise;
-})(AsyncOptLazy || (AsyncOptLazy = {}));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AsyncOptLazy,
-  CollectFun,
-  Comp,
-  Eq,
-  Err,
-  ErrBase,
-  IndexRange,
-  OptLazy,
-  OptLazyOr,
-  Range,
-  TraverseState,
-  Update
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./collect.cjs"), exports);
+tslib_1.__exportStar(require("./comp.cjs"), exports);
+tslib_1.__exportStar(require("./eq.cjs"), exports);
+tslib_1.__exportStar(require("./err.cjs"), exports);
+tslib_1.__exportStar(require("./index-range.cjs"), exports);
+tslib_1.__exportStar(require("./optlazy.cjs"), exports);
+tslib_1.__exportStar(require("./range.cjs"), exports);
+tslib_1.__exportStar(require("./traverse-state.cjs"), exports);
+tslib_1.__exportStar(require("./types.cjs"), exports);
+tslib_1.__exportStar(require("./update.cjs"), exports);
+tslib_1.__exportStar(require("./async-optlazy.cjs"), exports);
+//# sourceMappingURL=internal.cjs.map