@highstate/designer 0.2.1 → 0.2.2

package/.output/server/node_modules/@pulumi/query/operators.js

@@ -1,1269 +0,0 @@
-"use strict";
-// Copyright 2016-2019, Pulumi Corporation.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__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 = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__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]); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("util");
-const base_1 = require("./base");
-const sources_1 = require("./sources");
-//
-// Restriction operators.
-//
-function filter(f) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_1, _a;
-            try {
-                for (var _b = __asyncValues(zip(source, sources_1.range(0))), _c; _c = yield __await(_b.next()), !_c.done;) {
-                    const [t, i] = _c.value;
-                    if (yield __await(f(t, i))) {
-                        yield yield __await(t);
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        });
-    };
-}
-exports.filter = filter;
-//
-// Projection operators.
-//
-function flatMap(selector, resultSelector = (t, ti) => ti) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_2, _a, e_3, _b;
-            try {
-                for (var _c = __asyncValues(zip(source, sources_1.range(0))), _d; _d = yield __await(_c.next()), !_d.done;) {
-                    const [t, i] = _d.value;
-                    const us = selector(t, i);
-                    try {
-                        for (var _e = __asyncValues(sources_1.from(us)), _f; _f = yield __await(_e.next()), !_f.done;) {
-                            const u = _f.value;
-                            yield yield __await(yield __await(resultSelector(t, u)));
-                        }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
-                        try {
-                            if (_f && !_f.done && (_b = _e.return)) yield __await(_b.call(_e));
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                    }
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c.return)) yield __await(_a.call(_c));
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-        });
-    };
-}
-exports.flatMap = flatMap;
-function map(f) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_4, _a;
-            try {
-                for (var _b = __asyncValues(zip(source, sources_1.range(0))), _c; _c = yield __await(_b.next()), !_c.done;) {
-                    const [t, i] = _c.value;
-                    yield yield __await(yield __await(f(t, i)));
-                }
-            }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-                }
-                finally { if (e_4) throw e_4.error; }
-            }
-        });
-    };
-}
-exports.map = map;
-//
-// Partitioning operators.
-//
-function skip(n) {
-    if (n < 0) {
-        throw Error("skip was provided a negative number of elements to skip");
-    }
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_5, _a;
-            try {
-                for (var _b = __asyncValues(zip(source, sources_1.range(1))), _c; _c = yield __await(_b.next()), !_c.done;) {
-                    const [t, i] = _c.value;
-                    if (i > n) {
-                        yield yield __await(t);
-                    }
-                }
-            }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-                }
-                finally { if (e_5) throw e_5.error; }
-            }
-        });
-    };
-}
-exports.skip = skip;
-function skipWhile(predicate) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_6, _a;
-            let stopSkipping = false;
-            try {
-                for (var _b = __asyncValues(zip(source, sources_1.range(0))), _c; _c = yield __await(_b.next()), !_c.done;) {
-                    const [t, i] = _c.value;
-                    if (stopSkipping === true) {
-                        yield yield __await(t);
-                    }
-                    else if ((yield __await(predicate(t, i))) === false) {
-                        stopSkipping = true;
-                        yield yield __await(t);
-                    }
-                }
-            }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-                }
-                finally { if (e_6) throw e_6.error; }
-            }
-        });
-    };
-}
-exports.skipWhile = skipWhile;
-function take(n) {
-    if (n < 0) {
-        throw Error("take was provided a negative number of elements to take");
-    }
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_7, _a;
-            try {
-                for (var _b = __asyncValues(zip(source, sources_1.range(0))), _c; _c = yield __await(_b.next()), !_c.done;) {
-                    const [t, i] = _c.value;
-                    if (i >= n) {
-                        return yield __await(void 0);
-                    }
-                    yield yield __await(t);
-                }
-            }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-                }
-                finally { if (e_7) throw e_7.error; }
-            }
-        });
-    };
-}
-exports.take = take;
-function takeWhile(predicate) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_8, _a;
-            try {
-                for (var _b = __asyncValues(zip(source, sources_1.range(0))), _c; _c = yield __await(_b.next()), !_c.done;) {
-                    const [t, i] = _c.value;
-                    if ((yield __await(predicate(t, i))) === false) {
-                        return yield __await(void 0);
-                    }
-                    yield yield __await(t);
-                }
-            }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-                }
-                finally { if (e_8) throw e_8.error; }
-            }
-        });
-    };
-}
-exports.takeWhile = takeWhile;
-//
-// Join operators.
-//
-function joinHelper(outer, inner, outerKeySelector, innerKeySelector) {
-    return __asyncGenerator(this, arguments, function* joinHelper_1() {
-        var e_9, _a, e_10, _b;
-        const inners = new Map();
-        try {
-            for (var inner_1 = __asyncValues(inner), inner_1_1; inner_1_1 = yield __await(inner_1.next()), !inner_1_1.done;) {
-                const t = inner_1_1.value;
-                const key = yield __await(innerKeySelector(t));
-                const val = inners.get(key);
-                if (inners.has(key)) {
-                    val.push(t);
-                }
-                else {
-                    inners.set(key, [t]);
-                }
-            }
-        }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
-        finally {
-            try {
-                if (inner_1_1 && !inner_1_1.done && (_a = inner_1.return)) yield __await(_a.call(inner_1));
-            }
-            finally { if (e_9) throw e_9.error; }
-        }
-        try {
-            for (var outer_1 = __asyncValues(outer), outer_1_1; outer_1_1 = yield __await(outer_1.next()), !outer_1_1.done;) {
-                const t = outer_1_1.value;
-                const key = yield __await(outerKeySelector(t));
-                if (key === undefined) {
-                    continue;
-                }
-                else if (inners.has(key)) {
-                    const innerValues = inners.get(key);
-                    yield yield __await([t, innerValues]);
-                }
-            }
-        }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
-        finally {
-            try {
-                if (outer_1_1 && !outer_1_1.done && (_b = outer_1.return)) yield __await(_b.call(outer_1));
-            }
-            finally { if (e_10) throw e_10.error; }
-        }
-    });
-}
-function join(inner, outerKeySelector, innerKeySelector, resultSelector) {
-    return function (outer) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_11, _a;
-            try {
-                for (var _b = __asyncValues(joinHelper(outer, inner, outerKeySelector, innerKeySelector)), _c; _c = yield __await(_b.next()), !_c.done;) {
-                    const [o, inners] = _c.value;
-                    for (const i of inners) {
-                        yield yield __await(yield __await(resultSelector(o, i)));
-                    }
-                }
-            }
-            catch (e_11_1) { e_11 = { error: e_11_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-                }
-                finally { if (e_11) throw e_11.error; }
-            }
-        });
-    };
-}
-exports.join = join;
-function groupJoin(inner, outerKeySelector, innerKeySelector, resultSelector) {
-    return function (outer) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_12, _a;
-            try {
-                for (var _b = __asyncValues(joinHelper(outer, inner, outerKeySelector, innerKeySelector)), _c; _c = yield __await(_b.next()), !_c.done;) {
-                    const [o, inners] = _c.value;
-                    yield yield __await(yield __await(resultSelector(o, sources_1.from(inners))));
-                }
-            }
-            catch (e_12_1) { e_12 = { error: e_12_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
-                }
-                finally { if (e_12) throw e_12.error; }
-            }
-        });
-    };
-}
-exports.groupJoin = groupJoin;
-//
-// Concatenation operators.
-//
-function concat(iter) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_13, _a, e_14, _b;
-            try {
-                for (var source_1 = __asyncValues(source), source_1_1; source_1_1 = yield __await(source_1.next()), !source_1_1.done;) {
-                    const t = source_1_1.value;
-                    yield yield __await(t);
-                }
-            }
-            catch (e_13_1) { e_13 = { error: e_13_1 }; }
-            finally {
-                try {
-                    if (source_1_1 && !source_1_1.done && (_a = source_1.return)) yield __await(_a.call(source_1));
-                }
-                finally { if (e_13) throw e_13.error; }
-            }
-            try {
-                for (var iter_1 = __asyncValues(iter), iter_1_1; iter_1_1 = yield __await(iter_1.next()), !iter_1_1.done;) {
-                    const t = iter_1_1.value;
-                    yield yield __await(t);
-                }
-            }
-            catch (e_14_1) { e_14 = { error: e_14_1 }; }
-            finally {
-                try {
-                    if (iter_1_1 && !iter_1_1.done && (_b = iter_1.return)) yield __await(_b.call(iter_1));
-                }
-                finally { if (e_14) throw e_14.error; }
-            }
-        });
-    };
-}
-exports.concat = concat;
-//
-// Ordering operators.
-//
-function orderBy(keySelector) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            //
-            // NOTE: This horrible little function is necessary because the default behavior of
-            // JavaScript's `Array#sort` is to coerce every element in the array into string, and then
-            // sort those strings lexically.
-            //
-            // This, of course, is completely unacceptable. Approximately 0 users call `.sort` on an
-            // array of `Object` with the intention that they be sorted in this manner. The right thing
-            // to do is to simply assume this is a user error and throw an exception.
-            //
-            // If the user actually wants to sort an array of `Object` by their stringified
-            // representation, let them pass us a key function that performs this conversion explicitly.
-            // There is no particular need for Brendan Eich's problems from 30 years ago to become our
-            // users' problems today.
-            //
-            let lastKey;
-            const ts = yield __await(map(function (t) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const key = yield keySelector(t);
-                    if (lastKey === undefined) {
-                        lastKey = key;
-                    }
-                    else {
-                        if (util_1.isNumber(key) && util_1.isString(key)) {
-                            throw Error("keySelector must produce a number or a string");
-                        }
-                        if (typeof lastKey !== typeof key) {
-                            throw Error(`keySelector must produce keys all of the same type, but found ` +
-                                `${typeof key} and ${typeof lastKey}`);
-                        }
-                    }
-                    return [key, t];
-                });
-            })(source));
-            const keyed = yield __await(toArray()(ts));
-            const comparator = ((util_1.isNumber(lastKey)
-                ? (a, b) => a - b
-                : (a, b) => a.localeCompare(b)));
-            const sorted = keyed.sort(([k1], [k2]) => comparator(k1, k2));
-            for (const [, t] of sorted) {
-                yield yield __await(t);
-            }
-        });
-    };
-}
-exports.orderBy = orderBy;
-function orderByDescending(keySelector) {
-    return function (source) {
-        return reverse()(orderBy(keySelector)(source));
-    };
-}
-exports.orderByDescending = orderByDescending;
-function reverse() {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_15, _a;
-            const ts = [];
-            try {
-                for (var source_2 = __asyncValues(source), source_2_1; source_2_1 = yield __await(source_2.next()), !source_2_1.done;) {
-                    const t = source_2_1.value;
-                    ts.push(t);
-                }
-            }
-            catch (e_15_1) { e_15 = { error: e_15_1 }; }
-            finally {
-                try {
-                    if (source_2_1 && !source_2_1.done && (_a = source_2.return)) yield __await(_a.call(source_2));
-                }
-                finally { if (e_15) throw e_15.error; }
-            }
-            for (const t of ts.reverse()) {
-                yield yield __await(t);
-            }
-        });
-    };
-}
-exports.reverse = reverse;
-//
-// Grouping operators.
-//
-function groupBy(keySelector, elementSelector) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_16, _a;
-            if (elementSelector === undefined) {
-                elementSelector = t => t;
-            }
-            const groups = new Map();
-            try {
-                for (var source_3 = __asyncValues(source), source_3_1; source_3_1 = yield __await(source_3.next()), !source_3_1.done;) {
-                    const t = source_3_1.value;
-                    const key = yield __await(keySelector(t));
-                    const val = yield __await(elementSelector(t));
-                    if (!groups.has(key)) {
-                        groups.set(key, [val]);
-                    }
-                    else {
-                        const group = groups.get(key);
-                        group.push(val);
-                    }
-                }
-            }
-            catch (e_16_1) { e_16 = { error: e_16_1 }; }
-            finally {
-                try {
-                    if (source_3_1 && !source_3_1.done && (_a = source_3.return)) yield __await(_a.call(source_3));
-                }
-                finally { if (e_16) throw e_16.error; }
-            }
-            for (const [key, group] of groups) {
-                yield yield __await(new base_1.GroupedAsyncIterableIteratorImpl(key, sources_1.from(group)));
-            }
-        });
-    };
-}
-exports.groupBy = groupBy;
-//
-// Set operators.
-//
-function distinct() {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_17, _a;
-            const dist = new Set();
-            try {
-                for (var source_4 = __asyncValues(source), source_4_1; source_4_1 = yield __await(source_4.next()), !source_4_1.done;) {
-                    const t = source_4_1.value;
-                    if (!dist.has(t)) {
-                        dist.add(t);
-                        yield yield __await(t);
-                    }
-                }
-            }
-            catch (e_17_1) { e_17 = { error: e_17_1 }; }
-            finally {
-                try {
-                    if (source_4_1 && !source_4_1.done && (_a = source_4.return)) yield __await(_a.call(source_4));
-                }
-                finally { if (e_17) throw e_17.error; }
-            }
-        });
-    };
-}
-exports.distinct = distinct;
-function union(second) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_18, _a, e_19, _b;
-            const dist = new Set();
-            try {
-                for (var source_5 = __asyncValues(source), source_5_1; source_5_1 = yield __await(source_5.next()), !source_5_1.done;) {
-                    const t = source_5_1.value;
-                    if (!dist.has(t)) {
-                        dist.add(t);
-                        yield yield __await(t);
-                    }
-                }
-            }
-            catch (e_18_1) { e_18 = { error: e_18_1 }; }
-            finally {
-                try {
-                    if (source_5_1 && !source_5_1.done && (_a = source_5.return)) yield __await(_a.call(source_5));
-                }
-                finally { if (e_18) throw e_18.error; }
-            }
-            try {
-                for (var second_1 = __asyncValues(second), second_1_1; second_1_1 = yield __await(second_1.next()), !second_1_1.done;) {
-                    const t = second_1_1.value;
-                    if (!dist.has(t)) {
-                        dist.add(t);
-                        yield yield __await(t);
-                    }
-                }
-            }
-            catch (e_19_1) { e_19 = { error: e_19_1 }; }
-            finally {
-                try {
-                    if (second_1_1 && !second_1_1.done && (_b = second_1.return)) yield __await(_b.call(second_1));
-                }
-                finally { if (e_19) throw e_19.error; }
-            }
-        });
-    };
-}
-exports.union = union;
-function intersect(second) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_20, _a, e_21, _b;
-            const dist = new Set();
-            try {
-                for (var source_6 = __asyncValues(source), source_6_1; source_6_1 = yield __await(source_6.next()), !source_6_1.done;) {
-                    const t = source_6_1.value;
-                    dist.add(t);
-                }
-            }
-            catch (e_20_1) { e_20 = { error: e_20_1 }; }
-            finally {
-                try {
-                    if (source_6_1 && !source_6_1.done && (_a = source_6.return)) yield __await(_a.call(source_6));
-                }
-                finally { if (e_20) throw e_20.error; }
-            }
-            const emitted = new Set();
-            try {
-                for (var second_2 = __asyncValues(second), second_2_1; second_2_1 = yield __await(second_2.next()), !second_2_1.done;) {
-                    const t = second_2_1.value;
-                    if (dist.has(t) && !emitted.has(t)) {
-                        emitted.add(t);
-                        yield yield __await(t);
-                    }
-                }
-            }
-            catch (e_21_1) { e_21 = { error: e_21_1 }; }
-            finally {
-                try {
-                    if (second_2_1 && !second_2_1.done && (_b = second_2.return)) yield __await(_b.call(second_2));
-                }
-                finally { if (e_21) throw e_21.error; }
-            }
-        });
-    };
-}
-exports.intersect = intersect;
-function except(second) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_22, _a, e_23, _b;
-            const dist = new Set();
-            try {
-                for (var source_7 = __asyncValues(source), source_7_1; source_7_1 = yield __await(source_7.next()), !source_7_1.done;) {
-                    const t = source_7_1.value;
-                    dist.add(t);
-                }
-            }
-            catch (e_22_1) { e_22 = { error: e_22_1 }; }
-            finally {
-                try {
-                    if (source_7_1 && !source_7_1.done && (_a = source_7.return)) yield __await(_a.call(source_7));
-                }
-                finally { if (e_22) throw e_22.error; }
-            }
-            try {
-                for (var second_3 = __asyncValues(second), second_3_1; second_3_1 = yield __await(second_3.next()), !second_3_1.done;) {
-                    const t = second_3_1.value;
-                    if (dist.has(t)) {
-                        dist.delete(t);
-                    }
-                    else {
-                        dist.add(t);
-                    }
-                }
-            }
-            catch (e_23_1) { e_23 = { error: e_23_1 }; }
-            finally {
-                try {
-                    if (second_3_1 && !second_3_1.done && (_b = second_3.return)) yield __await(_b.call(second_3));
-                }
-                finally { if (e_23) throw e_23.error; }
-            }
-            for (const t of dist) {
-                yield yield __await(t);
-            }
-        });
-    };
-}
-exports.except = except;
-//
-// Conversion operators.
-//
-function toArray() {
-    return function (source) {
-        var source_8, source_8_1;
-        var e_24, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = [];
-            try {
-                for (source_8 = __asyncValues(source); source_8_1 = yield source_8.next(), !source_8_1.done;) {
-                    const t = source_8_1.value;
-                    ret.push(t);
-                }
-            }
-            catch (e_24_1) { e_24 = { error: e_24_1 }; }
-            finally {
-                try {
-                    if (source_8_1 && !source_8_1.done && (_a = source_8.return)) yield _a.call(source_8);
-                }
-                finally { if (e_24) throw e_24.error; }
-            }
-            return ret;
-        });
-    };
-}
-exports.toArray = toArray;
-function toMap(keySelector, elementSelector) {
-    return function (source) {
-        var source_9, source_9_1;
-        var e_25, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (elementSelector === undefined) {
-                elementSelector = x => x;
-            }
-            const ret = new Map();
-            try {
-                for (source_9 = __asyncValues(source); source_9_1 = yield source_9.next(), !source_9_1.done;) {
-                    const t = source_9_1.value;
-                    const key = yield keySelector(t);
-                    if (key === undefined) {
-                        throw Error("key selector can't produce a null value");
-                    }
-                    const val = yield elementSelector(t);
-                    ret.set(key, val);
-                }
-            }
-            catch (e_25_1) { e_25 = { error: e_25_1 }; }
-            finally {
-                try {
-                    if (source_9_1 && !source_9_1.done && (_a = source_9.return)) yield _a.call(source_9);
-                }
-                finally { if (e_25) throw e_25.error; }
-            }
-            return ret;
-        });
-    };
-}
-exports.toMap = toMap;
-function ofType(typeGuard) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_26, _a;
-            try {
-                for (var source_10 = __asyncValues(source), source_10_1; source_10_1 = yield __await(source_10.next()), !source_10_1.done;) {
-                    const t = source_10_1.value;
-                    if (typeGuard(t)) {
-                        yield yield __await(t);
-                    }
-                }
-            }
-            catch (e_26_1) { e_26 = { error: e_26_1 }; }
-            finally {
-                try {
-                    if (source_10_1 && !source_10_1.done && (_a = source_10.return)) yield __await(_a.call(source_10));
-                }
-                finally { if (e_26) throw e_26.error; }
-            }
-        });
-    };
-}
-exports.ofType = ofType;
-//
-// Element operators.
-//
-function first(predicate) {
-    return function (source) {
-        var source_11, source_11_1;
-        var e_27, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (predicate === undefined) {
-                predicate = t => true;
-            }
-            try {
-                for (source_11 = __asyncValues(source); source_11_1 = yield source_11.next(), !source_11_1.done;) {
-                    const t = source_11_1.value;
-                    if ((yield predicate(t)) === true) {
-                        return t;
-                    }
-                }
-            }
-            catch (e_27_1) { e_27 = { error: e_27_1 }; }
-            finally {
-                try {
-                    if (source_11_1 && !source_11_1.done && (_a = source_11.return)) yield _a.call(source_11);
-                }
-                finally { if (e_27) throw e_27.error; }
-            }
-            return Promise.reject("first could not find any elements that match predicate");
-        });
-    };
-}
-exports.first = first;
-function firstOrDefault(defaultValue, predicate) {
-    return function (source) {
-        var source_12, source_12_1;
-        var e_28, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (predicate === undefined) {
-                predicate = t => true;
-            }
-            try {
-                for (source_12 = __asyncValues(source); source_12_1 = yield source_12.next(), !source_12_1.done;) {
-                    const t = source_12_1.value;
-                    if ((yield predicate(t)) === true) {
-                        return t;
-                    }
-                }
-            }
-            catch (e_28_1) { e_28 = { error: e_28_1 }; }
-            finally {
-                try {
-                    if (source_12_1 && !source_12_1.done && (_a = source_12.return)) yield _a.call(source_12);
-                }
-                finally { if (e_28) throw e_28.error; }
-            }
-            return defaultValue;
-        });
-    };
-}
-exports.firstOrDefault = firstOrDefault;
-function last(predicate) {
-    return function (source) {
-        var source_13, source_13_1;
-        var e_29, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (predicate === undefined) {
-                predicate = t => true;
-            }
-            let curr;
-            try {
-                for (source_13 = __asyncValues(source); source_13_1 = yield source_13.next(), !source_13_1.done;) {
-                    const t = source_13_1.value;
-                    if ((yield predicate(t)) === true) {
-                        curr = t;
-                    }
-                }
-            }
-            catch (e_29_1) { e_29 = { error: e_29_1 }; }
-            finally {
-                try {
-                    if (source_13_1 && !source_13_1.done && (_a = source_13.return)) yield _a.call(source_13);
-                }
-                finally { if (e_29) throw e_29.error; }
-            }
-            if (curr === undefined) {
-                return Promise.reject("last could not find any elements that match predicate");
-            }
-            else {
-                return curr;
-            }
-        });
-    };
-}
-exports.last = last;
-function lastOrDefault(defaultValue, predicate) {
-    return function (source) {
-        var source_14, source_14_1;
-        var e_30, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (predicate === undefined) {
-                predicate = t => true;
-            }
-            let curr;
-            try {
-                for (source_14 = __asyncValues(source); source_14_1 = yield source_14.next(), !source_14_1.done;) {
-                    const t = source_14_1.value;
-                    if ((yield predicate(t)) === true) {
-                        curr = t;
-                    }
-                }
-            }
-            catch (e_30_1) { e_30 = { error: e_30_1 }; }
-            finally {
-                try {
-                    if (source_14_1 && !source_14_1.done && (_a = source_14.return)) yield _a.call(source_14);
-                }
-                finally { if (e_30) throw e_30.error; }
-            }
-            if (curr === undefined) {
-                return defaultValue;
-            }
-            else {
-                return curr;
-            }
-        });
-    };
-}
-exports.lastOrDefault = lastOrDefault;
-function single(predicate) {
-    return function (source) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (predicate === undefined) {
-                predicate = t => true;
-            }
-            const seq = yield toArray()(filter(predicate)(source));
-            if (seq.length === 0) {
-                throw Error("single did not find any elements matching the predicate");
-            }
-            else if (seq.length > 1) {
-                throw Error("single found multiple elements matching the predicate");
-            }
-            return seq[0];
-        });
-    };
-}
-exports.single = single;
-function singleOrDefault(defaultValue, predicate) {
-    return function (source) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (predicate === undefined) {
-                predicate = t => true;
-            }
-            const seq = yield toArray()(filter(predicate)(source));
-            if (seq.length === 0) {
-                return defaultValue;
-            }
-            else if (seq.length > 1) {
-                throw Error("single found multiple elements matching the predicate");
-            }
-            else {
-                return seq[0];
-            }
-        });
-    };
-}
-exports.singleOrDefault = singleOrDefault;
-function elementAt(index) {
-    return function (source) {
-        var e_31, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // TODO: Maybe support `Array` here if we ever support sync iterables. This would allow us
-                // to access that index directly.
-                for (var _b = __asyncValues(zip(source, sources_1.range(0))), _c; _c = yield _b.next(), !_c.done;) {
-                    const [t, i] = _c.value;
-                    if (i === index) {
-                        return t;
-                    }
-                }
-            }
-            catch (e_31_1) { e_31 = { error: e_31_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
-                }
-                finally { if (e_31) throw e_31.error; }
-            }
-            throw Error(`elementAt tried to find item at index ${index}, but sequence had fewer elements`);
-        });
-    };
-}
-exports.elementAt = elementAt;
-function elementAtOrDefault(defaultValue, index) {
-    return function (source) {
-        var e_32, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // TODO: Maybe support `Array` here if we ever support sync iterables. This would allow us
-                // to access that index directly.
-                for (var _b = __asyncValues(zip(source, sources_1.range(0))), _c; _c = yield _b.next(), !_c.done;) {
-                    const [t, i] = _c.value;
-                    if (i === index) {
-                        return t;
-                    }
-                }
-            }
-            catch (e_32_1) { e_32 = { error: e_32_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
-                }
-                finally { if (e_32) throw e_32.error; }
-            }
-            return defaultValue;
-        });
-    };
-}
-exports.elementAtOrDefault = elementAtOrDefault;
-function defaultIfEmpty(defaultValue) {
-    return function (source) {
-        return __asyncGenerator(this, arguments, function* () {
-            var e_33, _a;
-            let sequenceEmpty = true;
-            try {
-                for (var source_15 = __asyncValues(source), source_15_1; source_15_1 = yield __await(source_15.next()), !source_15_1.done;) {
-                    const t = source_15_1.value;
-                    sequenceEmpty = false;
-                    yield yield __await(t);
-                }
-            }
-            catch (e_33_1) { e_33 = { error: e_33_1 }; }
-            finally {
-                try {
-                    if (source_15_1 && !source_15_1.done && (_a = source_15.return)) yield __await(_a.call(source_15));
-                }
-                finally { if (e_33) throw e_33.error; }
-            }
-            if (sequenceEmpty) {
-                yield yield __await(defaultValue);
-            }
-        });
-    };
-}
-exports.defaultIfEmpty = defaultIfEmpty;
-//
-// Quantifiers.
-//
-function any(predicate) {
-    return function (source) {
-        var source_16, source_16_1;
-        var e_34, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (predicate === undefined) {
-                predicate = t => true;
-            }
-            try {
-                for (source_16 = __asyncValues(source); source_16_1 = yield source_16.next(), !source_16_1.done;) {
-                    const t = source_16_1.value;
-                    if ((yield predicate(t)) === true) {
-                        return true;
-                    }
-                }
-            }
-            catch (e_34_1) { e_34 = { error: e_34_1 }; }
-            finally {
-                try {
-                    if (source_16_1 && !source_16_1.done && (_a = source_16.return)) yield _a.call(source_16);
-                }
-                finally { if (e_34) throw e_34.error; }
-            }
-            return false;
-        });
-    };
-}
-exports.any = any;
-function all(predicate) {
-    return function (source) {
-        var source_17, source_17_1;
-        var e_35, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                for (source_17 = __asyncValues(source); source_17_1 = yield source_17.next(), !source_17_1.done;) {
-                    const t = source_17_1.value;
-                    if ((yield predicate(t)) === false) {
-                        return false;
-                    }
-                }
-            }
-            catch (e_35_1) { e_35 = { error: e_35_1 }; }
-            finally {
-                try {
-                    if (source_17_1 && !source_17_1.done && (_a = source_17.return)) yield _a.call(source_17);
-                }
-                finally { if (e_35) throw e_35.error; }
-            }
-            return true;
-        });
-    };
-}
-exports.all = all;
-function contains(value) {
-    return function (source) {
-        var source_18, source_18_1;
-        var e_36, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const dist = new Set([value]);
-            try {
-                for (source_18 = __asyncValues(source); source_18_1 = yield source_18.next(), !source_18_1.done;) {
-                    const t = source_18_1.value;
-                    if (dist.has(t)) {
-                        return true;
-                    }
-                }
-            }
-            catch (e_36_1) { e_36 = { error: e_36_1 }; }
-            finally {
-                try {
-                    if (source_18_1 && !source_18_1.done && (_a = source_18.return)) yield _a.call(source_18);
-                }
-                finally { if (e_36) throw e_36.error; }
-            }
-            return false;
-        });
-    };
-}
-exports.contains = contains;
-//
-// Aggregate operators.
-//
-function count(predicate) {
-    return function (source) {
-        var source_19, source_19_1;
-        var e_37, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (predicate === undefined) {
-                predicate = t => true;
-            }
-            let n = 0;
-            try {
-                for (source_19 = __asyncValues(source); source_19_1 = yield source_19.next(), !source_19_1.done;) {
-                    const t = source_19_1.value;
-                    if ((yield predicate(t)) === true) {
-                        n++;
-                    }
-                }
-            }
-            catch (e_37_1) { e_37 = { error: e_37_1 }; }
-            finally {
-                try {
-                    if (source_19_1 && !source_19_1.done && (_a = source_19.return)) yield _a.call(source_19);
-                }
-                finally { if (e_37) throw e_37.error; }
-            }
-            return n;
-        });
-    };
-}
-exports.count = count;
-function sum(selector) {
-    return function (source) {
-        var source_20, source_20_1;
-        var e_38, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // If selector is undefined, the source should emit `number`.
-            if (selector === undefined) {
-                selector = t => t;
-            }
-            let total = 0;
-            try {
-                for (source_20 = __asyncValues(source); source_20_1 = yield source_20.next(), !source_20_1.done;) {
-                    const t = source_20_1.value;
-                    const toSum = yield selector(t);
-                    if (!util_1.isNumber(toSum)) {
-                        throw Error("Can't sum things that aren't numbers");
-                    }
-                    total += toSum;
-                }
-            }
-            catch (e_38_1) { e_38 = { error: e_38_1 }; }
-            finally {
-                try {
-                    if (source_20_1 && !source_20_1.done && (_a = source_20.return)) yield _a.call(source_20);
-                }
-                finally { if (e_38) throw e_38.error; }
-            }
-            return total;
-        });
-    };
-}
-exports.sum = sum;
-function min(selector) {
-    return function (source) {
-        var source_21, source_21_1;
-        var e_39, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // If selector is undefined, the source should emit `number`.
-            if (selector === undefined) {
-                selector = t => t;
-            }
-            let minimum = undefined;
-            try {
-                for (source_21 = __asyncValues(source); source_21_1 = yield source_21.next(), !source_21_1.done;) {
-                    const t = source_21_1.value;
-                    const curr = yield selector(t);
-                    if (minimum === undefined) {
-                        minimum = curr;
-                    }
-                    if (!util_1.isNumber(curr)) {
-                        throw Error("min can't find the minimum of things that aren't numbers");
-                    }
-                    if (minimum > curr) {
-                        minimum = curr;
-                    }
-                }
-            }
-            catch (e_39_1) { e_39 = { error: e_39_1 }; }
-            finally {
-                try {
-                    if (source_21_1 && !source_21_1.done && (_a = source_21.return)) yield _a.call(source_21);
-                }
-                finally { if (e_39) throw e_39.error; }
-            }
-            if (minimum === undefined) {
-                throw Error("min can't be called on an empty sequence");
-            }
-            return minimum;
-        });
-    };
-}
-exports.min = min;
-function max(selector) {
-    return function (source) {
-        var source_22, source_22_1;
-        var e_40, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // If selector is undefined, the source should emit `number`.
-            if (selector === undefined) {
-                selector = t => t;
-            }
-            let maximum = undefined;
-            try {
-                for (source_22 = __asyncValues(source); source_22_1 = yield source_22.next(), !source_22_1.done;) {
-                    const t = source_22_1.value;
-                    const curr = yield selector(t);
-                    if (maximum === undefined) {
-                        maximum = curr;
-                    }
-                    if (!util_1.isNumber(curr)) {
-                        throw Error("max can't find the maximum of things that aren't numbers");
-                    }
-                    if (maximum < curr) {
-                        maximum = curr;
-                    }
-                }
-            }
-            catch (e_40_1) { e_40 = { error: e_40_1 }; }
-            finally {
-                try {
-                    if (source_22_1 && !source_22_1.done && (_a = source_22.return)) yield _a.call(source_22);
-                }
-                finally { if (e_40) throw e_40.error; }
-            }
-            if (maximum === undefined) {
-                throw Error("max can't be called on an empty sequence");
-            }
-            return maximum;
-        });
-    };
-}
-exports.max = max;
-function average(selector) {
-    return function (source) {
-        var source_23, source_23_1;
-        var e_41, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // If selector is undefined, the source should emit `number`.
-            if (selector === undefined) {
-                selector = t => t;
-            }
-            let total = 0;
-            let cnt = 0;
-            try {
-                for (source_23 = __asyncValues(source); source_23_1 = yield source_23.next(), !source_23_1.done;) {
-                    const t = source_23_1.value;
-                    const toSum = yield selector(t);
-                    if (!util_1.isNumber(toSum)) {
-                        throw Error("Can't sum things that aren't numbers");
-                    }
-                    total += toSum;
-                    cnt++;
-                }
-            }
-            catch (e_41_1) { e_41 = { error: e_41_1 }; }
-            finally {
-                try {
-                    if (source_23_1 && !source_23_1.done && (_a = source_23.return)) yield _a.call(source_23);
-                }
-                finally { if (e_41) throw e_41.error; }
-            }
-            if (cnt === 0) {
-                return Promise.reject("Can't compute average of empty sequence");
-            }
-            return total / cnt;
-        });
-    };
-}
-exports.average = average;
-function aggregate(seed, func) {
-    return function (source) {
-        var source_24, source_24_1;
-        var e_42, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let acc = seed;
-            try {
-                for (source_24 = __asyncValues(source); source_24_1 = yield source_24.next(), !source_24_1.done;) {
-                    const t = source_24_1.value;
-                    acc = yield func(acc, t);
-                }
-            }
-            catch (e_42_1) { e_42 = { error: e_42_1 }; }
-            finally {
-                try {
-                    if (source_24_1 && !source_24_1.done && (_a = source_24.return)) yield _a.call(source_24);
-                }
-                finally { if (e_42) throw e_42.error; }
-            }
-            return acc;
-        });
-    };
-}
-exports.aggregate = aggregate;
-//
-// Misc.
-//
-function zip(source1, source2, resultSelector = (t1, t2) => [t1, t2]) {
-    return __asyncGenerator(this, arguments, function* zip_1() {
-        while (true) {
-            const result1 = yield __await(source1.next());
-            const result2 = yield __await(source2.next());
-            if (result1.done || result2.done) {
-                return yield __await(void 0);
-            }
-            else {
-                yield yield __await(yield __await(resultSelector(result1.value, result2.value)));
-            }
-        }
-    });
-}
-exports.zip = zip;