threadsx 2.0.2 → 2.1.0

package/esm/master/pool.mjs

@@ -0,0 +1,313 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import DebugLogger from 'debug';
+import { Subject, multicast, Observable } from 'observable-fns';
+import { allSettled } from '../ponyfills.mjs';
+import { defaultPoolSize } from './implementation.mjs';
+import { PoolEventType } from './pool-types.mjs';
+import { Thread } from './thread.mjs';
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+let nextPoolID = 1;
+function createArray(size) {
+    const array = [];
+    for (let index = 0; index < size; index++) {
+        array.push(index);
+    }
+    return array;
+}
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function flatMap(array, mapper) {
+    return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
+}
+function slugify(text) {
+    return text.replace(/\W/g, " ").trim().replace(/\s+/g, "-");
+}
+function spawnWorkers(spawnWorker, count) {
+    return createArray(count).map(() => ({
+        init: spawnWorker(),
+        runningTasks: []
+    }));
+}
+class WorkerPool {
+    constructor(spawnWorker, optionsOrSize) {
+        this.eventSubject = new Subject();
+        this.initErrors = [];
+        this.isClosing = false;
+        this.nextTaskID = 1;
+        this.taskQueue = [];
+        const options = typeof optionsOrSize === "number"
+            ? { size: optionsOrSize }
+            : optionsOrSize || {};
+        const { size = defaultPoolSize } = options;
+        this.debug = DebugLogger(`threads:pool:${slugify(options.name || String(nextPoolID++))}`);
+        this.options = options;
+        this.workers = spawnWorkers(spawnWorker, size);
+        this.eventObservable = multicast(Observable.from(this.eventSubject));
+        Promise.all(this.workers.map(worker => worker.init)).then(() => this.eventSubject.next({
+            type: PoolEventType.initialized,
+            size: this.workers.length
+        }), error => {
+            this.debug("Error while initializing pool worker:", error);
+            this.eventSubject.error(error);
+            this.initErrors.push(error);
+        });
+    }
+    findIdlingWorker() {
+        const { concurrency = 1 } = this.options;
+        return this.workers.find(worker => worker.runningTasks.length < concurrency);
+    }
+    runPoolTask(worker, task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workerID = this.workers.indexOf(worker) + 1;
+            this.debug(`Running task #${task.id} on worker #${workerID}...`);
+            this.eventSubject.next({
+                type: PoolEventType.taskStart,
+                taskID: task.id,
+                workerID
+            });
+            try {
+                const returnValue = yield task.run(yield worker.init);
+                this.debug(`Task #${task.id} completed successfully`);
+                this.eventSubject.next({
+                    type: PoolEventType.taskCompleted,
+                    returnValue,
+                    taskID: task.id,
+                    workerID
+                });
+            }
+            catch (error) {
+                this.debug(`Task #${task.id} failed`);
+                this.eventSubject.next({
+                    type: PoolEventType.taskFailed,
+                    taskID: task.id,
+                    error: error,
+                    workerID
+                });
+            }
+        });
+    }
+    run(worker, task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                const removeTaskFromWorkersRunningTasks = () => {
+                    worker.runningTasks = worker.runningTasks.filter(someRunPromise => someRunPromise !== runPromise);
+                };
+                // Defer task execution by one tick to give handlers time to subscribe
+                yield delay(0);
+                try {
+                    yield this.runPoolTask(worker, task);
+                }
+                finally {
+                    removeTaskFromWorkersRunningTasks();
+                    if (!this.isClosing) {
+                        this.scheduleWork();
+                    }
+                }
+            }))();
+            worker.runningTasks.push(runPromise);
+        });
+    }
+    scheduleWork() {
+        this.debug(`Attempt de-queueing a task in order to run it...`);
+        const availableWorker = this.findIdlingWorker();
+        if (!availableWorker)
+            return;
+        const nextTask = this.taskQueue.shift();
+        if (!nextTask) {
+            this.debug(`Task queue is empty`);
+            this.eventSubject.next({ type: PoolEventType.taskQueueDrained });
+            return;
+        }
+        this.run(availableWorker, nextTask);
+    }
+    taskCompletion(taskID) {
+        return new Promise((resolve, reject) => {
+            const eventSubscription = this.events().subscribe(event => {
+                if (event.type === PoolEventType.taskCompleted && event.taskID === taskID) {
+                    eventSubscription.unsubscribe();
+                    resolve(event.returnValue);
+                }
+                else if (event.type === PoolEventType.taskFailed && event.taskID === taskID) {
+                    eventSubscription.unsubscribe();
+                    reject(event.error);
+                }
+                else if (event.type === PoolEventType.terminated) {
+                    eventSubscription.unsubscribe();
+                    reject(Error("Pool has been terminated before task was run."));
+                }
+            });
+        });
+    }
+    settled() {
+        return __awaiter(this, arguments, void 0, function* (allowResolvingImmediately = false) {
+            const getCurrentlyRunningTasks = () => flatMap(this.workers, worker => worker.runningTasks);
+            const taskFailures = [];
+            const failureSubscription = this.eventObservable.subscribe(event => {
+                if (event.type === PoolEventType.taskFailed) {
+                    taskFailures.push(event.error);
+                }
+            });
+            if (this.initErrors.length > 0) {
+                return Promise.reject(this.initErrors[0]);
+            }
+            if (allowResolvingImmediately && this.taskQueue.length === 0) {
+                yield allSettled(getCurrentlyRunningTasks());
+                return taskFailures;
+            }
+            yield new Promise((resolve, reject) => {
+                const subscription = this.eventObservable.subscribe({
+                    next(event) {
+                        if (event.type === PoolEventType.taskQueueDrained || event.type === PoolEventType.terminated) {
+                            subscription.unsubscribe();
+                            resolve(void 0);
+                        }
+                    },
+                    complete() {
+                        // The pool was terminated while we were waiting; resolve instead of hanging.
+                        subscription.unsubscribe();
+                        resolve(void 0);
+                    },
+                    error: reject // make a pool-wide error reject the completed() result promise
+                });
+            });
+            yield allSettled(getCurrentlyRunningTasks());
+            failureSubscription.unsubscribe();
+            return taskFailures;
+        });
+    }
+    completed() {
+        return __awaiter(this, arguments, void 0, function* (allowResolvingImmediately = false) {
+            const settlementPromise = this.settled(allowResolvingImmediately);
+            const earlyExitPromise = new Promise((resolve, reject) => {
+                const subscription = this.eventObservable.subscribe({
+                    next(event) {
+                        if (event.type === PoolEventType.taskQueueDrained || event.type === PoolEventType.terminated) {
+                            subscription.unsubscribe();
+                            resolve(settlementPromise);
+                        }
+                        else if (event.type === PoolEventType.taskFailed) {
+                            subscription.unsubscribe();
+                            reject(event.error);
+                        }
+                    },
+                    complete() {
+                        // The pool was terminated while we were waiting; resolve instead of hanging.
+                        subscription.unsubscribe();
+                        resolve(settlementPromise);
+                    },
+                    error: reject // make a pool-wide error reject the completed() result promise
+                });
+            });
+            const errors = yield Promise.race([
+                settlementPromise,
+                earlyExitPromise
+            ]);
+            if (errors.length > 0) {
+                throw errors[0];
+            }
+        });
+    }
+    events() {
+        return this.eventObservable;
+    }
+    queue(taskFunction) {
+        const { maxQueuedJobs = Infinity } = this.options;
+        if (this.isClosing) {
+            throw Error(`Cannot schedule pool tasks after terminate() has been called.`);
+        }
+        if (this.initErrors.length > 0) {
+            throw this.initErrors[0];
+        }
+        const taskID = this.nextTaskID++;
+        const taskCompletion = this.taskCompletion(taskID);
+        taskCompletion.catch((error) => {
+            // Prevent unhandled rejections here as we assume the user will use
+            // `pool.completed()`, `pool.settled()` or `task.catch()` to handle errors
+            this.debug(`Task #${taskID} errored:`, error);
+        });
+        const task = {
+            id: taskID,
+            run: taskFunction,
+            cancel: () => {
+                if (this.taskQueue.indexOf(task) === -1)
+                    return;
+                this.taskQueue = this.taskQueue.filter(someTask => someTask !== task);
+                this.eventSubject.next({
+                    type: PoolEventType.taskCanceled,
+                    taskID: task.id
+                });
+            },
+            then: taskCompletion.then.bind(taskCompletion)
+        };
+        if (this.taskQueue.length >= maxQueuedJobs) {
+            throw Error("Maximum number of pool tasks queued. Refusing to queue another one.\n" +
+                "This usually happens for one of two reasons: We are either at peak " +
+                "workload right now or some tasks just won't finish, thus blocking the pool.");
+        }
+        this.debug(`Queueing task #${task.id}...`);
+        this.taskQueue.push(task);
+        this.eventSubject.next({
+            type: PoolEventType.taskQueued,
+            taskID: task.id
+        });
+        this.scheduleWork();
+        return task;
+    }
+    terminate(force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isClosing = true;
+            if (!force) {
+                yield this.completed(true);
+            }
+            this.eventSubject.next({
+                type: PoolEventType.terminated,
+                remainingQueue: [...this.taskQueue]
+            });
+            this.eventSubject.complete();
+            yield Promise.all(this.workers.map((worker) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield Thread.terminate(yield worker.init);
+                }
+                catch (error) {
+                    // The worker never finished initializing (e.g. it hit the init
+                    // timeout), so `worker.init` rejected and there is no thread to
+                    // terminate here — spawn() already tore down the underlying worker.
+                    this.debug("Worker did not initialize; nothing to terminate:", error);
+                }
+            })));
+        });
+    }
+}
+WorkerPool.EventType = PoolEventType;
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+function PoolConstructor(spawnWorker, optionsOrSize) {
+    // The function exists only so we don't need to use `new` to create a pool (we still can, though).
+    // If the Pool is a class or not is an implementation detail that should not concern the user.
+    // The explicit `Pool<ThreadType>` return type keeps the private `WorkerPool` class out of the
+    // public type surface, so consumers can name/re-export the pool type (#417).
+    return new WorkerPool(spawnWorker, optionsOrSize);
+}
+PoolConstructor.EventType = PoolEventType;
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+const Pool = PoolConstructor;
+
+export { Pool, PoolEventType, Thread };

package/esm/master/register.mjs

@@ -0,0 +1,14 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Worker } from './index.mjs';
+
+if (typeof global !== "undefined") {
+    global.Worker = Worker;
+}
+else if (typeof window !== "undefined") {
+    window.Worker = Worker;
+}

package/esm/master/spawn.mjs

@@ -0,0 +1,162 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import DebugLogger from 'debug';
+import { Observable } from 'observable-fns';
+import { deserialize } from '../common.mjs';
+import { createPromiseWithResolver } from '../promise.mjs';
+import { $worker, $terminate, $events, $errors } from '../symbols.mjs';
+import { WorkerEventType } from '../types/master.mjs';
+import { createProxyModule, createProxyFunction } from './invocation-proxy.mjs';
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const debugMessages = DebugLogger("threads:master:messages");
+const debugSpawn = DebugLogger("threads:master:spawn");
+const debugThreadUtils = DebugLogger("threads:master:thread-utils");
+const isInitMessage = (data) => data && data.type === "init";
+const isUncaughtErrorMessage = (data) => data && data.type === "uncaughtError";
+const initMessageTimeout = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.THREADS_WORKER_INIT_TIMEOUT
+    ? Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
+    : 10000;
+function withTimeout(promise, timeoutInMs, errorMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let timeoutHandle;
+        const timeout = new Promise((resolve, reject) => {
+            timeoutHandle = setTimeout(() => reject(Error(errorMessage)), timeoutInMs);
+        });
+        try {
+            return yield Promise.race([
+                promise,
+                timeout
+            ]);
+        }
+        finally {
+            // Always clear the timer, even when `promise` rejects. Otherwise a pending
+            // timeout keeps the event loop alive until it fires (which on a failed
+            // spawn showed up as ava "failed to exit" on slower runners).
+            clearTimeout(timeoutHandle);
+        }
+    });
+}
+function receiveInitMessage(worker) {
+    return new Promise((resolve, reject) => {
+        const messageHandler = ((event) => {
+            debugMessages("Message from worker before finishing initialization:", event.data);
+            if (isInitMessage(event.data)) {
+                worker.removeEventListener("message", messageHandler);
+                resolve(event.data);
+            }
+            else if (isUncaughtErrorMessage(event.data)) {
+                worker.removeEventListener("message", messageHandler);
+                reject(deserialize(event.data.error));
+            }
+        });
+        worker.addEventListener("message", messageHandler);
+    });
+}
+function createEventObservable(worker, workerTermination) {
+    return new Observable(observer => {
+        const messageHandler = ((messageEvent) => {
+            const workerEvent = {
+                type: WorkerEventType.message,
+                data: messageEvent.data
+            };
+            observer.next(workerEvent);
+        });
+        const rejectionHandler = ((errorEvent) => {
+            debugThreadUtils("Unhandled promise rejection event in thread:", errorEvent);
+            const workerEvent = {
+                type: WorkerEventType.internalError,
+                error: Error(errorEvent.reason)
+            };
+            observer.next(workerEvent);
+        });
+        worker.addEventListener("message", messageHandler);
+        worker.addEventListener("unhandledrejection", rejectionHandler);
+        workerTermination.then(() => {
+            const terminationEvent = {
+                type: WorkerEventType.termination
+            };
+            worker.removeEventListener("message", messageHandler);
+            worker.removeEventListener("unhandledrejection", rejectionHandler);
+            observer.next(terminationEvent);
+            observer.complete();
+        });
+    });
+}
+function createTerminator(worker) {
+    const [termination, resolver] = createPromiseWithResolver();
+    const terminate = () => __awaiter(this, void 0, void 0, function* () {
+        debugThreadUtils("Terminating worker");
+        // Newer versions of worker_threads workers return a promise
+        yield worker.terminate();
+        resolver();
+    });
+    return { terminate, termination };
+}
+function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
+    const workerErrors = workerEvents
+        .filter(event => event.type === WorkerEventType.internalError)
+        .map(errorEvent => errorEvent.error);
+    return Object.assign(raw, {
+        [$errors]: workerErrors,
+        [$events]: workerEvents,
+        [$terminate]: terminate,
+        [$worker]: worker
+    });
+}
+/**
+ * Spawn a new thread. Takes a fresh worker instance, wraps it in a thin
+ * abstraction layer to provide the transparent API and verifies that
+ * the worker has initialized successfully.
+ *
+ * @param worker Instance of `Worker`. Either a web worker or a `worker_threads` worker.
+ * @param [options]
+ * @param [options.timeout] Init message timeout. Default: 10000 or set by environment variable.
+ */
+function spawn(worker, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        debugSpawn("Initializing new thread");
+        const timeout = options && options.timeout ? options.timeout : initMessageTimeout;
+        let initMessage;
+        try {
+            initMessage = yield withTimeout(receiveInitMessage(worker), timeout, `Timeout: Did not receive an init message from worker after ${timeout}ms. Make sure the worker calls expose().`);
+        }
+        catch (error) {
+            // The worker failed to initialise (e.g. it threw before calling expose(),
+            // or never sent an init message). Tear it down so it does not leak a live
+            // worker handle and keep the process from exiting.
+            yield Promise.resolve((_b = (_a = worker).terminate) === null || _b === void 0 ? void 0 : _b.call(_a)).catch(() => undefined);
+            throw error;
+        }
+        const exposed = initMessage.exposed;
+        const { termination, terminate } = createTerminator(worker);
+        const events = createEventObservable(worker, termination);
+        if (exposed.type === "function") {
+            const proxy = createProxyFunction(worker);
+            return setPrivateThreadProps(proxy, worker, events, terminate);
+        }
+        else if (exposed.type === "module") {
+            const proxy = createProxyModule(worker, exposed.methods);
+            return setPrivateThreadProps(proxy, worker, events, terminate);
+        }
+        else {
+            const type = exposed.type;
+            throw Error(`Worker init message states unexpected type of expose(): ${type}`);
+        }
+    });
+}
+
+export { spawn };

package/esm/master/thread.mjs

@@ -0,0 +1,28 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { $terminate, $events, $errors } from '../symbols.mjs';
+
+function fail(message) {
+    throw Error(message);
+}
+/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */
+const Thread = {
+    /** Return an observable that can be used to subscribe to all errors happening in the thread. */
+    errors(thread) {
+        return thread[$errors] || fail("Error observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
+    },
+    /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */
+    events(thread) {
+        return thread[$events] || fail("Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
+    },
+    /** Terminate a thread. Remember to terminate every thread when you are done using it. */
+    terminate(thread) {
+        return thread[$terminate]();
+    }
+};
+
+export { Thread };

package/esm/observable-promise.mjs

@@ -0,0 +1,155 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Observable } from 'observable-fns';
+
+var _a;
+const doNothing = () => undefined;
+const returnInput = (input) => input;
+const runDeferred = (fn) => Promise.resolve().then(fn);
+function fail(error) {
+    throw error;
+}
+function isThenable(thing) {
+    return thing && typeof thing.then === "function";
+}
+/**
+ * Creates a hybrid, combining the APIs of an Observable and a Promise.
+ *
+ * It is used to proxy async process states when we are initially not sure
+ * if that async process will yield values once (-> Promise) or multiple
+ * times (-> Observable).
+ *
+ * Note that the observable promise inherits some of the observable's characteristics:
+ * The `init` function will be called *once for every time anyone subscribes to it*.
+ *
+ * If this is undesired, derive a hot observable from it using `makeHot()` and
+ * subscribe to that.
+ */
+class ObservablePromise extends Observable {
+    constructor(init) {
+        super((originalObserver) => {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const self = this;
+            const observer = Object.assign(Object.assign({}, originalObserver), { complete() {
+                    originalObserver.complete();
+                    self.onCompletion();
+                },
+                error(error) {
+                    originalObserver.error(error);
+                    self.onError(error);
+                },
+                next(value) {
+                    originalObserver.next(value);
+                    self.onNext(value);
+                } });
+            try {
+                this.initHasRun = true;
+                return init(observer);
+            }
+            catch (error) {
+                observer.error(error);
+            }
+        });
+        this.initHasRun = false;
+        this.fulfillmentCallbacks = [];
+        this.rejectionCallbacks = [];
+        this.firstValueSet = false;
+        this.state = "pending";
+        this[_a] = "[object ObservablePromise]";
+    }
+    onNext(value) {
+        if (!this.firstValueSet) {
+            this.firstValue = value;
+            this.firstValueSet = true;
+        }
+    }
+    onError(error) {
+        this.state = "rejected";
+        this.rejection = error;
+        for (const onRejected of this.rejectionCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onRejected(error));
+        }
+    }
+    onCompletion() {
+        this.state = "fulfilled";
+        for (const onFulfilled of this.fulfillmentCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onFulfilled(this.firstValue));
+        }
+    }
+    then(onFulfilledRaw, onRejectedRaw) {
+        const onFulfilled = onFulfilledRaw || returnInput;
+        const onRejected = onRejectedRaw || fail;
+        let onRejectedCalled = false;
+        return new Promise((resolve, reject) => {
+            const rejectionCallback = (error) => {
+                if (onRejectedCalled)
+                    return;
+                onRejectedCalled = true;
+                try {
+                    resolve(onRejected(error));
+                }
+                catch (anotherError) {
+                    reject(anotherError);
+                }
+            };
+            const fulfillmentCallback = (value) => {
+                try {
+                    resolve(onFulfilled(value));
+                }
+                catch (error) {
+                    rejectionCallback(error);
+                }
+            };
+            if (!this.initHasRun) {
+                this.subscribe({ error: rejectionCallback });
+            }
+            if (this.state === "fulfilled") {
+                return resolve(onFulfilled(this.firstValue));
+            }
+            if (this.state === "rejected") {
+                onRejectedCalled = true;
+                return resolve(onRejected(this.rejection));
+            }
+            this.fulfillmentCallbacks.push(fulfillmentCallback);
+            this.rejectionCallbacks.push(rejectionCallback);
+        });
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    finally(onCompleted) {
+        const handler = onCompleted || doNothing;
+        return this.then((value) => {
+            handler();
+            return value;
+        }, () => handler());
+    }
+    static from(thing) {
+        if (isThenable(thing)) {
+            return new ObservablePromise(observer => {
+                const onFulfilled = (value) => {
+                    observer.next(value);
+                    observer.complete();
+                };
+                const onRejected = (error) => {
+                    observer.error(error);
+                };
+                thing.then(onFulfilled, onRejected);
+            });
+        }
+        else {
+            return super.from(thing);
+        }
+    }
+}
+_a = Symbol.toStringTag;
+
+export { ObservablePromise };