diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..0693147
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ben Lesh <ben@benlesh.com>, Dominic Farolino <dom@chromium.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/impl/observable-polyfill.d.ts b/impl/observable-polyfill.d.ts
new file mode 100644
index 0000000..2871499
--- /dev/null
+++ b/impl/observable-polyfill.d.ts
@@ -0,0 +1,379 @@
+import { Observable } from './observable';
+
+declare global {
+	interface EventTarget {
+		on(eventType: string): Observable<Event>;
+	}
+	interface AbortSignal {
+		on<K extends keyof AbortSignalEventMap>(
+			eventType: K,
+		): Observable<AbortSignalEventMap[K]>;
+	}
+	interface AbstractWorker {
+		on<K extends keyof AbstractWorkerEventMap>(
+			eventType: K,
+		): Observable<AbstractWorkerEventMap[K]>;
+	}
+	interface Animation {
+		on<K extends keyof AnimationEventMap>(
+			eventType: K,
+		): Observable<AnimationEventMap[K]>;
+	}
+	interface AudioScheduledSourceNode {
+		on<K extends keyof AudioScheduledSourceNodeEventMap>(
+			eventType: K,
+		): Observable<AudioScheduledSourceNodeEventMap[K]>;
+	}
+	interface AudioWorkletNode {
+		on<K extends keyof AudioWorkletNodeEventMap>(
+			eventType: K,
+		): Observable<AudioWorkletNodeEventMap[K]>;
+	}
+	interface BaseAudioContext {
+		on<K extends keyof BaseAudioContextEventMap>(
+			eventType: K,
+		): Observable<BaseAudioContextEventMap[K]>;
+	}
+	interface BroadcastChannel {
+		on<K extends keyof BroadcastChannelEventMap>(
+			eventType: K,
+		): Observable<BroadcastChannelEventMap[K]>;
+	}
+	interface Document {
+		on<K extends keyof DocumentEventMap>(
+			eventType: K,
+		): Observable<DocumentEventMap[K]>;
+	}
+	interface Element {
+		on<K extends keyof ElementEventMap>(
+			eventType: K,
+		): Observable<ElementEventMap[K]>;
+	}
+	interface EventSource {
+		on<K extends keyof EventSourceEventMap>(
+			eventType: K,
+		): Observable<EventSourceEventMap[K]>;
+	}
+	interface FileReader {
+		on<K extends keyof FileReaderEventMap>(
+			eventType: K,
+		): Observable<FileReaderEventMap[K]>;
+	}
+	interface FontFaceSet {
+		on<K extends keyof FontFaceSetEventMap>(
+			eventType: K,
+		): Observable<FontFaceSetEventMap[K]>;
+	}
+	interface GlobalEventHandlers {
+		on<K extends keyof GlobalEventHandlersEventMap>(
+			eventType: K,
+		): Observable<GlobalEventHandlersEventMap[K]>;
+	}
+	interface HTMLBodyElement {
+		on<K extends keyof HTMLBodyElementEventMap>(
+			eventType: K,
+		): Observable<HTMLBodyElementEventMap[K]>;
+	}
+	interface HTMLElement {
+		on<K extends keyof HTMLElementEventMap>(
+			eventType: K,
+		): Observable<HTMLElementEventMap[K]>;
+	}
+	interface HTMLFrameSetElement {
+		on<K extends keyof HTMLFrameSetElementEventMap>(
+			eventType: K,
+		): Observable<HTMLFrameSetElementEventMap[K]>;
+	}
+	interface HTMLMediaElement {
+		on<K extends keyof HTMLMediaElementEventMap>(
+			eventType: K,
+		): Observable<HTMLMediaElementEventMap[K]>;
+	}
+	interface HTMLVideoElement {
+		on<K extends keyof HTMLVideoElementEventMap>(
+			eventType: K,
+		): Observable<HTMLVideoElementEventMap[K]>;
+	}
+	interface IDBDatabase {
+		on<K extends keyof IDBDatabaseEventMap>(
+			eventType: K,
+		): Observable<IDBDatabaseEventMap[K]>;
+	}
+	interface IDBOpenDBRequest {
+		on<K extends keyof IDBOpenDBRequestEventMap>(
+			eventType: K,
+		): Observable<IDBOpenDBRequestEventMap[K]>;
+	}
+	interface IDBRequest {
+		on<K extends keyof IDBRequestEventMap>(
+			eventType: K,
+		): Observable<IDBRequestEventMap[K]>;
+	}
+	interface IDBTransaction {
+		on<K extends keyof IDBTransactionEventMap>(
+			eventType: K,
+		): Observable<IDBTransactionEventMap[K]>;
+	}
+	interface MIDIAccess {
+		on<K extends keyof MIDIAccessEventMap>(
+			eventType: K,
+		): Observable<MIDIAccessEventMap[K]>;
+	}
+	interface MIDIInput {
+		on<K extends keyof MIDIInputEventMap>(
+			eventType: K,
+		): Observable<MIDIInputEventMap[K]>;
+	}
+	interface MIDIPort {
+		on<K extends keyof MIDIPortEventMap>(
+			eventType: K,
+		): Observable<MIDIPortEventMap[K]>;
+	}
+	interface MathMLElement {
+		on<K extends keyof MathMLElementEventMap>(
+			eventType: K,
+		): Observable<MathMLElementEventMap[K]>;
+	}
+	interface MediaDevices {
+		on<K extends keyof MediaDevicesEventMap>(
+			eventType: K,
+		): Observable<MediaDevicesEventMap[K]>;
+	}
+	interface MediaKeySession {
+		on<K extends keyof MediaKeySessionEventMap>(
+			eventType: K,
+		): Observable<MediaKeySessionEventMap[K]>;
+	}
+	interface MediaQueryList {
+		on<K extends keyof MediaQueryListEventMap>(
+			eventType: K,
+		): Observable<MediaQueryListEventMap[K]>;
+	}
+	interface MediaRecorder {
+		on<K extends keyof MediaRecorderEventMap>(
+			eventType: K,
+		): Observable<MediaRecorderEventMap[K]>;
+	}
+	interface MediaSource {
+		on<K extends keyof MediaSourceEventMap>(
+			eventType: K,
+		): Observable<MediaSourceEventMap[K]>;
+	}
+	interface MediaStream {
+		on<K extends keyof MediaStreamEventMap>(
+			eventType: K,
+		): Observable<MediaStreamEventMap[K]>;
+	}
+	interface MediaStreamTrack {
+		on<K extends keyof MediaStreamTrackEventMap>(
+			eventType: K,
+		): Observable<MediaStreamTrackEventMap[K]>;
+	}
+	interface MessagePort {
+		on<K extends keyof MessagePortEventMap>(
+			eventType: K,
+		): Observable<MessagePortEventMap[K]>;
+	}
+	interface Notification {
+		on<K extends keyof NotificationEventMap>(
+			eventType: K,
+		): Observable<NotificationEventMap[K]>;
+	}
+	interface OfflineAudioContext {
+		on<K extends keyof OfflineAudioContextEventMap>(
+			eventType: K,
+		): Observable<OfflineAudioContextEventMap[K]>;
+	}
+	interface OffscreenCanvas {
+		on<K extends keyof OffscreenCanvasEventMap>(
+			eventType: K,
+		): Observable<OffscreenCanvasEventMap[K]>;
+	}
+	interface PaymentRequest {
+		on<K extends keyof PaymentRequestEventMap>(
+			eventType: K,
+		): Observable<PaymentRequestEventMap[K]>;
+	}
+	interface Performance {
+		on<K extends keyof PerformanceEventMap>(
+			eventType: K,
+		): Observable<PerformanceEventMap[K]>;
+	}
+	interface PermissionStatus {
+		on<K extends keyof PermissionStatusEventMap>(
+			eventType: K,
+		): Observable<PermissionStatusEventMap[K]>;
+	}
+	interface PictureInPictureWindow {
+		on<K extends keyof PictureInPictureWindowEventMap>(
+			eventType: K,
+		): Observable<PictureInPictureWindowEventMap[K]>;
+	}
+	interface RTCDTMFSender {
+		on<K extends keyof RTCDTMFSenderEventMap>(
+			eventType: K,
+		): Observable<RTCDTMFSenderEventMap[K]>;
+	}
+	interface RTCDataChannel {
+		on<K extends keyof RTCDataChannelEventMap>(
+			eventType: K,
+		): Observable<RTCDataChannelEventMap[K]>;
+	}
+	interface RTCDtlsTransport {
+		on<K extends keyof RTCDtlsTransportEventMap>(
+			eventType: K,
+		): Observable<RTCDtlsTransportEventMap[K]>;
+	}
+	interface RTCIceTransport {
+		on<K extends keyof RTCIceTransportEventMap>(
+			eventType: K,
+		): Observable<RTCIceTransportEventMap[K]>;
+	}
+	interface RTCPeerConnection {
+		on<K extends keyof RTCPeerConnectionEventMap>(
+			eventType: K,
+		): Observable<RTCPeerConnectionEventMap[K]>;
+	}
+	interface RTCSctpTransport {
+		on<K extends keyof RTCSctpTransportEventMap>(
+			eventType: K,
+		): Observable<RTCSctpTransportEventMap[K]>;
+	}
+	interface RemotePlayback {
+		on<K extends keyof RemotePlaybackEventMap>(
+			eventType: K,
+		): Observable<RemotePlaybackEventMap[K]>;
+	}
+	interface SharedWorker {
+		on<K extends keyof AbstractWorkerEventMap>(
+			eventType: K,
+		): Observable<AbstractWorkerEventMap[K]>;
+	}
+	interface SVGElement {
+		on<K extends keyof SVGElementEventMap>(
+			eventType: K,
+		): Observable<SVGElementEventMap[K]>;
+	}
+	interface SVGSVGElement {
+		on<K extends keyof SVGSVGElementEventMap>(
+			eventType: K,
+		): Observable<SVGSVGElementEventMap[K]>;
+	}
+	interface ScreenOrientation {
+		on<K extends keyof ScreenOrientationEventMap>(
+			eventType: K,
+		): Observable<ScreenOrientationEventMap[K]>;
+	}
+	interface ScriptProcessorNode {
+		on<K extends keyof ScriptProcessorNodeEventMap>(
+			eventType: K,
+		): Observable<ScriptProcessorNodeEventMap[K]>;
+	}
+	interface ServiceWorker {
+		on<K extends keyof ServiceWorkerEventMap>(
+			eventType: K,
+		): Observable<ServiceWorkerEventMap[K]>;
+	}
+	interface ServiceWorkerContainer {
+		on<K extends keyof ServiceWorkerContainerEventMap>(
+			eventType: K,
+		): Observable<ServiceWorkerContainerEventMap[K]>;
+	}
+	interface ServiceWorkerRegistration {
+		on<K extends keyof ServiceWorkerRegistrationEventMap>(
+			eventType: K,
+		): Observable<ServiceWorkerRegistrationEventMap[K]>;
+	}
+	interface ShadowRoot {
+		on<K extends keyof ShadowRootEventMap>(
+			eventType: K,
+		): Observable<ShadowRootEventMap[K]>;
+	}
+	interface SourceBuffer {
+		on<K extends keyof SourceBufferEventMap>(
+			eventType: K,
+		): Observable<SourceBufferEventMap[K]>;
+	}
+	interface SourceBufferList {
+		on<K extends keyof SourceBufferListEventMap>(
+			eventType: K,
+		): Observable<SourceBufferListEventMap[K]>;
+	}
+	interface SpeechSynthesis {
+		on<K extends keyof SpeechSynthesisEventMap>(
+			eventType: K,
+		): Observable<SpeechSynthesisEventMap[K]>;
+	}
+	interface SpeechSynthesisUtterance {
+		on<K extends keyof SpeechSynthesisUtteranceEventMap>(
+			eventType: K,
+		): Observable<SpeechSynthesisUtteranceEventMap[K]>;
+	}
+	interface TextTrack {
+		on<K extends keyof TextTrackEventMap>(
+			eventType: K,
+		): Observable<TextTrackEventMap[K]>;
+	}
+	interface TextTrackCue {
+		on<K extends keyof TextTrackCueEventMap>(
+			eventType: K,
+		): Observable<TextTrackCueEventMap[K]>;
+	}
+	interface TextTrackList {
+		on<K extends keyof TextTrackListEventMap>(
+			eventType: K,
+		): Observable<TextTrackListEventMap[K]>;
+	}
+	interface VideoDecoder {
+		on<K extends keyof VideoDecoderEventMap>(
+			eventType: K,
+		): Observable<VideoDecoderEventMap[K]>;
+	}
+	interface VideoEncoder {
+		on<K extends keyof VideoEncoderEventMap>(
+			eventType: K,
+		): Observable<VideoEncoderEventMap[K]>;
+	}
+	interface VisualViewport {
+		on<K extends keyof VisualViewportEventMap>(
+			eventType: K,
+		): Observable<VisualViewportEventMap[K]>;
+	}
+	interface WakeLockSentinel {
+		on<K extends keyof WakeLockSentinelEventMap>(
+			eventType: K,
+		): Observable<WakeLockSentinelEventMap[K]>;
+	}
+	interface WebSocket {
+		on<K extends keyof WebSocketEventMap>(
+			eventType: K,
+		): Observable<WebSocketEventMap[K]>;
+	}
+	interface Window {
+		on<K extends keyof WindowEventMap>(
+			eventType: K,
+		): Observable<WindowEventMap[K]>;
+	}
+	interface WindowEventHandlers {
+		on<K extends keyof WindowEventHandlersEventMap>(
+			eventType: K,
+		): Observable<WindowEventHandlersEventMap[K]>;
+	}
+	interface Worker {
+		on<K extends keyof WorkerEventMap>(
+			eventType: K,
+		): Observable<WorkerEventMap[K]>;
+	}
+	interface XMLHttpRequest {
+		on<K extends keyof XMLHttpRequestEventMap>(
+			eventType: K,
+		): Observable<XMLHttpRequestEventMap[K]>;
+	}
+	interface XMLHttpRequestEventTarget {
+		on<K extends keyof XMLHttpRequestEventTargetEventMap>(
+			eventType: K,
+		): Observable<XMLHttpRequestEventTargetEventMap[K]>;
+	}
+}
+
+export {};
diff --git a/impl/observable-polyfill.js b/impl/observable-polyfill.js
new file mode 100644
index 0000000..0349ea9
--- /dev/null
+++ b/impl/observable-polyfill.js
@@ -0,0 +1,23 @@
+import { Observable } from './observable.js';
+
+function polyfill() {
+	const proto = EventTarget.prototype;
+	if (typeof proto.on !== 'function') {
+		proto.on = function (type) {
+			return new Observable((subscriber) => {
+				this.addEventListener(
+					type,
+					(event) => {
+						subscriber.next(event);
+					},
+					{ signal: subscriber.signal },
+				);
+			});
+		};
+	}
+	if (typeof globalThis.Observable !== 'function') {
+		globalThis.Observable = Observable;
+	}
+}
+
+polyfill();
diff --git a/impl/observable.d.ts b/impl/observable.d.ts
new file mode 100644
index 0000000..f67737e
--- /dev/null
+++ b/impl/observable.d.ts
@@ -0,0 +1,72 @@
+export interface Observer<T> {
+	next(value: T): void;
+	error(error: any): void;
+	complete(): void;
+}
+export interface SubscriptionOptions {
+	signal?: AbortSignal;
+}
+type ConvertableToObservable<T> =
+	| Observable<T>
+	| PromiseLike<T>
+	| Iterable<T>
+	| AsyncIterable<T>;
+export declare class Observable<T> {
+	private start;
+	static from<T>(value: ConvertableToObservable<T>): Observable<T>;
+	constructor(start: (subscriber: Subscriber<T>) => void);
+	subscribe(onNext: (value: T) => void, options?: SubscriptionOptions): void;
+	subscribe(
+		observer: Partial<Observer<T>>,
+		options?: SubscriptionOptions,
+	): void;
+	forEach(
+		callback: (value: T) => void,
+		options?: SubscriptionOptions,
+	): Promise<void>;
+	map<R>(project: (value: T, index: number) => R): Observable<R>;
+	filter(predicate: (value: T, index: number) => boolean): Observable<T>;
+	take(count: number): Observable<T>;
+	drop(count: number): Observable<T>;
+	flatMap<R>(
+		project: (value: T, index: number) => ConvertableToObservable<R>,
+	): Observable<R>;
+	takeUntil(notifier: ConvertableToObservable<unknown>): Observable<T>;
+	every(
+		predicate: (value: T, index: number) => boolean,
+		options?: SubscriptionOptions,
+	): Promise<boolean>;
+	some(
+		predicate: (value: T, index: number) => boolean,
+		options?: SubscriptionOptions,
+	): Promise<boolean>;
+	find(
+		predicate: (value: T, index: number) => boolean,
+		options?: SubscriptionOptions,
+	): Promise<T>;
+	reduce<S>(
+		reducer: (accumulated: S, value: T, index: number) => S,
+		initialValue?: S,
+		options?: SubscriptionOptions,
+	): Promise<S>;
+	toArray(options?: SubscriptionOptions): Promise<T[]>;
+	catch<R>(
+		handleError: (error: unknown) => ConvertableToObservable<R>,
+	): Observable<T | R>;
+	finally(onFinalize: () => void): Observable<T>;
+	[Symbol.asyncIterator](): AsyncGenerator<T>;
+}
+
+declare class Subscriber<T> implements Observer<T> {
+	#private;
+	private _observer;
+	get signal(): AbortSignal;
+	get isActive(): boolean;
+	constructor(signal: AbortSignal | undefined, _observer: Observer<T>);
+	next(value: T): void;
+	error(error: any): void;
+	complete(): void;
+	addTeardown(teardown: () => void): void;
+}
+
+export {};
diff --git a/impl/observable.js b/impl/observable.js
new file mode 100644
index 0000000..05c60eb
--- /dev/null
+++ b/impl/observable.js
@@ -0,0 +1,650 @@
+export class Observable {
+	static from(value) {
+		if (value instanceof Observable) {
+			return value;
+		}
+		if (isPromiseLike(value)) {
+			return new Observable((subscriber) => {
+				value.then(
+					(value) => {
+						subscriber.next(value);
+						subscriber.complete();
+					},
+					(error) => {
+						subscriber.error(error);
+					},
+				);
+			});
+		}
+		if (Symbol.asyncIterator in value) {
+			return new Observable(async (subscriber) => {
+				const iterator = value[Symbol.asyncIterator]();
+				try {
+					while (subscriber.isActive) {
+						const { value, done } = await iterator.next();
+						if (done) {
+							subscriber.complete();
+							return;
+						}
+						subscriber.next(value);
+					}
+				} catch (error) {
+					subscriber.error(error);
+				} finally {
+					iterator.return?.();
+				}
+			});
+		}
+		if (Symbol.iterator in value) {
+			return new Observable((subscriber) => {
+				const iterator = value[Symbol.iterator]();
+				try {
+					while (subscriber.isActive) {
+						const { value, done } = iterator.next();
+						if (done) {
+							subscriber.complete();
+							return;
+						}
+						subscriber.next(value);
+					}
+				} catch (error) {
+					subscriber.error(error);
+				} finally {
+					iterator.return?.();
+				}
+			});
+		}
+		throw new TypeError('Value is not observable');
+	}
+	constructor(start) {
+		this.start = start;
+	}
+	subscribe(fnOrObserver, options) {
+		const partialObserver =
+			typeof fnOrObserver === 'function'
+				? { next: fnOrObserver }
+				: fnOrObserver;
+		const observer = {
+			next: noop,
+			error: reportError,
+			complete: noop,
+			...partialObserver,
+		};
+		const subscriber = new Subscriber(options?.signal, observer);
+		this.start(subscriber);
+	}
+	forEach(callback, options) {
+		return new Promise((resolve, reject) => {
+			const ac = new AbortController();
+			const signal = options?.signal
+				? abortSignalAny([ac.signal, options.signal])
+				: ac.signal;
+			this.subscribe(
+				{
+					next: (value) => {
+						try {
+							callback(value);
+						} catch (error) {
+							reject(error);
+							ac.abort();
+						}
+					},
+					error: reject,
+					complete: resolve,
+				},
+				{
+					signal,
+				},
+			);
+		});
+	}
+	map(project) {
+		return new Observable((destination) => {
+			let index = 0;
+			this.subscribe(
+				{
+					next(value) {
+						let result;
+						try {
+							result = project(value, index++);
+						} catch (error) {
+							destination.error(error);
+							return;
+						}
+						destination.next(result);
+					},
+					error(error) {
+						destination.error(error);
+					},
+					complete() {
+						destination.complete();
+					},
+				},
+				{
+					signal: destination.signal,
+				},
+			);
+		});
+	}
+	filter(predicate) {
+		return new Observable((destination) => {
+			let index = 0;
+			this.subscribe(
+				{
+					next(value) {
+						let result = false;
+						try {
+							result = predicate(value, index++);
+						} catch (error) {
+							destination.error(error);
+							return;
+						}
+						if (result) {
+							destination.next(value);
+						}
+					},
+					error(error) {
+						destination.error(error);
+					},
+					complete() {
+						destination.complete();
+					},
+				},
+				{
+					signal: destination.signal,
+				},
+			);
+		});
+	}
+	take(count) {
+		return new Observable((destination) => {
+			let remaining = count;
+			this.subscribe(
+				{
+					next(value) {
+						remaining--;
+						if (remaining >= 0) {
+							destination.next(value);
+						}
+						if (remaining === 0) {
+							destination.complete();
+						}
+					},
+					error(error) {
+						destination.error(error);
+					},
+					complete() {
+						destination.complete();
+					},
+				},
+				{
+					signal: destination.signal,
+				},
+			);
+		});
+	}
+	drop(count) {
+		return new Observable((destination) => {
+			let seen = 0;
+			this.subscribe(
+				{
+					next(value) {
+						seen++;
+						if (seen > count) {
+							destination.next(value);
+						}
+					},
+					error(error) {
+						destination.error(error);
+					},
+					complete() {
+						destination.complete();
+					},
+				},
+				{
+					signal: destination.signal,
+				},
+			);
+		});
+	}
+	flatMap(project) {
+		return new Observable((destination) => {
+			let queue = [];
+			let index = 0;
+			let innerAC;
+			let outerComplete = false;
+			const startInner = (value) => {
+				innerAC = new AbortController();
+				const signal = abortSignalAny([innerAC.signal, destination.signal]);
+				let innerObservable;
+				try {
+					innerObservable = Observable.from(project(value, index++));
+				} catch (error) {
+					destination.error(error);
+					return;
+				}
+				innerObservable.subscribe(
+					{
+						next(innerValue) {
+							destination.next(innerValue);
+						},
+						error(error) {
+							destination.error(error);
+						},
+						complete() {
+							innerAC = undefined;
+							if (queue.length > 0) {
+								startInner(queue.shift());
+							} else if (outerComplete) {
+								destination.complete();
+							}
+						},
+					},
+					{
+						signal,
+					},
+				);
+			};
+			this.subscribe(
+				{
+					next(value) {
+						if (innerAC) {
+							queue.push(value);
+						} else {
+							startInner(value);
+						}
+					},
+					error(error) {
+						destination.error(error);
+					},
+					complete() {
+						outerComplete = true;
+						if (queue.length === 0) {
+							destination.complete();
+						}
+					},
+				},
+				{
+					signal: destination.signal,
+				},
+			);
+		});
+	}
+	takeUntil(notifier) {
+		return new Observable((destination) => {
+			Observable.from(notifier).subscribe(
+				{
+					next() {
+						destination.complete();
+					},
+					error(error) {
+						destination.error(error);
+					},
+				},
+				{
+					signal: destination.signal,
+				},
+			);
+			this.subscribe(destination, { signal: destination.signal });
+		});
+	}
+	every(predicate, options) {
+		return new Promise((resolve, reject) => {
+			const ac = new AbortController();
+			const signal = options?.signal
+				? abortSignalAny([ac.signal, options.signal])
+				: ac.signal;
+			let index = 0;
+			this.subscribe(
+				{
+					next(value) {
+						let result = false;
+						try {
+							result = predicate(value, index++);
+						} catch (error) {
+							reject(error);
+							ac.abort();
+							return;
+						}
+						if (!result) {
+							resolve(false);
+							ac.abort();
+						}
+					},
+					error: reject,
+					complete() {
+						resolve(true);
+					},
+				},
+				{
+					signal,
+				},
+			);
+		});
+	}
+	some(predicate, options) {
+		return new Promise((resolve, reject) => {
+			const ac = new AbortController();
+			const signal = options?.signal
+				? abortSignalAny([ac.signal, options.signal])
+				: ac.signal;
+			let index = 0;
+			this.subscribe(
+				{
+					next(value) {
+						let result = false;
+						try {
+							result = predicate(value, index++);
+						} catch (error) {
+							reject(error);
+							ac.abort();
+							return;
+						}
+						if (result) {
+							resolve(true);
+							ac.abort();
+						}
+					},
+					error: reject,
+					complete() {
+						resolve(false);
+					},
+				},
+				{
+					signal,
+				},
+			);
+		});
+	}
+	find(predicate, options) {
+		return new Promise((resolve, reject) => {
+			const ac = new AbortController();
+			const signal = options?.signal
+				? abortSignalAny([ac.signal, options.signal])
+				: ac.signal;
+			let index = 0;
+			this.subscribe(
+				{
+					next(value) {
+						let result = false;
+						try {
+							result = predicate(value, index++);
+						} catch (error) {
+							reject(error);
+							ac.abort();
+							return;
+						}
+						if (result) {
+							resolve(value);
+							ac.abort();
+						}
+					},
+					error: reject,
+					complete() {
+						// TODO: Figure out the proper semantics here.
+						reject(new Error('Value not found'));
+					},
+				},
+				{
+					signal,
+				},
+			);
+		});
+	}
+	reduce(reducer, initialValue, options) {
+		return new Promise((resolve, reject) => {
+			const ac = new AbortController();
+			const signal = options?.signal
+				? abortSignalAny([ac.signal, options.signal])
+				: ac.signal;
+			let hasState = arguments.length >= 2;
+			let state = initialValue;
+			let index = 0;
+			this.subscribe(
+				{
+					next(value) {
+						if (hasState) {
+							try {
+								state = reducer(state, value, index++);
+							} catch (error) {
+								reject(error);
+								ac.abort();
+								return;
+							}
+						} else {
+							state = value;
+						}
+						hasState = true;
+					},
+					error: reject,
+					complete() {
+						resolve(state);
+					},
+				},
+				{
+					signal,
+				},
+			);
+		});
+	}
+	toArray(options) {
+		return this.reduce(
+			(arr, value) => {
+				arr.push(value);
+				return arr;
+			},
+			[],
+			options,
+		);
+	}
+	catch(handleError) {
+		return new Observable((destination) => {
+			this.subscribe(
+				{
+					next(value) {
+						destination.next(value);
+					},
+					error(error) {
+						Observable.from(handleError(error)).subscribe(destination, {
+							signal: destination.signal,
+						});
+					},
+					complete() {
+						destination.complete();
+					},
+				},
+				{
+					signal: destination.signal,
+				},
+			);
+		});
+	}
+	finally(onFinalize) {
+		return new Observable((destination) => {
+			destination.addTeardown(onFinalize);
+			this.subscribe(destination, {
+				signal: destination.signal,
+			});
+		});
+	}
+	[Symbol.asyncIterator]() {
+		let ac;
+		let deferred = [];
+		let buffer = [];
+		let hasError = false;
+		let error = undefined;
+		let isComplete = false;
+		return {
+			next: () => {
+				return new Promise((resolve, reject) => {
+					if (buffer.length > 0) {
+						resolve({ value: buffer.shift(), done: false });
+						return;
+					}
+					if (hasError) {
+						reject(error);
+						return;
+					}
+					if (isComplete) {
+						resolve({ value: undefined, done: true });
+						return;
+					}
+					if (!ac) {
+						ac = new AbortController();
+						this.subscribe(
+							{
+								next(value) {
+									if (deferred.length > 0) {
+										const [resolve] = deferred.shift();
+										resolve({ value, done: false });
+									} else {
+										buffer.push(value);
+									}
+								},
+								error(err) {
+									if (buffer.length > 0) {
+										hasError = true;
+										error = err;
+									} else {
+										while (deferred.length > 0) {
+											const [, reject] = deferred.shift();
+											reject(err);
+										}
+									}
+								},
+								complete() {},
+							},
+							{
+								signal: ac.signal,
+							},
+						);
+					}
+					deferred.push([resolve, reject]);
+				});
+			},
+			throw: (err) => {
+				return new Promise((_resolve, reject) => {
+					ac?.abort();
+					hasError = true;
+					error = err;
+					for (const [, deferredReject] of deferred) {
+						deferredReject(error);
+					}
+					reject(error);
+				});
+			},
+			return: () => {
+				return new Promise((resolve) => {
+					ac?.abort();
+					isComplete = true;
+					for (const [deferredResolve] of deferred) {
+						deferredResolve({ value: undefined, done: true });
+					}
+					resolve({ value: undefined, done: true });
+				});
+			},
+			[Symbol.asyncIterator]() {
+				return this;
+			},
+		};
+	}
+}
+class Subscriber {
+	#active = true;
+	#abortController = new AbortController();
+	#signal;
+	#teardowns;
+	get signal() {
+		return this.#signal;
+	}
+	get isActive() {
+		return this.#active && !this.signal.aborted;
+	}
+	constructor(signal, _observer) {
+		this._observer = _observer;
+		const ownSignal = this.#abortController.signal;
+		this.#signal = signal ? abortSignalAny([signal, ownSignal]) : ownSignal;
+	}
+	next(value) {
+		if (this.isActive) {
+			this._observer.next(value);
+		}
+	}
+	error(error) {
+		if (this.isActive) {
+			this.#active = false;
+			this._observer.error(error);
+			this.#abortController.abort();
+		}
+	}
+	complete() {
+		if (this.isActive) {
+			this.#active = false;
+			this._observer.complete();
+			this.#abortController.abort();
+		}
+	}
+	#teardownHandler = () => {
+		const teardowns = Array.from(this.#teardowns);
+		this.#teardowns = undefined;
+		let errors;
+		for (let i = teardowns.length - 1; i >= 0; i--) {
+			try {
+				teardowns[i]();
+			} catch (error) {
+				errors ??= [];
+				errors.push(error);
+			}
+		}
+		if (errors) {
+			// TODO: We need to figure out how to report multiple errors.
+			throw new Error(
+				`${errors.length} teardowns failed.\n ${errors.join('\n')}}`,
+			);
+		}
+	};
+	addTeardown(teardown) {
+		if (this.isActive) {
+			if (!this.#teardowns) {
+				this.#teardowns = [];
+				this.#abortController.signal.addEventListener(
+					'abort',
+					this.#teardownHandler,
+					{
+						once: true,
+					},
+				);
+			}
+			this.#teardowns.push(teardown);
+		} else {
+			teardown();
+		}
+	}
+}
+function noop() {}
+
+function abortSignalAny(signals) {
+	if (typeof AbortSignal.any === 'function') {
+		return AbortSignal.any(signals);
+	} else {
+		const ac = new AbortController();
+		const handleAbort = () => {
+			ac.abort();
+			for (const signal of signals) {
+				signal.removeEventListener('abort', handleAbort);
+			}
+		};
+		for (const signal of signals) {
+			signal.addEventListener('abort', handleAbort);
+		}
+		return ac.signal;
+	}
+}
+function isPromiseLike(value) {
+	return (
+		value instanceof Promise ||
+		(typeof value === 'object' &&
+			value !== null &&
+			typeof value.then === 'function')
+	);
+}