aix 0.0.14 → 0.1.0-alpha.1

package/lib/restToIterable.js

@@ -1,74 +0,0 @@
-"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;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) 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 __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 });
-/**
- * @param values values to be returned by the async iterable
- */
-function restToIterable() {
-    var values = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        values[_i] = arguments[_i];
-    }
-    return __asyncGenerator(this, arguments, function restToIterable_1() {
-        var _i, values_1, item;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _i = 0, values_1 = values;
-                    _a.label = 1;
-                case 1:
-                    if (!(_i < values_1.length)) return [3 /*break*/, 5];
-                    item = values_1[_i];
-                    return [4 /*yield*/, __await(item)];
-                case 2: return [4 /*yield*/, _a.sent()];
-                case 3:
-                    _a.sent();
-                    _a.label = 4;
-                case 4:
-                    _i++;
-                    return [3 /*break*/, 1];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
-}
-exports.restToIterable = restToIterable;
-exports.default = restToIterable;

package/lib/spanAll.d.ts

@@ -1,2 +0,0 @@
-export declare function spanAll<T>(predicate: (t: T) => boolean): (source: AsyncIterable<T>) => AsyncIterableIterator<AsyncIterable<T>>;
-export default spanAll;

package/lib/spanAll.js

@@ -1,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var deferredIterable_1 = __importDefault(require("./deferredIterable"));
-var toCallbacks_1 = __importDefault(require("./toCallbacks"));
-function spanAll(predicate) {
-    return function inner(source) {
-        var spanDeferredIterable = new deferredIterable_1.default();
-        var currentDeferredIterable = new deferredIterable_1.default();
-        spanDeferredIterable.value(currentDeferredIterable.iterator);
-        toCallbacks_1.default(source, function (result) {
-            if (result.done) {
-                currentDeferredIterable.close();
-                spanDeferredIterable.close();
-                return Promise.resolve();
-            }
-            if (predicate(result.value)) {
-                currentDeferredIterable.close();
-                currentDeferredIterable = new deferredIterable_1.default();
-                spanDeferredIterable.value(currentDeferredIterable.iterator);
-            }
-            else {
-                currentDeferredIterable.value(result.value);
-            }
-            // not handling back pressure at the moment
-            return Promise.resolve();
-        });
-        return spanDeferredIterable.iterator;
-    };
-}
-exports.spanAll = spanAll;
-exports.default = spanAll;

package/lib/tap.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tap an iterable
- */
-export declare function tap<T>(func: (t: T) => void): (source: AsyncIterable<T>) => AsyncIterableIterator<T>;
-export default tap;

package/lib/tap.js

@@ -1,97 +0,0 @@
-"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;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __asyncValues = (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 });
-/**
- * Tap an iterable
- */
-function tap(func) {
-    return function inner(source) {
-        return __asyncGenerator(this, arguments, function inner_1() {
-            var e_1, _a, source_1, source_1_1, item, e_1_1;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 7, 8, 13]);
-                        source_1 = __asyncValues(source);
-                        _b.label = 1;
-                    case 1: return [4 /*yield*/, __await(source_1.next())];
-                    case 2:
-                        if (!(source_1_1 = _b.sent(), !source_1_1.done)) return [3 /*break*/, 6];
-                        item = source_1_1.value;
-                        func(item);
-                        return [4 /*yield*/, __await(item)];
-                    case 3: return [4 /*yield*/, _b.sent()];
-                    case 4:
-                        _b.sent();
-                        _b.label = 5;
-                    case 5: return [3 /*break*/, 1];
-                    case 6: return [3 /*break*/, 13];
-                    case 7:
-                        e_1_1 = _b.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 13];
-                    case 8:
-                        _b.trys.push([8, , 11, 12]);
-                        if (!(source_1_1 && !source_1_1.done && (_a = source_1.return))) return [3 /*break*/, 10];
-                        return [4 /*yield*/, __await(_a.call(source_1))];
-                    case 9:
-                        _b.sent();
-                        _b.label = 10;
-                    case 10: return [3 /*break*/, 12];
-                    case 11:
-                        if (e_1) throw e_1.error;
-                        return [7 /*endfinally*/];
-                    case 12: return [7 /*endfinally*/];
-                    case 13: return [2 /*return*/];
-                }
-            });
-        });
-    };
-}
-exports.tap = tap;
-exports.default = tap;

package/lib/toCallbacks.d.ts

@@ -1,12 +0,0 @@
-/** Provides a way for callbacks to signal early completion */
-export declare class StopError extends Error {
-}
-/**
- * Converts an async iterable into a series of callbacks. The function returns
- * a promise that resolves when the stream is done
- *
- * @param source the source iterable
- * @param callback the callback that gets called for each value
- */
-export declare function toCallbacks<T>(source: AsyncIterable<T>, callback: (result: IteratorResult<T>) => Promise<void>): Promise<void>;
-export default toCallbacks;

package/lib/toCallbacks.js

@@ -1,98 +0,0 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-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 __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;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) 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 };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/** Provides a way for callbacks to signal early completion */
-var StopError = /** @class */ (function (_super) {
-    __extends(StopError, _super);
-    function StopError() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return StopError;
-}(Error));
-exports.StopError = StopError;
-/**
- * Converts an async iterable into a series of callbacks. The function returns
- * a promise that resolves when the stream is done
- *
- * @param source the source iterable
- * @param callback the callback that gets called for each value
- */
-function toCallbacks(source, callback) {
-    return __awaiter(this, void 0, void 0, function () {
-        var iterator, result, StopError_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    iterator = source[Symbol.asyncIterator]();
-                    _a.label = 1;
-                case 1:
-                    if (!true) return [3 /*break*/, 7];
-                    return [4 /*yield*/, iterator.next()];
-                case 2:
-                    result = _a.sent();
-                    _a.label = 3;
-                case 3:
-                    _a.trys.push([3, 5, , 6]);
-                    return [4 /*yield*/, callback(result)];
-                case 4:
-                    _a.sent();
-                    return [3 /*break*/, 6];
-                case 5:
-                    StopError_1 = _a.sent();
-                    return [2 /*return*/];
-                case 6:
-                    if (result.done) {
-                        return [2 /*return*/];
-                    }
-                    return [3 /*break*/, 1];
-                case 7: return [2 /*return*/];
-            }
-        });
-    });
-}
-exports.toCallbacks = toCallbacks;
-exports.default = toCallbacks;

package/lib/zip.d.ts

@@ -1,5 +0,0 @@
-/**
- * Zips two iterables
- */
-export declare function zip<T>(first: AsyncIterable<T>): (second: AsyncIterable<T>) => AsyncIterableIterator<IteratorResult<T>[]>;
-export default zip;

package/lib/zip.js

@@ -1,76 +0,0 @@
-"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;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) 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 __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 });
-/**
- * Zips two iterables
- */
-function zip(first) {
-    return function inner(second) {
-        return __asyncGenerator(this, arguments, function inner_1() {
-            var iterators, _a, firstNext, secondNext;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        iterators = [first, second].map(function (value) {
-                            return value[Symbol.asyncIterator]();
-                        });
-                        _b.label = 1;
-                    case 1:
-                        if (!true) return [3 /*break*/, 7];
-                        return [4 /*yield*/, __await(Promise.all(iterators.map(function (iterator) { return iterator.next(); })))];
-                    case 2:
-                        _a = _b.sent(), firstNext = _a[0], secondNext = _a[1];
-                        if (!(firstNext.done || secondNext.done)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, __await(void 0)];
-                    case 3: return [2 /*return*/, _b.sent()];
-                    case 4: return [4 /*yield*/, __await([firstNext, secondNext])];
-                    case 5: return [4 /*yield*/, _b.sent()];
-                    case 6:
-                        _b.sent();
-                        return [3 /*break*/, 1];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-}
-exports.zip = zip;
-exports.default = zip;

package/src/__tests__/deferredIterable.test.ts

@@ -1,22 +0,0 @@
-import { DeferredIterable } from "../deferredIterable";
-
-test("DeferredIterable", async () => {
-  const d = new DeferredIterable<number>();
-  d.value(1);
-  d.value(2);
-  d.value(3);
-  d.close();
-  const result = [];
-  for await (const item of d.iterator) {
-    result.push(item);
-  }
-  expect(result).toEqual([1, 2, 3]);
-});
-
-test("DeferredIterable", async () => {
-  const d = new DeferredIterable<number>();
-  const iterator = d.iterator;
-  const [, { value, done }] = await Promise.all([d.value(1), iterator.next()]);
-  expect(done).toBeFalsy();
-  expect(value).toBe(1);
-});

package/src/__tests__/filter.test.ts

@@ -1,10 +0,0 @@
-import { of } from "../of";
-import { iterableToArray } from "../iterableToArray";
-import { filter } from "../filter";
-
-test("filter", async () => {
-  const result = await iterableToArray(
-    filter((value: number) => value % 2 === 0)(of(1, 2, 3, 4, 5, 6))
-  );
-  expect(result).toEqual([2, 4, 6]);
-});

package/src/__tests__/flatMap.test.ts

@@ -1,12 +0,0 @@
-import { of } from "../of";
-import { flatMap } from "../flatMap";
-import { iterableToArray } from "../iterableToArray";
-
-test("flatMap", async () => {
-  const result = await iterableToArray(
-    flatMap(async function*(value: number) {
-      yield value * 2;
-    })(of(1, 2, 3))
-  );
-  expect(result).toEqual([2, 4, 6]);
-});

package/src/__tests__/lookahead.test.ts

@@ -1,9 +0,0 @@
-import { restToIterable } from "../restToIterable";
-import { lookahead } from "../lookahead";
-import { iterableToArray } from "../iterableToArray";
-
-test("lookahead", async () => {
-  const result = await lookahead(2)(restToIterable(1, 2, 3));
-  expect(result.values).toEqual([1, 2]);
-  expect(await iterableToArray(result.iterable)).toEqual([1, 2, 3]);
-});

package/src/__tests__/map.test.ts

@@ -1,10 +0,0 @@
-import { restToIterable } from "../restToIterable";
-import { iterableToArray } from "../iterableToArray";
-import { map } from "../map";
-
-test("map", async () => {
-  const result = await iterableToArray(
-    map((value: number) => value * 2)(restToIterable(1, 2, 3))
-  );
-  expect(result).toEqual([2, 4, 6]);
-});

package/src/__tests__/merge.test.ts

@@ -1,9 +0,0 @@
-import { of } from "../of";
-import { merge } from "../merge";
-import { iterableToArray } from "../iterableToArray";
-
-test("merge", async () => {
-  const merged = merge(of(1, 2, 3), of(4, 5, 6));
-  const result = (await iterableToArray(merged)).sort();
-  expect(result).toEqual([1, 2, 3, 4, 5, 6]);
-});

package/src/__tests__/reduce.test.ts

@@ -1,10 +0,0 @@
-import { of } from "../of";
-import { reduce } from "../reduce";
-
-test("reduce", async () => {
-  const result = await reduce(
-    (accumulator: number, next: number) => accumulator + next,
-    0
-  )(of(1, 2, 3));
-  expect(result).toEqual(6);
-});

package/src/__tests__/spanAll.test.ts

@@ -1,17 +0,0 @@
-import { of } from "../of";
-import { spanAll } from "../spanAll";
-
-test("spanAll", async () => {
-  const iterables = spanAll((value: number) => value % 2 === 0)(
-    of(1, 2, 3, 4, 5, 6)
-  );
-  const result = [];
-  for await (const iterable of iterables) {
-    const innerResult = [];
-    for await (const item of iterable) {
-      innerResult.push(item)
-    }
-    result.push(innerResult);
-  }
-  expect(result).toEqual([[1], [3], [5], []]);
-});

package/src/concat.ts

@@ -1,13 +0,0 @@
-/**
- * Concatenates two iterables
- */
-export function concat<T>(first: AsyncIterable<T>) {
-  return async function* inner(second: AsyncIterable<T>) {
-    for await (const item of first) {
-      yield item;
-    }
-    for await (const item of second) {
-      yield item;
-    }
-  };
-}

package/src/deferred.ts

@@ -1,15 +0,0 @@
-/**
- * A classic deferred
- */
-export class Deferred<T> {
-  resolve: (value?: T | PromiseLike<T>) => void = () => {};
-  reject: (reason?: any) => void = () => {};
-  promise: Promise<T>;
-
-  constructor() {
-    this.promise = new Promise<T>((resolve, reject) => {
-      this.resolve = resolve;
-      this.reject = reject;
-    });
-  }
-}