@jin-qu/jinqu 2.0.0

package/dist/lib/array-query-provider.js

@@ -0,0 +1,1532 @@
+"use strict";
+var __generator = (this && this.__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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 __values = (this && this.__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.");
+};
+var __read = (this && this.__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 = (this && this.__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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayQueryProvider = void 0;
+var class_transformer_1 = require("class-transformer");
+var query_1 = require("./query");
+var query_part_1 = require("./query-part");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+var deepEqual = require("deep-equal");
+var primitives = [Number, Boolean, String];
+var orderFuncs = [query_part_1.QueryFunc.orderBy, query_part_1.QueryFunc.orderByDescending, query_part_1.QueryFunc.thenBy, query_part_1.QueryFunc.thenByDescending];
+var descFuncs = [query_part_1.QueryFunc.orderByDescending, query_part_1.QueryFunc.thenByDescending];
+var executors = [
+    query_part_1.QueryFunc.aggregate,
+    query_part_1.QueryFunc.all,
+    query_part_1.QueryFunc.any,
+    query_part_1.QueryFunc.average,
+    query_part_1.QueryFunc.contains,
+    query_part_1.QueryFunc.elementAt,
+    query_part_1.QueryFunc.elementAtOrDefault,
+    query_part_1.QueryFunc.first,
+    query_part_1.QueryFunc.firstOrDefault,
+    query_part_1.QueryFunc.last,
+    query_part_1.QueryFunc.lastOrDefault,
+    query_part_1.QueryFunc.max,
+    query_part_1.QueryFunc.min,
+    query_part_1.QueryFunc.sequenceEqual,
+    query_part_1.QueryFunc.single,
+    query_part_1.QueryFunc.singleOrDefault,
+    query_part_1.QueryFunc.sum,
+    query_part_1.QueryFunc.toArray,
+];
+var countModifiers = [
+    query_part_1.QueryFunc.concat,
+    query_part_1.QueryFunc.distinct,
+    query_part_1.QueryFunc.except,
+    query_part_1.QueryFunc.groupBy,
+    query_part_1.QueryFunc.groupJoin,
+    query_part_1.QueryFunc.intersect,
+    query_part_1.QueryFunc.join,
+    query_part_1.QueryFunc.ofGuardedType,
+    query_part_1.QueryFunc.ofType,
+    query_part_1.QueryFunc.skipWhile,
+    query_part_1.QueryFunc.takeWhile,
+    query_part_1.QueryFunc.union,
+    query_part_1.QueryFunc.where,
+    query_part_1.QueryFunc.zip,
+];
+var ArrayQueryProvider = /** @class */ (function () {
+    function ArrayQueryProvider(items) {
+        this.items = items;
+        if (!items)
+            throw new TypeError("Cannot query null array.");
+    }
+    ArrayQueryProvider.prototype.createQuery = function (parts, ctor) {
+        var query = new query_1.Query(this, parts);
+        return ctor ? query.cast(ctor) : query;
+    };
+    ArrayQueryProvider.prototype.execute = function (parts) {
+        var e_1, _a, _b;
+        if (!parts || !parts.length)
+            return this.items;
+        var ctor = null;
+        var value = this.items instanceof Array ? this.items[Symbol.iterator]() : this.items;
+        var inlineCountEnabled;
+        var orderParts = [];
+        var inlineCount = null;
+        try {
+            for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
+                var p = parts_1_1.value;
+                if (p.type === query_part_1.QueryFunc.inlineCount) {
+                    inlineCountEnabled = true;
+                    continue;
+                }
+                else if (orderFuncs.indexOf(p.type) !== -1) {
+                    // accumulate consecutive sorting
+                    orderParts.push(p);
+                    continue;
+                }
+                else if (p.type === query_part_1.QueryFunc.skip || p.type === query_part_1.QueryFunc.take || executors.indexOf(p.type) !== -1) {
+                    if (inlineCountEnabled && inlineCount == null) {
+                        _b = __read(getCount(value), 2), inlineCount = _b[0], value = _b[1];
+                    }
+                }
+                else if (p.type === query_part_1.QueryFunc.cast) {
+                    ctor = p.args[0].literal;
+                }
+                else if (countModifiers.indexOf(p.type) !== -1) {
+                    inlineCount = null;
+                }
+                // if it is not an order, apply previous sorting
+                if (orderParts.length) {
+                    value = this.multiOrderBy(value, orderParts);
+                }
+                // clear sorting
+                orderParts = [];
+                value = this.handlePart(value, p);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        // handle remaining sorting. necessary when last query part is an order
+        if (orderParts.length) {
+            value = this.multiOrderBy(value, orderParts);
+        }
+        value = (ctor ? (0, class_transformer_1.plainToClass)(ctor, value) : value);
+        if (inlineCountEnabled) {
+            value = { value: value, inlineCount: inlineCount };
+        }
+        return value;
+    };
+    ArrayQueryProvider.prototype.executeAsync = function (parts) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            try {
+                resolve(_this.execute(parts));
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    };
+    ArrayQueryProvider.prototype.handlePart = function (items, part) {
+        var f = funcs[part.type];
+        if (!f)
+            throw new Error("Unknown query part type ".concat(part.type, "."));
+        return f.call.apply(f, __spreadArray([null, items], __read(part.args), false));
+    };
+    ArrayQueryProvider.prototype.multiOrderBy = function (items, keySelectors) {
+        var arr = Array.from(items).sort(function (i1, i2) {
+            var e_2, _a;
+            try {
+                for (var keySelectors_1 = __values(keySelectors), keySelectors_1_1 = keySelectors_1.next(); !keySelectors_1_1.done; keySelectors_1_1 = keySelectors_1.next()) {
+                    var s = keySelectors_1_1.value;
+                    var desc = descFuncs.indexOf(s.type) !== -1 ? 1 : -1;
+                    var sel = s.args[0];
+                    var v1 = sel.func(i1);
+                    var v2 = sel.func(i2);
+                    if (v1 < v2)
+                        return desc;
+                    if (v1 > v2)
+                        return -1 * desc;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (keySelectors_1_1 && !keySelectors_1_1.done && (_a = keySelectors_1.return)) _a.call(keySelectors_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        });
+        return arr[Symbol.iterator]();
+    };
+    return ArrayQueryProvider;
+}());
+exports.ArrayQueryProvider = ArrayQueryProvider;
+var funcs = {
+    aggregate: function (items, func, seed) {
+        var e_3, _a;
+        var s = seed.literal || 0;
+        try {
+            for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
+                var i = items_1_1.value;
+                s = func.func(s, i);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return s;
+    },
+    all: function (items, predicate) {
+        var e_4, _a;
+        try {
+            for (var items_2 = __values(items), items_2_1 = items_2.next(); !items_2_1.done; items_2_1 = items_2.next()) {
+                var i = items_2_1.value;
+                if (!predicate.func(i))
+                    return false;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (items_2_1 && !items_2_1.done && (_a = items_2.return)) _a.call(items_2);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return true;
+    },
+    any: function (items, predicate) {
+        var e_5, _a;
+        try {
+            for (var items_3 = __values(items), items_3_1 = items_3.next(); !items_3_1.done; items_3_1 = items_3.next()) {
+                var i = items_3_1.value;
+                if (!predicate.func || predicate.func(i))
+                    return true;
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (items_3_1 && !items_3_1.done && (_a = items_3.return)) _a.call(items_3);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return false;
+    },
+    average: function (items, selector) {
+        var e_6, _a;
+        var sum = 0;
+        var c = 0;
+        try {
+            for (var items_4 = __values(items), items_4_1 = items_4.next(); !items_4_1.done; items_4_1 = items_4.next()) {
+                var i = items_4_1.value;
+                var curr = selector.func ? selector.func(i) : i;
+                sum += curr;
+                c++;
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (items_4_1 && !items_4_1.done && (_a = items_4.return)) _a.call(items_4);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        return c === 0 ? 0 : sum / c;
+    },
+    cast: function (items, ctor) {
+        var items_5, items_5_1, i, v, e_7_1;
+        var e_7, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 9, 10, 11]);
+                    items_5 = __values(items), items_5_1 = items_5.next();
+                    _b.label = 1;
+                case 1:
+                    if (!!items_5_1.done) return [3 /*break*/, 8];
+                    i = items_5_1.value;
+                    if (!(i == null)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, i];
+                case 2:
+                    _b.sent();
+                    return [3 /*break*/, 7];
+                case 3:
+                    if (!(i !== Object(i))) return [3 /*break*/, 5];
+                    v = ctor.literal(i);
+                    if (v == null || (ctor.literal === Number && isNaN(v)))
+                        throw new Error("Unable to cast ".concat(i));
+                    return [4 /*yield*/, v];
+                case 4:
+                    _b.sent();
+                    return [3 /*break*/, 7];
+                case 5:
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+                    if (i.constructor !== Object && !(i instanceof ctor.literal))
+                        throw new Error("Unable to cast ".concat(i));
+                    return [4 /*yield*/, i];
+                case 6:
+                    _b.sent();
+                    _b.label = 7;
+                case 7:
+                    items_5_1 = items_5.next();
+                    return [3 /*break*/, 1];
+                case 8: return [3 /*break*/, 11];
+                case 9:
+                    e_7_1 = _b.sent();
+                    e_7 = { error: e_7_1 };
+                    return [3 /*break*/, 11];
+                case 10:
+                    try {
+                        if (items_5_1 && !items_5_1.done && (_a = items_5.return)) _a.call(items_5);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                    return [7 /*endfinally*/];
+                case 11: return [2 /*return*/];
+            }
+        });
+    },
+    concat: function (items, other) {
+        var os, items_6, items_6_1, i, e_8_1, os_1, os_1_1, o, e_9_1;
+        var e_8, _a, e_9, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    os = getArray(other);
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 6, 7, 8]);
+                    items_6 = __values(items), items_6_1 = items_6.next();
+                    _c.label = 2;
+                case 2:
+                    if (!!items_6_1.done) return [3 /*break*/, 5];
+                    i = items_6_1.value;
+                    return [4 /*yield*/, i];
+                case 3:
+                    _c.sent();
+                    _c.label = 4;
+                case 4:
+                    items_6_1 = items_6.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_8_1 = _c.sent();
+                    e_8 = { error: e_8_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_6_1 && !items_6_1.done && (_a = items_6.return)) _a.call(items_6);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                    return [7 /*endfinally*/];
+                case 8:
+                    _c.trys.push([8, 13, 14, 15]);
+                    os_1 = __values(os), os_1_1 = os_1.next();
+                    _c.label = 9;
+                case 9:
+                    if (!!os_1_1.done) return [3 /*break*/, 12];
+                    o = os_1_1.value;
+                    return [4 /*yield*/, o];
+                case 10:
+                    _c.sent();
+                    _c.label = 11;
+                case 11:
+                    os_1_1 = os_1.next();
+                    return [3 /*break*/, 9];
+                case 12: return [3 /*break*/, 15];
+                case 13:
+                    e_9_1 = _c.sent();
+                    e_9 = { error: e_9_1 };
+                    return [3 /*break*/, 15];
+                case 14:
+                    try {
+                        if (os_1_1 && !os_1_1.done && (_b = os_1.return)) _b.call(os_1);
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                    return [7 /*endfinally*/];
+                case 15: return [2 /*return*/];
+            }
+        });
+    },
+    contains: function (items, item, comparer) {
+        var e_10, _a;
+        try {
+            for (var items_7 = __values(items), items_7_1 = items_7.next(); !items_7_1.done; items_7_1 = items_7.next()) {
+                var i = items_7_1.value;
+                if (comparer.func ? comparer.func(i, item.literal) : i === item.literal)
+                    return true;
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (items_7_1 && !items_7_1.done && (_a = items_7.return)) _a.call(items_7);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        return false;
+    },
+    count: function (items, predicate) {
+        var e_11, _a;
+        var c = 0;
+        try {
+            for (var items_8 = __values(items), items_8_1 = items_8.next(); !items_8_1.done; items_8_1 = items_8.next()) {
+                var i = items_8_1.value;
+                if (!predicate.func || predicate.func(i)) {
+                    c++;
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (items_8_1 && !items_8_1.done && (_a = items_8.return)) _a.call(items_8);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        return c;
+    },
+    defaultIfEmpty: function (items, defaultValue) {
+        var arr = Array.from(items);
+        if (arr.length)
+            return arr[Symbol.iterator]();
+        return defaultValue.literal != null ? [defaultValue.literal] : [];
+    },
+    distinct: function (items, comparer) {
+        var dist, c, _loop_1, items_9, items_9_1, i, e_12_1;
+        var e_12, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dist = [];
+                    c = (comparer.func || (function (a, b) { return a === b; }));
+                    _loop_1 = function (i) {
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    if (dist.find(function (d) { return c(i, d); }))
+                                        return [2 /*return*/, "continue"];
+                                    dist.push(i);
+                                    return [4 /*yield*/, i];
+                                case 1:
+                                    _c.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    items_9 = __values(items), items_9_1 = items_9.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_9_1.done) return [3 /*break*/, 5];
+                    i = items_9_1.value;
+                    return [5 /*yield**/, _loop_1(i)];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    items_9_1 = items_9.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_12_1 = _b.sent();
+                    e_12 = { error: e_12_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_9_1 && !items_9_1.done && (_a = items_9.return)) _a.call(items_9);
+                    }
+                    finally { if (e_12) throw e_12.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    },
+    elementAt: function (items, index) {
+        var e_13, _a;
+        var idx = 0;
+        try {
+            for (var items_10 = __values(items), items_10_1 = items_10.next(); !items_10_1.done; items_10_1 = items_10.next()) {
+                var i = items_10_1.value;
+                if (idx++ === index.literal)
+                    return i;
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (items_10_1 && !items_10_1.done && (_a = items_10.return)) _a.call(items_10);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+        throw new Error("Index was outside the bounds of the array.");
+    },
+    elementAtOrDefault: function (items, index) {
+        var e_14, _a;
+        var idx = 0;
+        try {
+            for (var items_11 = __values(items), items_11_1 = items_11.next(); !items_11_1.done; items_11_1 = items_11.next()) {
+                var i = items_11_1.value;
+                if (idx++ === index.literal)
+                    return i;
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (items_11_1 && !items_11_1.done && (_a = items_11.return)) _a.call(items_11);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        return null;
+    },
+    except: function (items, other, comparer) {
+        var dist, c, _loop_2, items_12, items_12_1, i, e_15_1;
+        var e_15, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dist = [];
+                    c = (comparer.func || (function (a, b) { return a === b; }));
+                    _loop_2 = function (i) {
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    if (dist.find(function (d) { return c(i, d); }) || other.literal["find"](function (d) { return c(i, d); }))
+                                        return [2 /*return*/, "continue"];
+                                    dist.push(i);
+                                    return [4 /*yield*/, i];
+                                case 1:
+                                    _c.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    items_12 = __values(items), items_12_1 = items_12.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_12_1.done) return [3 /*break*/, 5];
+                    i = items_12_1.value;
+                    return [5 /*yield**/, _loop_2(i)];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    items_12_1 = items_12.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_15_1 = _b.sent();
+                    e_15 = { error: e_15_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_12_1 && !items_12_1.done && (_a = items_12.return)) _a.call(items_12);
+                    }
+                    finally { if (e_15) throw e_15.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    },
+    first: function (items, predicate) {
+        var _a = __read(getFirst(items, predicate), 2), found = _a[0], item = _a[1];
+        if (!found)
+            throw new Error("Sequence contains no matching element");
+        return item;
+    },
+    firstOrDefault: function (items, predicate) {
+        return getFirst(items, predicate)[1];
+    },
+    groupBy: function (items, keySelector, elementSelector) {
+        var groups, _loop_3, items_13, items_13_1, i, groups_1, groups_1_1, g, e_16_1;
+        var e_17, _a, e_16, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    groups = [];
+                    _loop_3 = function (i) {
+                        var key = keySelector.func(i);
+                        var a = groups.find(function (g) { return deepEqual(g.key, key); });
+                        if (!a) {
+                            var group = [i];
+                            groups.push({ key: key, group: group });
+                        }
+                        else {
+                            a.group.push(i);
+                        }
+                    };
+                    try {
+                        for (items_13 = __values(items), items_13_1 = items_13.next(); !items_13_1.done; items_13_1 = items_13.next()) {
+                            i = items_13_1.value;
+                            _loop_3(i);
+                        }
+                    }
+                    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                    finally {
+                        try {
+                            if (items_13_1 && !items_13_1.done && (_a = items_13.return)) _a.call(items_13);
+                        }
+                        finally { if (e_17) throw e_17.error; }
+                    }
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 8, 9, 10]);
+                    groups_1 = __values(groups), groups_1_1 = groups_1.next();
+                    _c.label = 2;
+                case 2:
+                    if (!!groups_1_1.done) return [3 /*break*/, 7];
+                    g = groups_1_1.value;
+                    if (!elementSelector.func) return [3 /*break*/, 4];
+                    return [4 /*yield*/, elementSelector.func(g.key, g.group)];
+                case 3:
+                    _c.sent();
+                    return [3 /*break*/, 6];
+                case 4:
+                    g.group["key"] = g.key;
+                    return [4 /*yield*/, g.group];
+                case 5:
+                    _c.sent();
+                    _c.label = 6;
+                case 6:
+                    groups_1_1 = groups_1.next();
+                    return [3 /*break*/, 2];
+                case 7: return [3 /*break*/, 10];
+                case 8:
+                    e_16_1 = _c.sent();
+                    e_16 = { error: e_16_1 };
+                    return [3 /*break*/, 10];
+                case 9:
+                    try {
+                        if (groups_1_1 && !groups_1_1.done && (_b = groups_1.return)) _b.call(groups_1);
+                    }
+                    finally { if (e_16) throw e_16.error; }
+                    return [7 /*endfinally*/];
+                case 10: return [2 /*return*/];
+            }
+        });
+    },
+    groupJoin: function (items, other, thisKey, otherKey, selector) {
+        var os, _loop_4, items_14, items_14_1, i, e_18_1;
+        var e_18, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    os = getArray(other);
+                    _loop_4 = function (i) {
+                        var k;
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    k = thisKey.func(i);
+                                    return [4 /*yield*/, selector.func(i, os.filter(function (o) { return deepEqual(otherKey.func(o), k); }))];
+                                case 1:
+                                    _c.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    items_14 = __values(items), items_14_1 = items_14.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_14_1.done) return [3 /*break*/, 5];
+                    i = items_14_1.value;
+                    return [5 /*yield**/, _loop_4(i)];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    items_14_1 = items_14.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_18_1 = _b.sent();
+                    e_18 = { error: e_18_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_14_1 && !items_14_1.done && (_a = items_14.return)) _a.call(items_14);
+                    }
+                    finally { if (e_18) throw e_18.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    },
+    intersect: function (items, other, comparer) {
+        var dist, c, _loop_5, items_15, items_15_1, i, e_19_1;
+        var e_19, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dist = [];
+                    c = (comparer.func || (function (a, b) { return a === b; }));
+                    _loop_5 = function (i) {
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    if (dist.find(function (d) { return c(i, d); }) || !other.literal["find"](function (d) { return c(i, d); }))
+                                        return [2 /*return*/, "continue"];
+                                    dist.push(i);
+                                    return [4 /*yield*/, i];
+                                case 1:
+                                    _c.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    items_15 = __values(items), items_15_1 = items_15.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_15_1.done) return [3 /*break*/, 5];
+                    i = items_15_1.value;
+                    return [5 /*yield**/, _loop_5(i)];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    items_15_1 = items_15.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_19_1 = _b.sent();
+                    e_19 = { error: e_19_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_15_1 && !items_15_1.done && (_a = items_15.return)) _a.call(items_15);
+                    }
+                    finally { if (e_19) throw e_19.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    },
+    join: function (items, other, thisKey, otherKey, selector) {
+        var os, items_16, items_16_1, i, k, os_2, os_2_1, o, e_20_1, e_21_1;
+        var e_21, _a, e_20, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    os = getArray(other);
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 12, 13, 14]);
+                    items_16 = __values(items), items_16_1 = items_16.next();
+                    _c.label = 2;
+                case 2:
+                    if (!!items_16_1.done) return [3 /*break*/, 11];
+                    i = items_16_1.value;
+                    k = thisKey.func(i);
+                    _c.label = 3;
+                case 3:
+                    _c.trys.push([3, 8, 9, 10]);
+                    os_2 = (e_20 = void 0, __values(os)), os_2_1 = os_2.next();
+                    _c.label = 4;
+                case 4:
+                    if (!!os_2_1.done) return [3 /*break*/, 7];
+                    o = os_2_1.value;
+                    if (!deepEqual(otherKey.func(o), k)) return [3 /*break*/, 6];
+                    return [4 /*yield*/, selector.func(i, o)];
+                case 5:
+                    _c.sent();
+                    _c.label = 6;
+                case 6:
+                    os_2_1 = os_2.next();
+                    return [3 /*break*/, 4];
+                case 7: return [3 /*break*/, 10];
+                case 8:
+                    e_20_1 = _c.sent();
+                    e_20 = { error: e_20_1 };
+                    return [3 /*break*/, 10];
+                case 9:
+                    try {
+                        if (os_2_1 && !os_2_1.done && (_b = os_2.return)) _b.call(os_2);
+                    }
+                    finally { if (e_20) throw e_20.error; }
+                    return [7 /*endfinally*/];
+                case 10:
+                    items_16_1 = items_16.next();
+                    return [3 /*break*/, 2];
+                case 11: return [3 /*break*/, 14];
+                case 12:
+                    e_21_1 = _c.sent();
+                    e_21 = { error: e_21_1 };
+                    return [3 /*break*/, 14];
+                case 13:
+                    try {
+                        if (items_16_1 && !items_16_1.done && (_a = items_16.return)) _a.call(items_16);
+                    }
+                    finally { if (e_21) throw e_21.error; }
+                    return [7 /*endfinally*/];
+                case 14: return [2 /*return*/];
+            }
+        });
+    },
+    last: function (items, predicate) {
+        var _a = __read(getLast(items, predicate), 2), found = _a[0], item = _a[1];
+        if (!found)
+            throw new Error("Sequence contains no matching element");
+        return item;
+    },
+    lastOrDefault: function (items, predicate) {
+        return getLast(items, predicate)[1];
+    },
+    max: function (items, selector) {
+        var e_22, _a;
+        var max;
+        try {
+            for (var items_17 = __values(items), items_17_1 = items_17.next(); !items_17_1.done; items_17_1 = items_17.next()) {
+                var i = items_17_1.value;
+                var curr = selector.func ? selector.func(i) : i;
+                if (max == null || curr > max) {
+                    max = curr;
+                }
+            }
+        }
+        catch (e_22_1) { e_22 = { error: e_22_1 }; }
+        finally {
+            try {
+                if (items_17_1 && !items_17_1.done && (_a = items_17.return)) _a.call(items_17);
+            }
+            finally { if (e_22) throw e_22.error; }
+        }
+        return max;
+    },
+    min: function (items, selector) {
+        var e_23, _a;
+        var min;
+        try {
+            for (var items_18 = __values(items), items_18_1 = items_18.next(); !items_18_1.done; items_18_1 = items_18.next()) {
+                var i = items_18_1.value;
+                var curr = selector.func ? selector.func(i) : i;
+                if (min == null || curr < min) {
+                    min = curr;
+                }
+            }
+        }
+        catch (e_23_1) { e_23 = { error: e_23_1 }; }
+        finally {
+            try {
+                if (items_18_1 && !items_18_1.done && (_a = items_18.return)) _a.call(items_18);
+            }
+            finally { if (e_23) throw e_23.error; }
+        }
+        return min;
+    },
+    ofGuardedType: function (items, typeGuard) {
+        var predicate, items_19, items_19_1, i, e_24_1;
+        var e_24, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    predicate = typeGuard.literal;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    items_19 = __values(items), items_19_1 = items_19.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_19_1.done) return [3 /*break*/, 5];
+                    i = items_19_1.value;
+                    if (!predicate(i)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, i];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    items_19_1 = items_19.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_24_1 = _b.sent();
+                    e_24 = { error: e_24_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_19_1 && !items_19_1.done && (_a = items_19.return)) _a.call(items_19);
+                    }
+                    finally { if (e_24) throw e_24.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    },
+    ofType: function (items, ctor) {
+        var type, isPrimitive, items_20, items_20_1, i, e_25_1;
+        var e_25, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    type = ctor.literal;
+                    isPrimitive = primitives.indexOf(type) !== -1;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 9, 10, 11]);
+                    items_20 = __values(items), items_20_1 = items_20.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_20_1.done) return [3 /*break*/, 8];
+                    i = items_20_1.value;
+                    if (!(isPrimitive && i !== Object(i))) return [3 /*break*/, 5];
+                    if (!(type(i) === i)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, i];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    if (!(i instanceof type)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, i];
+                case 6:
+                    _b.sent();
+                    _b.label = 7;
+                case 7:
+                    items_20_1 = items_20.next();
+                    return [3 /*break*/, 2];
+                case 8: return [3 /*break*/, 11];
+                case 9:
+                    e_25_1 = _b.sent();
+                    e_25 = { error: e_25_1 };
+                    return [3 /*break*/, 11];
+                case 10:
+                    try {
+                        if (items_20_1 && !items_20_1.done && (_a = items_20.return)) _a.call(items_20);
+                    }
+                    finally { if (e_25) throw e_25.error; }
+                    return [7 /*endfinally*/];
+                case 11: return [2 /*return*/];
+            }
+        });
+    },
+    // eslint-disable-next-line require-yield
+    reverse: function (items) {
+        var arr, items_21, items_21_1, i;
+        var e_26, _a;
+        return __generator(this, function (_b) {
+            arr = [];
+            try {
+                for (items_21 = __values(items), items_21_1 = items_21.next(); !items_21_1.done; items_21_1 = items_21.next()) {
+                    i = items_21_1.value;
+                    arr.splice(0, 0, i);
+                }
+            }
+            catch (e_26_1) { e_26 = { error: e_26_1 }; }
+            finally {
+                try {
+                    if (items_21_1 && !items_21_1.done && (_a = items_21.return)) _a.call(items_21);
+                }
+                finally { if (e_26) throw e_26.error; }
+            }
+            return [2 /*return*/, arr];
+        });
+    },
+    select: function (items, selector) {
+        var items_22, items_22_1, i, e_27_1;
+        var e_27, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 5, 6, 7]);
+                    items_22 = __values(items), items_22_1 = items_22.next();
+                    _b.label = 1;
+                case 1:
+                    if (!!items_22_1.done) return [3 /*break*/, 4];
+                    i = items_22_1.value;
+                    return [4 /*yield*/, selector.func(i)];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3:
+                    items_22_1 = items_22.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_27_1 = _b.sent();
+                    e_27 = { error: e_27_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (items_22_1 && !items_22_1.done && (_a = items_22.return)) _a.call(items_22);
+                    }
+                    finally { if (e_27) throw e_27.error; }
+                    return [7 /*endfinally*/];
+                case 7: return [2 /*return*/];
+            }
+        });
+    },
+    selectMany: function (items, selector) {
+        var items_23, items_23_1, i, _a, _b, ii, e_28_1, e_29_1;
+        var e_29, _c, e_28, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    _e.trys.push([0, 11, 12, 13]);
+                    items_23 = __values(items), items_23_1 = items_23.next();
+                    _e.label = 1;
+                case 1:
+                    if (!!items_23_1.done) return [3 /*break*/, 10];
+                    i = items_23_1.value;
+                    _e.label = 2;
+                case 2:
+                    _e.trys.push([2, 7, 8, 9]);
+                    _a = (e_28 = void 0, __values(selector.func(i))), _b = _a.next();
+                    _e.label = 3;
+                case 3:
+                    if (!!_b.done) return [3 /*break*/, 6];
+                    ii = _b.value;
+                    return [4 /*yield*/, ii];
+                case 4:
+                    _e.sent();
+                    _e.label = 5;
+                case 5:
+                    _b = _a.next();
+                    return [3 /*break*/, 3];
+                case 6: return [3 /*break*/, 9];
+                case 7:
+                    e_28_1 = _e.sent();
+                    e_28 = { error: e_28_1 };
+                    return [3 /*break*/, 9];
+                case 8:
+                    try {
+                        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                    }
+                    finally { if (e_28) throw e_28.error; }
+                    return [7 /*endfinally*/];
+                case 9:
+                    items_23_1 = items_23.next();
+                    return [3 /*break*/, 1];
+                case 10: return [3 /*break*/, 13];
+                case 11:
+                    e_29_1 = _e.sent();
+                    e_29 = { error: e_29_1 };
+                    return [3 /*break*/, 13];
+                case 12:
+                    try {
+                        if (items_23_1 && !items_23_1.done && (_c = items_23.return)) _c.call(items_23);
+                    }
+                    finally { if (e_29) throw e_29.error; }
+                    return [7 /*endfinally*/];
+                case 13: return [2 /*return*/];
+            }
+        });
+    },
+    sequenceEqual: function (items, other, comparer) {
+        var e_30, _a;
+        var os = getArray(other);
+        var idx = 0;
+        var c = (comparer.func || (function (a, b) { return a === b; }));
+        try {
+            for (var items_24 = __values(items), items_24_1 = items_24.next(); !items_24_1.done; items_24_1 = items_24.next()) {
+                var i = items_24_1.value;
+                if (idx >= os.length || !c(i, os[idx++]))
+                    return false;
+            }
+        }
+        catch (e_30_1) { e_30 = { error: e_30_1 }; }
+        finally {
+            try {
+                if (items_24_1 && !items_24_1.done && (_a = items_24.return)) _a.call(items_24);
+            }
+            finally { if (e_30) throw e_30.error; }
+        }
+        return idx === os.length;
+    },
+    single: function (items, predicate) {
+        var _a = __read(getSingle(items, predicate), 2), found = _a[0], item = _a[1];
+        if (!found)
+            throw new Error("Sequence contains no matching element");
+        return item;
+    },
+    singleOrDefault: function (items, predicate) {
+        return getSingle(items, predicate)[1];
+    },
+    skip: function (items, count) {
+        var i, items_25, items_25_1, item, e_31_1;
+        var e_31, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    i = 0;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    items_25 = __values(items), items_25_1 = items_25.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_25_1.done) return [3 /*break*/, 5];
+                    item = items_25_1.value;
+                    if (!(++i > count.literal)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, item];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    items_25_1 = items_25.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_31_1 = _b.sent();
+                    e_31 = { error: e_31_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_25_1 && !items_25_1.done && (_a = items_25.return)) _a.call(items_25);
+                    }
+                    finally { if (e_31) throw e_31.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    },
+    skipWhile: function (items, predicate) {
+        var yielding, items_26, items_26_1, i, e_32_1;
+        var e_32, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    yielding = false;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    items_26 = __values(items), items_26_1 = items_26.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_26_1.done) return [3 /*break*/, 5];
+                    i = items_26_1.value;
+                    if (!yielding && !predicate.func(i)) {
+                        yielding = true;
+                    }
+                    if (!yielding) return [3 /*break*/, 4];
+                    return [4 /*yield*/, i];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    items_26_1 = items_26.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_32_1 = _b.sent();
+                    e_32 = { error: e_32_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_26_1 && !items_26_1.done && (_a = items_26.return)) _a.call(items_26);
+                    }
+                    finally { if (e_32) throw e_32.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    },
+    sum: function (items, selector) {
+        var e_33, _a;
+        var sum = 0;
+        try {
+            for (var items_27 = __values(items), items_27_1 = items_27.next(); !items_27_1.done; items_27_1 = items_27.next()) {
+                var i = items_27_1.value;
+                var curr = selector.func ? selector.func(i) : i;
+                sum += curr;
+            }
+        }
+        catch (e_33_1) { e_33 = { error: e_33_1 }; }
+        finally {
+            try {
+                if (items_27_1 && !items_27_1.done && (_a = items_27.return)) _a.call(items_27);
+            }
+            finally { if (e_33) throw e_33.error; }
+        }
+        return sum;
+    },
+    take: function (items, count) {
+        var i, items_28, items_28_1, item, e_34_1;
+        var e_34, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    i = 0;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 7, 8, 9]);
+                    items_28 = __values(items), items_28_1 = items_28.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_28_1.done) return [3 /*break*/, 6];
+                    item = items_28_1.value;
+                    if (!(++i <= count.literal)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, item];
+                case 3:
+                    _b.sent();
+                    return [3 /*break*/, 5];
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    items_28_1 = items_28.next();
+                    return [3 /*break*/, 2];
+                case 6: return [3 /*break*/, 9];
+                case 7:
+                    e_34_1 = _b.sent();
+                    e_34 = { error: e_34_1 };
+                    return [3 /*break*/, 9];
+                case 8:
+                    try {
+                        if (items_28_1 && !items_28_1.done && (_a = items_28.return)) _a.call(items_28);
+                    }
+                    finally { if (e_34) throw e_34.error; }
+                    return [7 /*endfinally*/];
+                case 9: return [2 /*return*/];
+            }
+        });
+    },
+    takeWhile: function (items, predicate) {
+        var items_29, items_29_1, i, e_35_1;
+        var e_35, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 6, 7, 8]);
+                    items_29 = __values(items), items_29_1 = items_29.next();
+                    _b.label = 1;
+                case 1:
+                    if (!!items_29_1.done) return [3 /*break*/, 5];
+                    i = items_29_1.value;
+                    if (!predicate.func(i)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, i];
+                case 2:
+                    _b.sent();
+                    return [3 /*break*/, 4];
+                case 3: return [3 /*break*/, 5];
+                case 4:
+                    items_29_1 = items_29.next();
+                    return [3 /*break*/, 1];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_35_1 = _b.sent();
+                    e_35 = { error: e_35_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_29_1 && !items_29_1.done && (_a = items_29.return)) _a.call(items_29);
+                    }
+                    finally { if (e_35) throw e_35.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    },
+    union: function (items, other, comparer) {
+        var dist, c, _loop_6, items_30, items_30_1, i, e_36_1, os, _loop_7, os_3, os_3_1, o, e_37_1;
+        var e_36, _a, e_37, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dist = [];
+                    c = (comparer.func || (function (a, b) { return a === b; }));
+                    _loop_6 = function (i) {
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0:
+                                    if (!!dist.find(function (d) { return c(i, d); })) return [3 /*break*/, 2];
+                                    dist.push(i);
+                                    return [4 /*yield*/, i];
+                                case 1:
+                                    _d.sent();
+                                    _d.label = 2;
+                                case 2: return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 6, 7, 8]);
+                    items_30 = __values(items), items_30_1 = items_30.next();
+                    _c.label = 2;
+                case 2:
+                    if (!!items_30_1.done) return [3 /*break*/, 5];
+                    i = items_30_1.value;
+                    return [5 /*yield**/, _loop_6(i)];
+                case 3:
+                    _c.sent();
+                    _c.label = 4;
+                case 4:
+                    items_30_1 = items_30.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_36_1 = _c.sent();
+                    e_36 = { error: e_36_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_30_1 && !items_30_1.done && (_a = items_30.return)) _a.call(items_30);
+                    }
+                    finally { if (e_36) throw e_36.error; }
+                    return [7 /*endfinally*/];
+                case 8:
+                    os = getArray(other);
+                    _loop_7 = function (o) {
+                        return __generator(this, function (_e) {
+                            switch (_e.label) {
+                                case 0:
+                                    if (!!dist.find(function (d) { return c(o, d); })) return [3 /*break*/, 2];
+                                    dist.push(o);
+                                    return [4 /*yield*/, o];
+                                case 1:
+                                    _e.sent();
+                                    _e.label = 2;
+                                case 2: return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _c.label = 9;
+                case 9:
+                    _c.trys.push([9, 14, 15, 16]);
+                    os_3 = __values(os), os_3_1 = os_3.next();
+                    _c.label = 10;
+                case 10:
+                    if (!!os_3_1.done) return [3 /*break*/, 13];
+                    o = os_3_1.value;
+                    return [5 /*yield**/, _loop_7(o)];
+                case 11:
+                    _c.sent();
+                    _c.label = 12;
+                case 12:
+                    os_3_1 = os_3.next();
+                    return [3 /*break*/, 10];
+                case 13: return [3 /*break*/, 16];
+                case 14:
+                    e_37_1 = _c.sent();
+                    e_37 = { error: e_37_1 };
+                    return [3 /*break*/, 16];
+                case 15:
+                    try {
+                        if (os_3_1 && !os_3_1.done && (_b = os_3.return)) _b.call(os_3);
+                    }
+                    finally { if (e_37) throw e_37.error; }
+                    return [7 /*endfinally*/];
+                case 16: return [2 /*return*/];
+            }
+        });
+    },
+    where: function (items, predicate) {
+        var items_31, items_31_1, i, e_38_1;
+        var e_38, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 5, 6, 7]);
+                    items_31 = __values(items), items_31_1 = items_31.next();
+                    _b.label = 1;
+                case 1:
+                    if (!!items_31_1.done) return [3 /*break*/, 4];
+                    i = items_31_1.value;
+                    if (!predicate.func(i)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, i];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3:
+                    items_31_1 = items_31.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_38_1 = _b.sent();
+                    e_38 = { error: e_38_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (items_31_1 && !items_31_1.done && (_a = items_31.return)) _a.call(items_31);
+                    }
+                    finally { if (e_38) throw e_38.error; }
+                    return [7 /*endfinally*/];
+                case 7: return [2 /*return*/];
+            }
+        });
+    },
+    zip: function (items, other, selector) {
+        var os, idx, items_32, items_32_1, i, e_39_1;
+        var e_39, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    os = getArray(other);
+                    idx = 0;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 6, 7, 8]);
+                    items_32 = __values(items), items_32_1 = items_32.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!items_32_1.done) return [3 /*break*/, 5];
+                    i = items_32_1.value;
+                    if (idx >= os.length)
+                        return [2 /*return*/];
+                    return [4 /*yield*/, selector.func(i, os[idx++])];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4:
+                    items_32_1 = items_32.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_39_1 = _b.sent();
+                    e_39 = { error: e_39_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (items_32_1 && !items_32_1.done && (_a = items_32.return)) _a.call(items_32);
+                    }
+                    finally { if (e_39) throw e_39.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    },
+    toArray: function (items) {
+        return Array.from(items);
+    },
+};
+function getArray(arg) {
+    return arg.literal;
+}
+function getFirst(items, predicate) {
+    var e_40, _a;
+    try {
+        for (var items_33 = __values(items), items_33_1 = items_33.next(); !items_33_1.done; items_33_1 = items_33.next()) {
+            var i = items_33_1.value;
+            if (!predicate.func || predicate.func(i))
+                return [true, i];
+        }
+    }
+    catch (e_40_1) { e_40 = { error: e_40_1 }; }
+    finally {
+        try {
+            if (items_33_1 && !items_33_1.done && (_a = items_33.return)) _a.call(items_33);
+        }
+        finally { if (e_40) throw e_40.error; }
+    }
+    return [false, null];
+}
+function getLast(items, predicate) {
+    var e_41, _a;
+    var last;
+    try {
+        for (var items_34 = __values(items), items_34_1 = items_34.next(); !items_34_1.done; items_34_1 = items_34.next()) {
+            var i = items_34_1.value;
+            if (!predicate.func || predicate.func(i)) {
+                last = [true, i];
+            }
+        }
+    }
+    catch (e_41_1) { e_41 = { error: e_41_1 }; }
+    finally {
+        try {
+            if (items_34_1 && !items_34_1.done && (_a = items_34.return)) _a.call(items_34);
+        }
+        finally { if (e_41) throw e_41.error; }
+    }
+    return last ? last : [false, null];
+}
+function getSingle(items, predicate) {
+    var e_42, _a;
+    var matches = [];
+    try {
+        for (var items_35 = __values(items), items_35_1 = items_35.next(); !items_35_1.done; items_35_1 = items_35.next()) {
+            var item = items_35_1.value;
+            if (predicate.func && !predicate.func(item))
+                continue;
+            if (matches.length > 0)
+                throw new Error("Sequence contains more than one matching element");
+            matches.push(item);
+        }
+    }
+    catch (e_42_1) { e_42 = { error: e_42_1 }; }
+    finally {
+        try {
+            if (items_35_1 && !items_35_1.done && (_a = items_35.return)) _a.call(items_35);
+        }
+        finally { if (e_42) throw e_42.error; }
+    }
+    return matches.length ? [true, matches[0]] : [false, null];
+}
+function getCount(it) {
+    var arr = Array.from(it);
+    return [arr.length, arr[Symbol.iterator]()];
+}
+//# sourceMappingURL=array-query-provider.js.map