@getodk/xpath 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { c as commonjsGlobal, U as UpsertableMap, e as expressionParser, g as getAugmentedNamespace, a as getDefaultExportFromCjs } from './expressionParser-BbqMYp75.js';
+import { c as commonjsGlobal, U as UpsertableMap, e as expressionParser, g as getAugmentedNamespace, a as getDefaultExportFromCjs } from './expressionParser-BRkDdCO9.js';
 
 function _mergeNamespaces(n, m) {
 	for (var i = 0; i < m.length; i++) {
@@ -8044,6 +8044,33 @@ function requireSet () {
 	if (hasRequiredSet) return set;
 	hasRequiredSet = 1;
 
+	var __awaiter = commonjsGlobal && commonjsGlobal.__awaiter || function (thisArg, _arguments, P, generator) {
+	  function adopt(value) {
+	    return value instanceof P ? value : new P(function (resolve) {
+	      resolve(value);
+	    });
+	  }
+	  return new (P || (P = Promise))(function (resolve, reject) {
+	    function fulfilled(value) {
+	      try {
+	        step(generator.next(value));
+	      } catch (e) {
+	        reject(e);
+	      }
+	    }
+	    function rejected(value) {
+	      try {
+	        step(generator["throw"](value));
+	      } catch (e) {
+	        reject(e);
+	      }
+	    }
+	    function step(result) {
+	      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+	    }
+	    step((generator = generator.apply(thisArg, _arguments || [])).next());
+	  });
+	};
 	var __generator = commonjsGlobal && commonjsGlobal.__generator || function (thisArg, body) {
 	  var _ = {
 	      label: 0,
@@ -8259,7 +8286,7 @@ function requireSet () {
 	Object.defineProperty(set, "__esModule", {
 	  value: true
 	});
-	set.unionAsync = set.union = set.symmetricDifferenceAsync = set.symmetricDifference = set.partialIntersectionAsync = set.partialIntersection = set.intersectionAsync = set.intersection = set.distinctAsync = set.distinct = void 0;
+	set.cartesianProductAsync = set.cartesianProduct = set.unionAsync = set.union = set.symmetricDifferenceAsync = set.symmetricDifference = set.partialIntersectionAsync = set.partialIntersection = set.intersectionAsync = set.intersection = set.distinctAsync = set.distinct = void 0;
 	var transform_1 = requireTransform();
 	var tools_1 = requireTools();
 	var single_1 = requireSingle();
@@ -9074,6 +9101,241 @@ function requireSet () {
 	  });
 	}
 	set.unionAsync = unionAsync;
+	/**
+	 * Iterates cartesian product of given iterables.
+	 *
+	 * @param iterables
+	 */
+	function cartesianProduct() {
+	  var _i, _a, _b, item, e_17_1, arrays, toIterate, toIterate_1, toIterate_1_1, item, e_18_1;
+	  var e_17, _c, e_18, _d;
+	  var iterables = [];
+	  for (_i = 0; _i < arguments.length; _i++) {
+	    iterables[_i] = arguments[_i];
+	  }
+	  return __generator(this, function (_e) {
+	    switch (_e.label) {
+	      case 0:
+	        if (iterables.length === 0) {
+	          return [2 /*return*/];
+	        }
+	        if (!(iterables.length === 1)) return [3 /*break*/, 9];
+	        _e.label = 1;
+	      case 1:
+	        _e.trys.push([1, 6, 7, 8]);
+	        _a = __values((0, transform_1.toIterable)(iterables[0])), _b = _a.next();
+	        _e.label = 2;
+	      case 2:
+	        if (!!_b.done) return [3 /*break*/, 5];
+	        item = _b.value;
+	        return [4 /*yield*/, [item]];
+	      case 3:
+	        _e.sent();
+	        _e.label = 4;
+	      case 4:
+	        _b = _a.next();
+	        return [3 /*break*/, 2];
+	      case 5:
+	        return [3 /*break*/, 8];
+	      case 6:
+	        e_17_1 = _e.sent();
+	        e_17 = {
+	          error: e_17_1
+	        };
+	        return [3 /*break*/, 8];
+	      case 7:
+	        try {
+	          if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+	        } finally {
+	          if (e_17) throw e_17.error;
+	        }
+	        return [7 /*endfinally*/];
+	      case 8:
+	        return [2 /*return*/];
+	      case 9:
+	        arrays = (0, transform_1.toArray)((0, single_1.map)(iterables, function (iterable) {
+	          return (0, transform_1.toArray)(iterable);
+	        }));
+	        toIterate = arrays.reduce(function (acc, set) {
+	          return acc.flatMap(function (x) {
+	            return set.map(function (y) {
+	              return __spreadArray(__spreadArray([], __read(x), false), [y], false);
+	            });
+	          });
+	        }, [[]]);
+	        _e.label = 10;
+	      case 10:
+	        _e.trys.push([10, 15, 16, 17]);
+	        toIterate_1 = __values(toIterate), toIterate_1_1 = toIterate_1.next();
+	        _e.label = 11;
+	      case 11:
+	        if (!!toIterate_1_1.done) return [3 /*break*/, 14];
+	        item = toIterate_1_1.value;
+	        return [4 /*yield*/, item];
+	      case 12:
+	        _e.sent();
+	        _e.label = 13;
+	      case 13:
+	        toIterate_1_1 = toIterate_1.next();
+	        return [3 /*break*/, 11];
+	      case 14:
+	        return [3 /*break*/, 17];
+	      case 15:
+	        e_18_1 = _e.sent();
+	        e_18 = {
+	          error: e_18_1
+	        };
+	        return [3 /*break*/, 17];
+	      case 16:
+	        try {
+	          if (toIterate_1_1 && !toIterate_1_1.done && (_d = toIterate_1.return)) _d.call(toIterate_1);
+	        } finally {
+	          if (e_18) throw e_18.error;
+	        }
+	        return [7 /*endfinally*/];
+	      case 17:
+	        return [2 /*return*/];
+	    }
+	  });
+	}
+	set.cartesianProduct = cartesianProduct;
+	/**
+	 * Iterates cartesian product of given async iterables.
+	 *
+	 * @param iterables
+	 */
+	function cartesianProductAsync() {
+	  var iterables = [];
+	  for (var _i = 0; _i < arguments.length; _i++) {
+	    iterables[_i] = arguments[_i];
+	  }
+	  return __asyncGenerator(this, arguments, function cartesianProductAsync_1() {
+	    var _a, _b, _c, item, e_19_1, arrays, toIterate, toIterate_2, toIterate_2_1, item, e_20_1;
+	    var e_20, _d;
+	    var _this = this;
+	    var _e, e_19, _f, _g;
+	    return __generator(this, function (_h) {
+	      switch (_h.label) {
+	        case 0:
+	          if (!(iterables.length === 0)) return [3 /*break*/, 2];
+	          return [4 /*yield*/, __await(void 0)];
+	        case 1:
+	          return [2 /*return*/, _h.sent()];
+	        case 2:
+	          if (!(iterables.length === 1)) return [3 /*break*/, 20];
+	          _h.label = 3;
+	        case 3:
+	          _h.trys.push([3, 12, 13, 18]);
+	          _a = true, _b = __asyncValues((0, transform_1.toAsyncIterable)(iterables[0]));
+	          _h.label = 4;
+	        case 4:
+	          return [4 /*yield*/, __await(_b.next())];
+	        case 5:
+	          if (!(_c = _h.sent(), _e = _c.done, !_e)) return [3 /*break*/, 11];
+	          _g = _c.value;
+	          _a = false;
+	          _h.label = 6;
+	        case 6:
+	          _h.trys.push([6,, 9, 10]);
+	          item = _g;
+	          return [4 /*yield*/, __await([item])];
+	        case 7:
+	          return [4 /*yield*/, _h.sent()];
+	        case 8:
+	          _h.sent();
+	          return [3 /*break*/, 10];
+	        case 9:
+	          _a = true;
+	          return [7 /*endfinally*/];
+	        case 10:
+	          return [3 /*break*/, 4];
+	        case 11:
+	          return [3 /*break*/, 18];
+	        case 12:
+	          e_19_1 = _h.sent();
+	          e_19 = {
+	            error: e_19_1
+	          };
+	          return [3 /*break*/, 18];
+	        case 13:
+	          _h.trys.push([13,, 16, 17]);
+	          if (!(!_a && !_e && (_f = _b.return))) return [3 /*break*/, 15];
+	          return [4 /*yield*/, __await(_f.call(_b))];
+	        case 14:
+	          _h.sent();
+	          _h.label = 15;
+	        case 15:
+	          return [3 /*break*/, 17];
+	        case 16:
+	          if (e_19) throw e_19.error;
+	          return [7 /*endfinally*/];
+	        case 17:
+	          return [7 /*endfinally*/];
+	        case 18:
+	          return [4 /*yield*/, __await(void 0)];
+	        case 19:
+	          return [2 /*return*/, _h.sent()];
+	        case 20:
+	          return [4 /*yield*/, __await((0, transform_1.toArrayAsync)((0, single_1.mapAsync)(iterables, function (iterable) {
+	            return __awaiter(_this, void 0, void 0, function () {
+	              return __generator(this, function (_a) {
+	                switch (_a.label) {
+	                  case 0:
+	                    return [4 /*yield*/, (0, transform_1.toArrayAsync)(iterable)];
+	                  case 1:
+	                    return [2 /*return*/, _a.sent()];
+	                }
+	              });
+	            });
+	          })))];
+	        case 21:
+	          arrays = _h.sent();
+	          toIterate = arrays.reduce(function (acc, set) {
+	            return acc.flatMap(function (x) {
+	              return set.map(function (y) {
+	                return __spreadArray(__spreadArray([], __read(x), false), [y], false);
+	              });
+	            });
+	          }, [[]]);
+	          _h.label = 22;
+	        case 22:
+	          _h.trys.push([22, 28, 29, 30]);
+	          toIterate_2 = __values(toIterate), toIterate_2_1 = toIterate_2.next();
+	          _h.label = 23;
+	        case 23:
+	          if (!!toIterate_2_1.done) return [3 /*break*/, 27];
+	          item = toIterate_2_1.value;
+	          return [4 /*yield*/, __await(item)];
+	        case 24:
+	          return [4 /*yield*/, _h.sent()];
+	        case 25:
+	          _h.sent();
+	          _h.label = 26;
+	        case 26:
+	          toIterate_2_1 = toIterate_2.next();
+	          return [3 /*break*/, 23];
+	        case 27:
+	          return [3 /*break*/, 30];
+	        case 28:
+	          e_20_1 = _h.sent();
+	          e_20 = {
+	            error: e_20_1
+	          };
+	          return [3 /*break*/, 30];
+	        case 29:
+	          try {
+	            if (toIterate_2_1 && !toIterate_2_1.done && (_d = toIterate_2.return)) _d.call(toIterate_2);
+	          } finally {
+	            if (e_20) throw e_20.error;
+	          }
+	          return [7 /*endfinally*/];
+	        case 30:
+	          return [2 /*return*/];
+	      }
+	    });
+	  });
+	}
+	set.cartesianProductAsync = cartesianProductAsync;
 	return set;
 }
 
@@ -12117,6 +12379,415 @@ function requireSingle () {
 	return single;
 }
 
+var infinite = {};
+
+var hasRequiredInfinite;
+
+function requireInfinite () {
+	if (hasRequiredInfinite) return infinite;
+	hasRequiredInfinite = 1;
+
+	var __generator = commonjsGlobal && commonjsGlobal.__generator || function (thisArg, body) {
+	  var _ = {
+	      label: 0,
+	      sent: function () {
+	        if (t[0] & 1) throw t[1];
+	        return t[1];
+	      },
+	      trys: [],
+	      ops: []
+	    },
+	    f,
+	    y,
+	    t,
+	    g;
+	  return g = {
+	    next: verb(0),
+	    "throw": verb(1),
+	    "return": verb(2)
+	  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+	    return this;
+	  }), g;
+	  function verb(n) {
+	    return function (v) {
+	      return step([n, v]);
+	    };
+	  }
+	  function step(op) {
+	    if (f) throw new TypeError("Generator is already executing.");
+	    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+	      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+	      if (y = 0, t) op = [op[0] & 2, t.value];
+	      switch (op[0]) {
+	        case 0:
+	        case 1:
+	          t = op;
+	          break;
+	        case 4:
+	          _.label++;
+	          return {
+	            value: op[1],
+	            done: false
+	          };
+	        case 5:
+	          _.label++;
+	          y = op[1];
+	          op = [0];
+	          continue;
+	        case 7:
+	          op = _.ops.pop();
+	          _.trys.pop();
+	          continue;
+	        default:
+	          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+	            _ = 0;
+	            continue;
+	          }
+	          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+	            _.label = op[1];
+	            break;
+	          }
+	          if (op[0] === 6 && _.label < t[1]) {
+	            _.label = t[1];
+	            t = op;
+	            break;
+	          }
+	          if (t && _.label < t[2]) {
+	            _.label = t[2];
+	            _.ops.push(op);
+	            break;
+	          }
+	          if (t[2]) _.ops.pop();
+	          _.trys.pop();
+	          continue;
+	      }
+	      op = body.call(thisArg, _);
+	    } catch (e) {
+	      op = [6, e];
+	      y = 0;
+	    } finally {
+	      f = t = 0;
+	    }
+	    if (op[0] & 5) throw op[1];
+	    return {
+	      value: op[0] ? op[1] : void 0,
+	      done: true
+	    };
+	  }
+	};
+	var __asyncValues = commonjsGlobal && commonjsGlobal.__asyncValues || function (o) {
+	  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+	  var m = o[Symbol.asyncIterator],
+	    i;
+	  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
+	    return this;
+	  }, i);
+	  function verb(n) {
+	    i[n] = o[n] && function (v) {
+	      return new Promise(function (resolve, reject) {
+	        v = o[n](v), settle(resolve, reject, v.done, v.value);
+	      });
+	    };
+	  }
+	  function settle(resolve, reject, d, v) {
+	    Promise.resolve(v).then(function (v) {
+	      resolve({
+	        value: v,
+	        done: d
+	      });
+	    }, reject);
+	  }
+	};
+	var __await = commonjsGlobal && commonjsGlobal.__await || function (v) {
+	  return this instanceof __await ? (this.v = v, this) : new __await(v);
+	};
+	var __asyncDelegator = commonjsGlobal && commonjsGlobal.__asyncDelegator || function (o) {
+	  var i, p;
+	  return i = {}, verb("next"), verb("throw", function (e) {
+	    throw e;
+	  }), verb("return"), i[Symbol.iterator] = function () {
+	    return this;
+	  }, i;
+	  function verb(n, f) {
+	    i[n] = o[n] ? function (v) {
+	      return (p = !p) ? {
+	        value: __await(o[n](v)),
+	        done: n === "return"
+	      } : f ? f(v) : v;
+	    } : f;
+	  }
+	};
+	var __asyncGenerator = commonjsGlobal && commonjsGlobal.__asyncGenerator || function (thisArg, _arguments, generator) {
+	  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+	  var g = generator.apply(thisArg, _arguments || []),
+	    i,
+	    q = [];
+	  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
+	    return this;
+	  }, i;
+	  function verb(n) {
+	    if (g[n]) i[n] = function (v) {
+	      return new Promise(function (a, b) {
+	        q.push([n, v, a, b]) > 1 || resume(n, v);
+	      });
+	    };
+	  }
+	  function resume(n, v) {
+	    try {
+	      step(g[n](v));
+	    } catch (e) {
+	      settle(q[0][3], e);
+	    }
+	  }
+	  function step(r) {
+	    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+	  }
+	  function fulfill(value) {
+	    resume("next", value);
+	  }
+	  function reject(value) {
+	    resume("throw", value);
+	  }
+	  function settle(f, v) {
+	    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+	  }
+	};
+	var __read = commonjsGlobal && commonjsGlobal.__read || function (o, n) {
+	  var m = typeof Symbol === "function" && o[Symbol.iterator];
+	  if (!m) return o;
+	  var i = m.call(o),
+	    r,
+	    ar = [],
+	    e;
+	  try {
+	    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+	  } catch (error) {
+	    e = {
+	      error: error
+	    };
+	  } finally {
+	    try {
+	      if (r && !r.done && (m = i["return"])) m.call(i);
+	    } finally {
+	      if (e) throw e.error;
+	    }
+	  }
+	  return ar;
+	};
+	var __spreadArray = commonjsGlobal && commonjsGlobal.__spreadArray || function (to, from, pack) {
+	  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+	    if (ar || !(i in from)) {
+	      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+	      ar[i] = from[i];
+	    }
+	  }
+	  return to.concat(ar || Array.prototype.slice.call(from));
+	};
+	var __values = commonjsGlobal && commonjsGlobal.__values || function (o) {
+	  var s = typeof Symbol === "function" && Symbol.iterator,
+	    m = s && o[s],
+	    i = 0;
+	  if (m) return m.call(o);
+	  if (o && typeof o.length === "number") return {
+	    next: function () {
+	      if (o && i >= o.length) o = void 0;
+	      return {
+	        value: o && o[i++],
+	        done: !o
+	      };
+	    }
+	  };
+	  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+	};
+	Object.defineProperty(infinite, "__esModule", {
+	  value: true
+	});
+	infinite.repeat = infinite.cycleAsync = infinite.cycle = infinite.count = void 0;
+	var transform_1 = requireTransform();
+	/**
+	 * Count sequentially forever
+	 *
+	 * @param start (optional, default 1)
+	 * @param step (optional, default 1)
+	 */
+	function count(start, step) {
+	  var i;
+	  if (start === void 0) {
+	    start = 1;
+	  }
+	  if (step === void 0) {
+	    step = 1;
+	  }
+	  return __generator(this, function (_a) {
+	    switch (_a.label) {
+	      case 0:
+	        i = start;
+	        _a.label = 1;
+	      case 1:
+	        return [4 /*yield*/, i];
+	      case 2:
+	        _a.sent();
+	        _a.label = 3;
+	      case 3:
+	        i += step;
+	        return [3 /*break*/, 1];
+	      case 4:
+	        return [2 /*return*/];
+	    }
+	  });
+	}
+	infinite.count = count;
+	/**
+	 * Cycle through the elements of a collection sequentially forever
+	 *
+	 * @param iterable
+	 */
+	function cycle(iterable) {
+	  var data, data_1, data_1_1, datum, e_1_1;
+	  var e_1, _a;
+	  return __generator(this, function (_b) {
+	    switch (_b.label) {
+	      case 0:
+	        data = __spreadArray([], __read((0, transform_1.toIterable)(iterable)), false);
+	        if (data.length === 0) {
+	          return [2 /*return*/];
+	        }
+	        _b.label = 1;
+	      case 1:
+	        _b.label = 2;
+	      case 2:
+	        _b.trys.push([2, 7, 8, 9]);
+	        data_1 = (e_1 = void 0, __values(data)), data_1_1 = data_1.next();
+	        _b.label = 3;
+	      case 3:
+	        if (!!data_1_1.done) return [3 /*break*/, 6];
+	        datum = data_1_1.value;
+	        return [4 /*yield*/, datum];
+	      case 4:
+	        _b.sent();
+	        _b.label = 5;
+	      case 5:
+	        data_1_1 = data_1.next();
+	        return [3 /*break*/, 3];
+	      case 6:
+	        return [3 /*break*/, 9];
+	      case 7:
+	        e_1_1 = _b.sent();
+	        e_1 = {
+	          error: e_1_1
+	        };
+	        return [3 /*break*/, 9];
+	      case 8:
+	        try {
+	          if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
+	        } finally {
+	          if (e_1) throw e_1.error;
+	        }
+	        return [7 /*endfinally*/];
+	      case 9:
+	        return [3 /*break*/, 1];
+	      case 10:
+	        return [2 /*return*/];
+	    }
+	  });
+	}
+	infinite.cycle = cycle;
+	/**
+	 * Cycle through the elements of a async iterable sequentially forever
+	 *
+	 * @param iterable
+	 */
+	function cycleAsync(iterable) {
+	  return __asyncGenerator(this, arguments, function cycleAsync_1() {
+	    var data, _a, _b, _c, datum, e_2_1;
+	    var _d, e_2, _e, _f;
+	    return __generator(this, function (_g) {
+	      switch (_g.label) {
+	        case 0:
+	          data = [];
+	          _g.label = 1;
+	        case 1:
+	          _g.trys.push([1, 10, 11, 16]);
+	          _a = true, _b = __asyncValues((0, transform_1.toAsyncIterable)(iterable));
+	          _g.label = 2;
+	        case 2:
+	          return [4 /*yield*/, __await(_b.next())];
+	        case 3:
+	          if (!(_c = _g.sent(), _d = _c.done, !_d)) return [3 /*break*/, 9];
+	          _f = _c.value;
+	          _a = false;
+	          _g.label = 4;
+	        case 4:
+	          _g.trys.push([4,, 7, 8]);
+	          datum = _f;
+	          data.push(datum);
+	          return [4 /*yield*/, __await(datum)];
+	        case 5:
+	          return [4 /*yield*/, _g.sent()];
+	        case 6:
+	          _g.sent();
+	          return [3 /*break*/, 8];
+	        case 7:
+	          _a = true;
+	          return [7 /*endfinally*/];
+	        case 8:
+	          return [3 /*break*/, 2];
+	        case 9:
+	          return [3 /*break*/, 16];
+	        case 10:
+	          e_2_1 = _g.sent();
+	          e_2 = {
+	            error: e_2_1
+	          };
+	          return [3 /*break*/, 16];
+	        case 11:
+	          _g.trys.push([11,, 14, 15]);
+	          if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 13];
+	          return [4 /*yield*/, __await(_e.call(_b))];
+	        case 12:
+	          _g.sent();
+	          _g.label = 13;
+	        case 13:
+	          return [3 /*break*/, 15];
+	        case 14:
+	          if (e_2) throw e_2.error;
+	          return [7 /*endfinally*/];
+	        case 15:
+	          return [7 /*endfinally*/];
+	        case 16:
+	          return [5 /*yield**/, __values(__asyncDelegator(__asyncValues(cycle(data))))];
+	        case 17:
+	          return [4 /*yield*/, __await.apply(void 0, [_g.sent()])];
+	        case 18:
+	          _g.sent();
+	          return [2 /*return*/];
+	      }
+	    });
+	  });
+	}
+	infinite.cycleAsync = cycleAsync;
+	/**
+	 * Repeat an item forever
+	 *
+	 * @param item
+	 */
+	function repeat(item) {
+	  return __generator(this, function (_a) {
+	    switch (_a.label) {
+	      case 0:
+	        return [4 /*yield*/, item];
+	      case 1:
+	        _a.sent();
+	        return [3 /*break*/, 0];
+	      case 2:
+	        return [2 /*return*/];
+	    }
+	  });
+	}
+	infinite.repeat = repeat;
+	return infinite;
+}
+
 var math = {};
 
 var hasRequiredMath;
@@ -13275,11 +13946,12 @@ function requireReduce () {
 	Object.defineProperty(reduce$1, "__esModule", {
 	  value: true
 	});
-	reduce$1.toFirstAndLastAsync = reduce$1.toFirstAndLast = reduce$1.toLastAsync = reduce$1.toLast = reduce$1.toFirstAsync = reduce$1.toFirst = reduce$1.toCountAsync = reduce$1.toCount = reduce$1.toProductAsync = reduce$1.toProduct = reduce$1.toSumAsync = reduce$1.toSum = reduce$1.toMinMaxAsync = reduce$1.toMinMax = reduce$1.toMinAsync = reduce$1.toMin = reduce$1.toMaxAsync = reduce$1.toMax = reduce$1.toAverageAsync = reduce$1.toAverage = reduce$1.toValueAsync = reduce$1.toValue = void 0;
+	reduce$1.toFirstAndLastAsync = reduce$1.toFirstAndLast = reduce$1.toLastAsync = reduce$1.toLast = reduce$1.toFirstAsync = reduce$1.toFirst = reduce$1.toCountAsync = reduce$1.toCount = reduce$1.toProductAsync = reduce$1.toProduct = reduce$1.toSumAsync = reduce$1.toSum = reduce$1.toRangeAsync = reduce$1.toRange = reduce$1.toMinMaxAsync = reduce$1.toMinMax = reduce$1.toMinAsync = reduce$1.toMin = reduce$1.toMaxAsync = reduce$1.toMax = reduce$1.toAverageAsync = reduce$1.toAverage = reduce$1.toValueAsync = reduce$1.toValue = void 0;
 	var transform_1 = requireTransform();
 	var exceptions_1 = exceptions;
 	var summary_1 = requireSummary();
 	var tools_1 = requireTools();
+	var single_1 = requireSingle();
 	/**
 	 * Reduces iterable source like `array.reduce()` function.
 	 *
@@ -13645,6 +14317,46 @@ function requireReduce () {
 	  });
 	}
 	reduce$1.toMinMaxAsync = toMinMaxAsync;
+	/**
+	 * Reduces given collection to its range.
+	 *
+	 * Returns 0 if given collection is empty.
+	 *
+	 * @param numbers
+	 */
+	function toRange(numbers) {
+	  var _a = __read(toMinMax((0, single_1.map)(numbers, function (n) {
+	      return Number(n);
+	    })), 2),
+	    min = _a[0],
+	    max = _a[1];
+	  return (max !== null && max !== void 0 ? max : 0) - (min !== null && min !== void 0 ? min : 0);
+	}
+	reduce$1.toRange = toRange;
+	/**
+	 * Reduces given async collection to its range.
+	 *
+	 * Returns 0 if given async collection is empty.
+	 *
+	 * @param numbers
+	 */
+	function toRangeAsync(numbers) {
+	  return __awaiter(this, void 0, void 0, function () {
+	    var _a, min, max;
+	    return __generator(this, function (_b) {
+	      switch (_b.label) {
+	        case 0:
+	          return [4 /*yield*/, toMinMaxAsync((0, single_1.mapAsync)(numbers, function (n) {
+	            return Number(n);
+	          }))];
+	        case 1:
+	          _a = __read.apply(void 0, [_b.sent(), 2]), min = _a[0], max = _a[1];
+	          return [2 /*return*/, (max !== null && max !== void 0 ? max : 0) - (min !== null && min !== void 0 ? min : 0)];
+	      }
+	    });
+	  });
+	}
+	reduce$1.toRangeAsync = toRangeAsync;
 	/**
 	 * Reduces given collection to the sum of its items.
 	 *
@@ -14214,6 +14926,7 @@ function requireStream () {
 	var set_1 = requireSet();
 	var reduce_1 = requireReduce();
 	var summary_1 = requireSummary();
+	var index_1 = requireLib();
 	/**
 	 * Provides fluent interface for working with iterables.
 	 */
@@ -14240,6 +14953,43 @@ function requireStream () {
 	  Stream.ofEmpty = function () {
 	    return new Stream([]);
 	  };
+	  /**
+	   * Creates iterable instance with fluent interface from infinite count iterable.
+	   *
+	   * @param start (optional, default 1)
+	   * @param step (optional, default 1)
+	   *
+	   * @see infinite.count
+	   */
+	  Stream.ofCount = function (start, step) {
+	    if (start === void 0) {
+	      start = 1;
+	    }
+	    if (step === void 0) {
+	      step = 1;
+	    }
+	    return new Stream(index_1.infinite.count(start, step));
+	  };
+	  /**
+	   * Creates iterable instance with fluent interface from infinite collection items repeating.
+	   *
+	   * @param iterable
+	   *
+	   * @see infinite.cycle
+	   */
+	  Stream.ofCycle = function (iterable) {
+	    return new Stream(index_1.infinite.cycle(iterable));
+	  };
+	  /**
+	   * Creates iterable instance with fluent interface from infinite item repeating.
+	   *
+	   * @param item
+	   *
+	   * @see infinite.repeat
+	   */
+	  Stream.ofRepeat = function (item) {
+	    return new Stream(index_1.infinite.repeat(item));
+	  };
 	  /**
 	   * Iterate stream collection with another iterable collections simultaneously.
 	   *
@@ -14718,6 +15468,21 @@ function requireStream () {
 	    this.data = set_1.union.apply(void 0, __spreadArray([this.data], __read(iterables), false));
 	    return this;
 	  };
+	  /**
+	   * Iterates cartesian product of iterable source and given iterables.
+	   *
+	   * @param iterables
+	   *
+	   * @see set.cartesianProduct
+	   */
+	  Stream.prototype.cartesianProductWith = function () {
+	    var iterables = [];
+	    for (var _i = 0; _i < arguments.length; _i++) {
+	      iterables[_i] = arguments[_i];
+	    }
+	    this.data = set_1.cartesianProduct.apply(void 0, __spreadArray([this.data], __read(iterables), false));
+	    return this;
+	  };
 	  /**
 	   * Peek at each element between other Stream operations to do some action without modifying the stream.
 	   *
@@ -14887,6 +15652,16 @@ function requireStream () {
 	  Stream.prototype.toProduct = function () {
 	    return (0, reduce_1.toProduct)(this);
 	  };
+	  /**
+	   * Reduces given collection to its range.
+	   *
+	   * Returns 0 if given collection is empty.
+	   *
+	   * @see reduce.toRange
+	   */
+	  Stream.prototype.toRange = function () {
+	    return (0, reduce_1.toRange)(this);
+	  };
 	  /**
 	   * Returns true if all elements of stream match the predicate function.
 	   *
@@ -15323,6 +16098,7 @@ function requireAsyncStream () {
 	var set_1 = requireSet();
 	var reduce_1 = requireReduce();
 	var summary_1 = requireSummary();
+	var index_1 = requireLib();
 	/**
 	 * Provides fluent interface for working with async iterables.
 	 */
@@ -15349,6 +16125,37 @@ function requireAsyncStream () {
 	  AsyncStream.ofEmpty = function () {
 	    return new AsyncStream((0, transform_1.toAsyncIterable)([]));
 	  };
+	  /**
+	   * Creates iterable instance with fluent interface from infinite count iterable.
+	   *
+	   * @param start (optional, default 1)
+	   * @param step (optional, default 1)
+	   */
+	  AsyncStream.ofCount = function (start, step) {
+	    if (start === void 0) {
+	      start = 1;
+	    }
+	    if (step === void 0) {
+	      step = 1;
+	    }
+	    return new AsyncStream((0, transform_1.toAsyncIterable)(index_1.infinite.count(start, step)));
+	  };
+	  /**
+	   * Creates iterable instance with fluent interface from infinite collection items repeating.
+	   *
+	   * @param iterable
+	   */
+	  AsyncStream.ofCycle = function (iterable) {
+	    return new AsyncStream(index_1.infinite.cycleAsync(iterable));
+	  };
+	  /**
+	   * Creates iterable instance with fluent interface from infinite item repeating.
+	   *
+	   * @param item
+	   */
+	  AsyncStream.ofRepeat = function (item) {
+	    return new AsyncStream((0, transform_1.toAsyncIterable)(index_1.infinite.repeat(item)));
+	  };
 	  /**
 	   * Iterate stream collection with another iterable collections simultaneously.
 	   *
@@ -15827,6 +16634,21 @@ function requireAsyncStream () {
 	    this.data = set_1.unionAsync.apply(void 0, __spreadArray([this.data], __read(iterables), false));
 	    return this;
 	  };
+	  /**
+	   * Iterates cartesian product of iterable source and given iterables.
+	   *
+	   * @param iterables
+	   *
+	   * @see set.cartesianProductAsync
+	   */
+	  AsyncStream.prototype.cartesianProductWith = function () {
+	    var iterables = [];
+	    for (var _i = 0; _i < arguments.length; _i++) {
+	      iterables[_i] = arguments[_i];
+	    }
+	    this.data = set_1.cartesianProductAsync.apply(void 0, __spreadArray([this.data], __read(iterables), false));
+	    return this;
+	  };
 	  /**
 	   * Peek at each element between other Stream operations to do some action without modifying the stream.
 	   *
@@ -16134,6 +16956,25 @@ function requireAsyncStream () {
 	      });
 	    });
 	  };
+	  /**
+	   * Reduces given collection to its range.
+	   *
+	   * Returns 0 if given collection is empty.
+	   *
+	   * @see reduce.toRangeAsync
+	   */
+	  AsyncStream.prototype.toRange = function () {
+	    return __awaiter(this, void 0, void 0, function () {
+	      return __generator(this, function (_a) {
+	        switch (_a.label) {
+	          case 0:
+	            return [4 /*yield*/, (0, reduce_1.toRangeAsync)(this)];
+	          case 1:
+	            return [2 /*return*/, _a.sent()];
+	        }
+	      });
+	    });
+	  };
 	  /**
 	   * Returns true if all elements of stream match the predicate function.
 	   *
@@ -16207,7 +17048,7 @@ function requireAsyncStream () {
 	   *
 	   * @see summary.exactlyNAsync
 	   */
-	  AsyncStream.prototype.exactlyNAsync = function (n, predicate) {
+	  AsyncStream.prototype.exactlyN = function (n, predicate) {
 	    return __awaiter(this, void 0, void 0, function () {
 	      return __generator(this, function (_a) {
 	        return [2 /*return*/, (0, summary_1.exactlyNAsync)(this, n, predicate)];
@@ -16477,8 +17318,9 @@ function requireLib () {
 		Object.defineProperty(exports, "__esModule", {
 		  value: true
 		});
-		exports.LengthError = exports.InvalidArgumentError = exports.AsyncStream = exports.Stream = exports.transform = exports.summary = exports.reduce = exports.set = exports.multi = exports.math = exports.single = void 0;
+		exports.LengthError = exports.InvalidArgumentError = exports.AsyncStream = exports.Stream = exports.transform = exports.summary = exports.reduce = exports.set = exports.multi = exports.math = exports.infinite = exports.single = void 0;
 		var single_1 = requireSingle();
+		var infinite_1 = requireInfinite();
 		var math_1 = requireMath();
 		var multi_1 = requireMulti();
 		var set_1 = requireSet();
@@ -16552,6 +17394,12 @@ function requireLib () {
 		  takeWhileAsync: single_1.takeWhileAsync,
 		  valuesAsync: single_1.valuesAsync
 		};
+		exports.infinite = {
+		  count: infinite_1.count,
+		  cycle: infinite_1.cycle,
+		  cycleAsync: infinite_1.cycleAsync,
+		  repeat: infinite_1.repeat
+		};
 		exports.math = {
 		  runningAverage: math_1.runningAverage,
 		  runningDifference: math_1.runningDifference,
@@ -16584,11 +17432,13 @@ function requireLib () {
 		  partialIntersection: set_1.partialIntersection,
 		  symmetricDifference: set_1.symmetricDifference,
 		  union: set_1.union,
+		  cartesianProduct: set_1.cartesianProduct,
 		  distinctAsync: set_1.distinctAsync,
 		  intersectionAsync: set_1.intersectionAsync,
 		  partialIntersectionAsync: set_1.partialIntersectionAsync,
 		  symmetricDifferenceAsync: set_1.symmetricDifferenceAsync,
-		  unionAsync: set_1.unionAsync
+		  unionAsync: set_1.unionAsync,
+		  cartesianProductAsync: set_1.cartesianProductAsync
 		};
 		exports.reduce = {
 		  toAverage: reduce_1.toAverage,
@@ -16600,6 +17450,7 @@ function requireLib () {
 		  toMin: reduce_1.toMin,
 		  toMinMax: reduce_1.toMinMax,
 		  toProduct: reduce_1.toProduct,
+		  toRange: reduce_1.toRange,
 		  toSum: reduce_1.toSum,
 		  toValue: reduce_1.toValue,
 		  toAverageAsync: reduce_1.toAverageAsync,
@@ -16611,6 +17462,7 @@ function requireLib () {
 		  toMinAsync: reduce_1.toMinAsync,
 		  toMinMaxAsync: reduce_1.toMinMaxAsync,
 		  toProductAsync: reduce_1.toProductAsync,
+		  toRangeAsync: reduce_1.toRangeAsync,
 		  toSumAsync: reduce_1.toSumAsync,
 		  toValueAsync: reduce_1.toValueAsync
 		};
@@ -20588,7 +21440,7 @@ function* toIterableIterator(iter) {
     }
   }
 }
-const map = (fn) => (
+const map$1 = (fn) => (
   // eslint-disable-next-line @typescript-eslint/no-shadow -- naming the function is helpful in stack traces/debugging
   function* map2(iterable) {
     for (const item of toIterableIterator(iterable)) {
@@ -21170,7 +22022,7 @@ class LocationPathEvaluation {
     }
   }
   *following(step) {
-    const contextNodes = map((node) => node.ownerElement ?? node)(
+    const contextNodes = map$1((node) => node.ownerElement ?? node)(
       this.contextNodes
     );
     const treeWalker = this.getTreeWalker(step);
@@ -21763,8 +22615,8 @@ undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator)
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var __await$1 = undefined && undefined.__await || function (v) {
-  return this instanceof __await$1 ? (this.v = v, this) : new __await$1(v);
+var __await$2 = undefined && undefined.__await || function (v) {
+  return this instanceof __await$2 ? (this.v = v, this) : new __await$2(v);
 };
 undefined && undefined.__asyncGenerator || function (thisArg, _arguments, generator) {
   if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
@@ -21789,7 +22641,7 @@ undefined && undefined.__asyncGenerator || function (thisArg, _arguments, genera
     }
   }
   function step(r) {
-    r.value instanceof __await$1 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    r.value instanceof __await$2 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
   }
   function fulfill(value) {
     resume("next", value);
@@ -21839,7 +22691,7 @@ var __awaiter = undefined && undefined.__awaiter || function (thisArg, _argument
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var __asyncValues = undefined && undefined.__asyncValues || function (o) {
+var __asyncValues$1 = undefined && undefined.__asyncValues || function (o) {
   if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
   var m = o[Symbol.asyncIterator],
     i;
@@ -21888,7 +22740,7 @@ function toValueAsync(data, reducer, initialValue) {
   return __awaiter(this, void 0, void 0, function* () {
     let carry = initialValue;
     try {
-      for (var _d = true, _e = __asyncValues(toAsyncIterable(data)), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+      for (var _d = true, _e = __asyncValues$1(toAsyncIterable(data)), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
         _c = _f.value;
         _d = false;
         try {
@@ -22076,6 +22928,30 @@ function toMinMaxAsync(data, compareBy) {
     }), [undefined, undefined]);
   });
 }
+/**
+ * Reduces given collection to its range.
+ *
+ * Returns 0 if given collection is empty.
+ *
+ * @param numbers
+ */
+function toRange(numbers) {
+  const [min, max] = toMinMax(map(numbers, n => Number(n)));
+  return (max !== null && max !== void 0 ? max : 0) - (min !== null && min !== void 0 ? min : 0);
+}
+/**
+ * Reduces given async collection to its range.
+ *
+ * Returns 0 if given async collection is empty.
+ *
+ * @param numbers
+ */
+function toRangeAsync(numbers) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const [min, max] = yield toMinMaxAsync(mapAsync(numbers, n => Number(n)));
+    return (max !== null && max !== void 0 ? max : 0) - (min !== null && min !== void 0 ? min : 0);
+  });
+}
 /**
  * Reduces given collection to the sum of its items.
  *
@@ -22175,7 +23051,7 @@ function toFirstAsync(data) {
   var _a, e_2, _b, _c;
   return __awaiter(this, void 0, void 0, function* () {
     try {
-      for (var _d = true, _e = __asyncValues(toAsyncIterable(data)), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+      for (var _d = true, _e = __asyncValues$1(toAsyncIterable(data)), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
         _c = _f.value;
         _d = false;
         try {
@@ -22231,7 +23107,7 @@ function toLastAsync(data) {
     let isEmpty = true;
     let result;
     try {
-      for (var _d = true, _e = __asyncValues(toAsyncIterable(data)), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+      for (var _d = true, _e = __asyncValues$1(toAsyncIterable(data)), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
         _c = _f.value;
         _d = false;
         try {
@@ -22293,7 +23169,7 @@ function toFirstAndLastAsync(data) {
     let first = NoValueMonad;
     let last = NoValueMonad;
     try {
-      for (var _d = true, _e = __asyncValues(toAsyncIterable(data)), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+      for (var _d = true, _e = __asyncValues$1(toAsyncIterable(data)), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
         _c = _f.value;
         _d = false;
         try {
@@ -22443,10 +23319,10 @@ undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator)
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var __await = undefined && undefined.__await || function (v) {
-  return this instanceof __await ? (this.v = v, this) : new __await(v);
+var __await$1 = undefined && undefined.__await || function (v) {
+  return this instanceof __await$1 ? (this.v = v, this) : new __await$1(v);
 };
-var __asyncGenerator = undefined && undefined.__asyncGenerator || function (thisArg, _arguments, generator) {
+var __asyncGenerator$1 = undefined && undefined.__asyncGenerator || function (thisArg, _arguments, generator) {
   if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
   var g = generator.apply(thisArg, _arguments || []),
     i,
@@ -22469,7 +23345,7 @@ var __asyncGenerator = undefined && undefined.__asyncGenerator || function (this
     }
   }
   function step(r) {
-    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    r.value instanceof __await$1 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
   }
   function fulfill(value) {
     resume("next", value);
@@ -22547,13 +23423,13 @@ function toAsyncIterable(collection) {
   if (isIterator(collection)) {
     return {
       [Symbol.asyncIterator]() {
-        return __asyncGenerator(this, arguments, function* _a() {
+        return __asyncGenerator$1(this, arguments, function* _a() {
           while (true) {
-            const res = yield __await(collection.next());
+            const res = yield __await$1(collection.next());
             if (res.done) {
-              return yield __await(void 0);
+              return yield __await$1(void 0);
             }
-            yield yield __await(res.value);
+            yield yield __await$1(res.value);
           }
         });
       }
@@ -22565,9 +23441,9 @@ function toAsyncIterable(collection) {
   if (isIterable(collection)) {
     return {
       [Symbol.asyncIterator]() {
-        return __asyncGenerator(this, arguments, function* _a() {
+        return __asyncGenerator$1(this, arguments, function* _a() {
           for (const value of collection) {
-            yield yield __await(value);
+            yield yield __await$1(value);
           }
         });
       }
@@ -22576,6 +23452,114 @@ function toAsyncIterable(collection) {
   throw new InvalidArgumentError("Given collection is not async iterable or iterator.");
 }
 
+var __asyncValues = undefined && undefined.__asyncValues || function (o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator],
+    i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function (v) {
+      return new Promise(function (resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function (v) {
+      resolve({
+        value: v,
+        done: d
+      });
+    }, reject);
+  }
+};
+var __await = undefined && undefined.__await || function (v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+};
+var __asyncGenerator = undefined && undefined.__asyncGenerator || function (thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []),
+    i,
+    q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
+    return this;
+  }, i;
+  function verb(n) {
+    if (g[n]) i[n] = function (v) {
+      return new Promise(function (a, b) {
+        q.push([n, v, a, b]) > 1 || resume(n, v);
+      });
+    };
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+};
+/**
+ * Map a function onto every element of the iteration.
+ *
+ * @param data
+ * @param mapper
+ */
+function* map(data, mapper) {
+  for (const datum of toIterable(data)) {
+    yield mapper(datum);
+  }
+}
+/**
+ * Map a function onto every element of the iteration for async collections.
+ *
+ * Mapper may be also async.
+ *
+ * @param data
+ * @param mapper
+ */
+function mapAsync(data, mapper) {
+  return __asyncGenerator(this, arguments, function* mapAsync_1() {
+    var _a, e_1, _b, _c;
+    try {
+      for (var _d = true, _e = __asyncValues(toAsyncIterable(data)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+        _c = _f.value;
+        _d = false;
+        try {
+          const datum = _c;
+          yield yield __await(yield __await(mapper(datum)));
+        } finally {
+          _d = true;
+        }
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+  });
+}
+
 const reduce = {
   toAverage,
   toCount: toCount$1,
@@ -22586,6 +23570,7 @@ const reduce = {
   toMin,
   toMinMax,
   toProduct,
+  toRange,
   toSum,
   toValue,
   toAverageAsync,
@@ -22597,6 +23582,7 @@ const reduce = {
   toMinAsync,
   toMinMaxAsync,
   toProductAsync,
+  toRangeAsync,
   toSumAsync,
   toValueAsync
 };
@@ -25060,6 +26046,100 @@ const countNonEmpty = new NumberFunction(
     return result;
   }
 );
+const assertArgument = (index, arg) => {
+  if (arg == null) {
+    throw new Error(`Argument ${index + 1} expected`);
+  }
+};
+const assertIsLocationPathEvaluation = (evaluation) => {
+  if (!(evaluation instanceof LocationPathEvaluation)) {
+    throw new Error("Expected a node-set result");
+  }
+};
+const evaluateArgumentToFilterableNodes = (context, arg) => {
+  const evaluation = arg.evaluate(context);
+  assertIsLocationPathEvaluation(evaluation);
+  return Array.from(evaluation.contextNodes);
+};
+const compareContainmentDepth = ({ repeats: a }, { repeats: b }) => {
+  for (const repeatA of a) {
+    for (const repeatB of b) {
+      if (repeatA.contains(repeatB)) {
+        return -1;
+      }
+      if (repeatB.contains(repeatA)) {
+        return 1;
+      }
+    }
+  }
+  if (a.length === 0 || b.length === 0) {
+    return 0;
+  }
+  return 0;
+};
+const indexedRepeat = new NodeSetFunction(
+  "indexed-repeat",
+  [
+    // spec: arg
+    { arityType: "required", typeHint: "node" },
+    // spec: repeat1
+    { arityType: "required", typeHint: "node" },
+    // spec: index1
+    { arityType: "required", typeHint: "number" },
+    // spec: repeatN=0 -> repeat2
+    { arityType: "optional", typeHint: "node" },
+    // spec: indexN=0 -> index2
+    { arityType: "optional", typeHint: "number" },
+    // spec: repeatN=1 -> repeat3
+    { arityType: "optional", typeHint: "node" },
+    // spec: indexN=1 -> index3
+    { arityType: "optional", typeHint: "number" },
+    // Go beyond spec? Why the heck not! It's clearly a variadic design.
+    { arityType: "variadic", typeHint: "any" }
+  ],
+  (context, args) => {
+    const target = args[0];
+    let pairs = [];
+    for (let i = 1; i < args.length; i += 2) {
+      const repeatsArg = args[i];
+      const positionArg = args[i + 1];
+      assertArgument(i, repeatsArg);
+      assertArgument(i + 1, positionArg);
+      const position2 = positionArg.evaluate(context).toNumber();
+      if (Number.isNaN(position2)) {
+        return [];
+      }
+      const repeats = evaluateArgumentToFilterableNodes(context, repeatsArg);
+      if (repeats.length === 0) {
+        return [];
+      }
+      pairs.push({
+        repeats,
+        position: position2
+      });
+    }
+    pairs = pairs.sort(compareContainmentDepth);
+    let repeatContextNode;
+    for (const [index, pair] of pairs.entries()) {
+      const { position: position2 } = pair;
+      let { repeats } = pair;
+      if (index > 0) {
+        repeats = pair.repeats.filter((repeat) => {
+          return repeatContextNode.contains(repeat);
+        });
+      }
+      const positionedRepeat = repeats[position2 - 1];
+      if (positionedRepeat == null) {
+        return [];
+      }
+      repeatContextNode = positionedRepeat;
+    }
+    const targetNodes = evaluateArgumentToFilterableNodes(context, target);
+    return targetNodes.filter((targetNode) => {
+      return repeatContextNode.contains(targetNode);
+    });
+  }
+);
 const identifiedInstanceLookup = new ScopedElementLookup(":scope > instance[id]", "instance[id]");
 const instancesCache = new UpsertableWeakMap();
 const getInstanceElementByID = (modelElement, id) => {
@@ -25158,6 +26238,7 @@ const randomize = new NodeSetFunction(
 const nodeset = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	__proto__: null,
 	countNonEmpty,
+	indexedRepeat,
 	instance,
 	once,
 	position,