html-video-element-webworker-polyfill 0.0.0-stage → 0.1.1

package/dist/document-GIe-DKmi.js

@@ -0,0 +1,879 @@
+import { a as isProtocolMessage, r as MEDIA_EVENTS, t as CHANNEL } from "./protocol-Be-N8xdd.js";
+import { a as isMessageEndpoint, r as assertWorker } from "./environment-De2r8LaA.js";
+import { t as FRAME_SOURCE } from "./frame-source-BG--PzqD.js";
+//#region src/worker/bridge.ts
+const MISSING_HOST_WARNING_DELAY = 3e3;
+var Bridge = class {
+	endpoint;
+	timeOffset = 0;
+	#seq = 0;
+	#nextId = 1;
+	#nextCallId = 1;
+	#receivers = /* @__PURE__ */ new Map();
+	#pinned = /* @__PURE__ */ new Set();
+	#calls = /* @__PURE__ */ new Map();
+	#canPlayType = /* @__PURE__ */ new Map();
+	#registry;
+	#welcomed = false;
+	#missingHostTimer;
+	constructor(endpoint) {
+		this.endpoint = endpoint;
+		this.#registry = typeof FinalizationRegistry === "function" ? new FinalizationRegistry(({ id, release }) => {
+			release();
+			this.#receivers.delete(id);
+			this.post({
+				kind: "dispose",
+				id
+			});
+		}) : null;
+		endpoint.addEventListener("message", this.#onMessage);
+		endpoint.start?.();
+		this.post({ kind: "hello" });
+	}
+	watchForHost() {
+		if (this.#welcomed || this.#missingHostTimer !== void 0) return;
+		this.#missingHostTimer = setTimeout(() => {
+			if (this.#welcomed) return;
+			console.warn("html-video-element-webworker-polyfill: no VideoHost answered this worker. Call createVideoHost(worker) on the main thread right after creating the worker, otherwise videos never load.");
+		}, MISSING_HOST_WARNING_DELAY);
+	}
+	nextId() {
+		return this.#nextId++;
+	}
+	post(message, transfer = []) {
+		const seq = ++this.#seq;
+		this.endpoint.postMessage({
+			...message,
+			[CHANNEL]: 1,
+			seq
+		}, transfer);
+		return seq;
+	}
+	call(message, transfer) {
+		const callId = this.#nextCallId++;
+		const promise = new Promise((resolve, reject) => this.#calls.set(callId, {
+			resolve,
+			reject
+		}));
+		return [this.post({
+			...message,
+			callId
+		}, transfer), promise];
+	}
+	register(id, element, receiver, release) {
+		this.#receivers.set(id, new WeakRef(receiver));
+		this.#registry?.register(element, {
+			id,
+			release
+		}, receiver);
+	}
+	unregister(id, receiver, element) {
+		this.#receivers.delete(id);
+		this.#registry?.unregister(receiver);
+		this.#pinned.delete(element);
+	}
+	pin(element, pinned) {
+		if (pinned) this.#pinned.add(element);
+		else this.#pinned.delete(element);
+	}
+	canPlayType(type) {
+		const cached = this.#canPlayType.get(type);
+		if (cached !== void 0) return cached;
+		const callId = this.#nextCallId++;
+		this.#calls.set(callId, {
+			resolve: (value) => this.#canPlayType.set(type, value),
+			reject: () => {}
+		});
+		this.post({
+			kind: "canPlayType",
+			type,
+			callId
+		});
+		return guessCanPlayType(type);
+	}
+	#onMessage = (event) => {
+		if (!isProtocolMessage(event.data)) return;
+		const message = event.data;
+		switch (message.kind) {
+			case "welcome":
+				this.#welcomed = true;
+				clearTimeout(this.#missingHostTimer);
+				this.timeOffset = message.timeOrigin - performance.timeOrigin;
+				for (const [type, result] of Object.entries(message.canPlayType)) this.#canPlayType.set(type, result);
+				return;
+			case "result": {
+				const call = this.#calls.get(message.callId);
+				if (!call) return;
+				this.#calls.delete(message.callId);
+				if (message.error) call.reject(new DOMException(message.error.message, message.error.name));
+				else call.resolve(message.value);
+				return;
+			}
+			default: {
+				const receiver = this.#receivers.get(message.id)?.deref();
+				if (receiver) receiver.receive(message);
+				else if ("frame" in message) message.frame?.close();
+				if (message.kind === "frame") this.post({
+					kind: "frameAck",
+					id: message.id
+				});
+			}
+		}
+	};
+};
+const CONTAINER_CODECS = {
+	"video/webm": [
+		"vp8",
+		"vp9",
+		"av01.0.05M.08"
+	],
+	"video/mp4": [
+		"avc1.42E01E",
+		"av01.0.05M.08",
+		"hvc1.1.6.L93.B0",
+		"vp09.00.10.08"
+	],
+	"audio/webm": ["opus", "vorbis"],
+	"audio/mp4": [
+		"mp4a.40.2",
+		"opus",
+		"flac"
+	]
+};
+function guessCanPlayType(type) {
+	const MediaSourceCtor = globalThis.MediaSource;
+	if (!MediaSourceCtor) return "";
+	if (/codecs\s*=/i.test(type)) return MediaSourceCtor.isTypeSupported(type) ? "probably" : "";
+	if (MediaSourceCtor.isTypeSupported(type)) return "maybe";
+	const container = type.split(";")[0].trim().toLowerCase();
+	return (CONTAINER_CODECS[container] ?? []).some((codec) => MediaSourceCtor.isTypeSupported(`${container}; codecs="${codec}"`)) ? "maybe" : "";
+}
+const bridges = /* @__PURE__ */ new WeakMap();
+let defaultEndpoint;
+function bridgeFor(endpoint) {
+	const target = endpoint ?? defaultEndpoint ?? globalThis;
+	if (!isMessageEndpoint(target)) throw new TypeError("html-video-element-webworker-polyfill: `transport` must be a MessagePort or another object with postMessage/addEventListener/removeEventListener.");
+	let bridge = bridges.get(target);
+	if (!bridge) {
+		bridge = new Bridge(target);
+		bridges.set(target, bridge);
+	}
+	return bridge;
+}
+function configureVideoTransport(endpoint) {
+	assertWorker("configureVideoTransport()");
+	if (!isMessageEndpoint(endpoint)) throw new TypeError("html-video-element-webworker-polyfill: configureVideoTransport() expects a MessagePort or another object with postMessage/addEventListener/removeEventListener.");
+	defaultEndpoint = endpoint;
+}
+//#endregion
+//#region src/worker/media-types.ts
+var WorkerTimeRanges = class {
+	#ranges;
+	constructor(ranges = []) {
+		this.#ranges = ranges;
+	}
+	get length() {
+		return this.#ranges.length;
+	}
+	start(index) {
+		return this.#at(index)[0];
+	}
+	end(index) {
+		return this.#at(index)[1];
+	}
+	#at(index) {
+		const range = this.#ranges[index];
+		if (!range) throw new DOMException(`The index provided (${index}) is greater than or equal to the maximum bound (${this.#ranges.length}).`, "IndexSizeError");
+		return range;
+	}
+};
+var WorkerMediaError = class {
+	static MEDIA_ERR_ABORTED = 1;
+	static MEDIA_ERR_NETWORK = 2;
+	static MEDIA_ERR_DECODE = 3;
+	static MEDIA_ERR_SRC_NOT_SUPPORTED = 4;
+	MEDIA_ERR_ABORTED = 1;
+	MEDIA_ERR_NETWORK = 2;
+	MEDIA_ERR_DECODE = 3;
+	MEDIA_ERR_SRC_NOT_SUPPORTED = 4;
+	code;
+	message;
+	constructor({ code, message }) {
+		this.code = code;
+		this.message = message;
+	}
+};
+//#endregion
+//#region src/worker/video-element.ts
+const EMPTY_STATE = {
+	currentSrc: "",
+	currentTime: 0,
+	duration: NaN,
+	ended: false,
+	error: null,
+	muted: false,
+	networkState: 0,
+	paused: true,
+	playbackRate: 1,
+	readyState: 0,
+	seeking: false,
+	videoHeight: 0,
+	videoWidth: 0,
+	volume: 1,
+	buffered: [],
+	played: [],
+	seekable: [],
+	quality: null
+};
+const LOAD_RESET = {
+	currentTime: 0,
+	duration: NaN,
+	ended: false,
+	error: null,
+	paused: true,
+	readyState: 0,
+	seeking: false,
+	videoHeight: 0,
+	videoWidth: 0,
+	buffered: [],
+	played: [],
+	seekable: []
+};
+const ATTRIBUTES = {
+	autoplay: {
+		prop: "autoplay",
+		type: "bool"
+	},
+	controls: {
+		prop: "controls",
+		type: "bool"
+	},
+	crossorigin: {
+		prop: "crossOrigin",
+		type: "nullable"
+	},
+	disablepictureinpicture: {
+		prop: "disablePictureInPicture",
+		type: "bool"
+	},
+	disableremoteplayback: {
+		prop: "disableRemotePlayback",
+		type: "bool"
+	},
+	height: {
+		prop: "height",
+		type: "number"
+	},
+	loop: {
+		prop: "loop",
+		type: "bool"
+	},
+	muted: {
+		prop: "defaultMuted",
+		type: "bool"
+	},
+	playsinline: {
+		prop: "playsInline",
+		type: "bool"
+	},
+	poster: {
+		prop: "poster",
+		type: "string"
+	},
+	preload: {
+		prop: "preload",
+		type: "string"
+	},
+	src: {
+		prop: "src",
+		type: "string"
+	},
+	width: {
+		prop: "width",
+		type: "number"
+	}
+};
+var Internals = class {
+	element;
+	bridge;
+	id;
+	state = { ...EMPTY_STATE };
+	props = {
+		autoplay: false,
+		controls: false,
+		crossOrigin: null,
+		defaultMuted: false,
+		defaultPlaybackRate: 1,
+		disablePictureInPicture: false,
+		disableRemotePlayback: false,
+		height: 0,
+		loop: false,
+		playsInline: false,
+		poster: "",
+		preload: "metadata",
+		preservesPitch: true,
+		width: 0
+	};
+	src = "";
+	srcObject = null;
+	hasSrcAttribute = false;
+	frame = { current: null };
+	localWrites = /* @__PURE__ */ new Map();
+	frameCallbacks = /* @__PURE__ */ new Map();
+	nextFrameCallbackId = 1;
+	handlers = /* @__PURE__ */ new Map();
+	loadSeq = 0;
+	disposed = false;
+	constructor(element, bridge) {
+		this.element = element;
+		this.bridge = bridge;
+		this.id = bridge.nextId();
+		const frame = this.frame;
+		bridge.register(this.id, element, this, () => {
+			frame.current?.close();
+			frame.current = null;
+		});
+		bridge.post({
+			kind: "create",
+			id: this.id,
+			props: {}
+		});
+	}
+	write(prop, value, local = {}, transfer) {
+		if (this.disposed) return 0;
+		const seq = this.bridge.post({
+			kind: "set",
+			id: this.id,
+			prop,
+			value
+		}, transfer);
+		this.applyLocal(seq, local);
+		return seq;
+	}
+	invoke(method, args, local = {}) {
+		if (this.disposed) return 0;
+		const seq = this.bridge.post({
+			kind: "call",
+			id: this.id,
+			method,
+			args
+		});
+		this.applyLocal(seq, local);
+		return seq;
+	}
+	markLoad(seq) {
+		if (seq) this.loadSeq = seq;
+	}
+	applyLocal(seq, local) {
+		for (const [key, value] of Object.entries(local)) {
+			this.state[key] = value;
+			this.localWrites.set(key, seq);
+		}
+		if ("readyState" in local && (local.readyState ?? 0) < 2) this.setFrame(null);
+		this.updatePin();
+	}
+	updatePin() {
+		const { paused, seeking, networkState } = this.state;
+		this.bridge.pin(this.element, !paused || seeking || networkState === 2);
+	}
+	applyState(ack, state) {
+		const target = this.state;
+		for (const [key, value] of Object.entries(state)) {
+			const pending = this.localWrites.get(key);
+			if (pending !== void 0) {
+				if (pending > ack) continue;
+				this.localWrites.delete(key);
+			}
+			target[key] = value;
+		}
+		this.updatePin();
+	}
+	setFrame(frame) {
+		if (this.frame.current === frame) return;
+		this.frame.current?.close();
+		this.frame.current = frame;
+	}
+	receive(message) {
+		if (this.disposed || message.kind !== "state" && message.ack < this.loadSeq) {
+			if ("frame" in message) message.frame?.close();
+			if (this.disposed) return;
+		}
+		this.applyState(message.ack, message.state);
+		if (message.kind !== "state" && message.ack < this.loadSeq) return;
+		switch (message.kind) {
+			case "state": return;
+			case "frame":
+				this.setFrame(message.frame);
+				this.runFrameCallbacks(message.metadata);
+				return;
+			case "event":
+				if (message.frame) this.setFrame(message.frame);
+				else if (message.type === "emptied") this.setFrame(null);
+				this.element.dispatchEvent(new Event(message.type));
+				if (message.frame && message.metadata) this.runFrameCallbacks(message.metadata);
+		}
+	}
+	runFrameCallbacks(metadata) {
+		if (this.frameCallbacks.size === 0) return;
+		const callbacks = [...this.frameCallbacks.values()];
+		this.frameCallbacks.clear();
+		const offset = this.bridge.timeOffset;
+		const local = {
+			...metadata,
+			presentationTime: metadata.presentationTime + offset,
+			expectedDisplayTime: metadata.expectedDisplayTime + offset
+		};
+		const now = performance.now();
+		for (const callback of callbacks) try {
+			callback.call(this.element, now, local);
+		} catch (error) {
+			reportError(error);
+		}
+	}
+	resolveUrl(value) {
+		if (value === "") return value;
+		const base = globalThis.location?.href;
+		try {
+			return new URL(value, base).href;
+		} catch {
+			return value;
+		}
+	}
+};
+function reportError(error) {
+	const report = globalThis.reportError;
+	if (report) report(error);
+	else setTimeout(() => {
+		throw error;
+	});
+}
+const internals = /* @__PURE__ */ new WeakMap();
+function $(element) {
+	const value = internals.get(element);
+	if (!value) throw new TypeError("Illegal invocation");
+	return value;
+}
+var WorkerVideoElement = class extends EventTarget {
+	static NETWORK_EMPTY = 0;
+	static NETWORK_IDLE = 1;
+	static NETWORK_LOADING = 2;
+	static NETWORK_NO_SOURCE = 3;
+	static HAVE_NOTHING = 0;
+	static HAVE_METADATA = 1;
+	static HAVE_CURRENT_DATA = 2;
+	static HAVE_FUTURE_DATA = 3;
+	static HAVE_ENOUGH_DATA = 4;
+	NETWORK_EMPTY = 0;
+	NETWORK_IDLE = 1;
+	NETWORK_LOADING = 2;
+	NETWORK_NO_SOURCE = 3;
+	HAVE_NOTHING = 0;
+	HAVE_METADATA = 1;
+	HAVE_CURRENT_DATA = 2;
+	HAVE_FUTURE_DATA = 3;
+	HAVE_ENOUGH_DATA = 4;
+	tagName = "VIDEO";
+	nodeName = "VIDEO";
+	localName = "video";
+	constructor(options = {}) {
+		assertWorker("createVideoElement()");
+		super();
+		const bridge = bridgeFor(options.transport);
+		bridge.watchForHost();
+		internals.set(this, new Internals(this, bridge));
+	}
+	get currentFrame() {
+		const frame = $(this).frame.current;
+		return frame && frame.format !== null ? frame : null;
+	}
+	get disposed() {
+		return $(this).disposed;
+	}
+	dispose() {
+		const core = $(this);
+		if (core.disposed) return;
+		core.bridge.post({
+			kind: "dispose",
+			id: core.id
+		});
+		core.disposed = true;
+		core.setFrame(null);
+		core.frameCallbacks.clear();
+		core.bridge.unregister(core.id, core, this);
+		core.state = { ...EMPTY_STATE };
+		core.localWrites.clear();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	get src() {
+		return $(this).src;
+	}
+	set src(value) {
+		const core = $(this);
+		core.src = core.resolveUrl(String(value));
+		core.hasSrcAttribute = true;
+		core.markLoad(core.write("src", core.src, {
+			...LOAD_RESET,
+			currentSrc: "",
+			networkState: 0
+		}));
+	}
+	get srcObject() {
+		return $(this).srcObject;
+	}
+	set srcObject(value) {
+		const core = $(this);
+		core.srcObject = value ?? null;
+		const transfer = value ? [value] : [];
+		core.markLoad(core.write("srcObject", value ?? null, {
+			...LOAD_RESET,
+			currentSrc: "",
+			networkState: 0
+		}, transfer));
+	}
+	get currentSrc() {
+		return $(this).state.currentSrc;
+	}
+	get duration() {
+		return $(this).state.duration;
+	}
+	get paused() {
+		return $(this).state.paused;
+	}
+	get ended() {
+		return $(this).state.ended;
+	}
+	get seeking() {
+		return $(this).state.seeking;
+	}
+	get readyState() {
+		return $(this).state.readyState;
+	}
+	get networkState() {
+		return $(this).state.networkState;
+	}
+	get videoWidth() {
+		return $(this).state.videoWidth;
+	}
+	get videoHeight() {
+		return $(this).state.videoHeight;
+	}
+	get error() {
+		const error = $(this).state.error;
+		return error ? new WorkerMediaError(error) : null;
+	}
+	get buffered() {
+		return new WorkerTimeRanges($(this).state.buffered);
+	}
+	get played() {
+		return new WorkerTimeRanges($(this).state.played);
+	}
+	get seekable() {
+		return new WorkerTimeRanges($(this).state.seekable);
+	}
+	get currentTime() {
+		return $(this).state.currentTime;
+	}
+	set currentTime(value) {
+		const time = Number(value);
+		if (!Number.isFinite(time)) throw new TypeError("Failed to set the 'currentTime' property: The provided double value is non-finite.");
+		const core = $(this);
+		const local = {
+			currentTime: time,
+			ended: false
+		};
+		if (core.state.readyState > 0) local.seeking = true;
+		core.write("currentTime", time, local);
+	}
+	fastSeek(time) {
+		const core = $(this);
+		const local = {
+			currentTime: time,
+			ended: false
+		};
+		if (core.state.readyState > 0) local.seeking = true;
+		core.invoke("fastSeek", [time], local);
+	}
+	get volume() {
+		return $(this).state.volume;
+	}
+	set volume(value) {
+		const volume = Number(value);
+		if (!(volume >= 0 && volume <= 1)) throw new DOMException(`Failed to set the 'volume' property: The volume provided (${value}) is outside the range [0, 1].`, "IndexSizeError");
+		$(this).write("volume", volume, { volume });
+	}
+	get muted() {
+		return $(this).state.muted;
+	}
+	set muted(value) {
+		$(this).write("muted", Boolean(value), { muted: Boolean(value) });
+	}
+	get playbackRate() {
+		return $(this).state.playbackRate;
+	}
+	set playbackRate(value) {
+		$(this).write("playbackRate", Number(value), { playbackRate: Number(value) });
+	}
+	get autoplay() {
+		return $(this).props.autoplay;
+	}
+	set autoplay(value) {
+		this.#mirror("autoplay", Boolean(value));
+	}
+	get controls() {
+		return $(this).props.controls;
+	}
+	set controls(value) {
+		this.#mirror("controls", Boolean(value));
+	}
+	get crossOrigin() {
+		return $(this).props.crossOrigin;
+	}
+	set crossOrigin(value) {
+		this.#mirror("crossOrigin", value === null ? null : String(value));
+	}
+	get defaultMuted() {
+		return $(this).props.defaultMuted;
+	}
+	set defaultMuted(value) {
+		this.#mirror("defaultMuted", Boolean(value));
+	}
+	get defaultPlaybackRate() {
+		return $(this).props.defaultPlaybackRate;
+	}
+	set defaultPlaybackRate(value) {
+		this.#mirror("defaultPlaybackRate", Number(value));
+	}
+	get disablePictureInPicture() {
+		return $(this).props.disablePictureInPicture;
+	}
+	set disablePictureInPicture(value) {
+		this.#mirror("disablePictureInPicture", Boolean(value));
+	}
+	get disableRemotePlayback() {
+		return $(this).props.disableRemotePlayback;
+	}
+	set disableRemotePlayback(value) {
+		this.#mirror("disableRemotePlayback", Boolean(value));
+	}
+	get height() {
+		return $(this).props.height;
+	}
+	set height(value) {
+		this.#mirror("height", Math.max(0, Math.trunc(Number(value))) || 0);
+	}
+	get width() {
+		return $(this).props.width;
+	}
+	set width(value) {
+		this.#mirror("width", Math.max(0, Math.trunc(Number(value))) || 0);
+	}
+	get loop() {
+		return $(this).props.loop;
+	}
+	set loop(value) {
+		this.#mirror("loop", Boolean(value));
+	}
+	get playsInline() {
+		return $(this).props.playsInline;
+	}
+	set playsInline(value) {
+		this.#mirror("playsInline", Boolean(value));
+	}
+	get poster() {
+		return $(this).props.poster;
+	}
+	set poster(value) {
+		this.#mirror("poster", $(this).resolveUrl(String(value)));
+	}
+	get preload() {
+		return $(this).props.preload;
+	}
+	set preload(value) {
+		const normalized = String(value).toLowerCase();
+		this.#mirror("preload", [
+			"none",
+			"metadata",
+			"auto"
+		].includes(normalized) ? normalized : "auto");
+	}
+	get preservesPitch() {
+		return $(this).props.preservesPitch;
+	}
+	set preservesPitch(value) {
+		this.#mirror("preservesPitch", Boolean(value));
+	}
+	#mirror(prop, value) {
+		const core = $(this);
+		core.props[prop] = value;
+		core.write(prop, value);
+	}
+	getAttribute(name) {
+		const core = $(this);
+		const attribute = ATTRIBUTES[name.toLowerCase()];
+		if (!attribute) return null;
+		if (attribute.prop === "src") return core.hasSrcAttribute ? core.src : null;
+		const value = this[attribute.prop];
+		switch (attribute.type) {
+			case "bool": return value ? "" : null;
+			case "nullable": return value === null ? null : String(value);
+			default: return String(value);
+		}
+	}
+	hasAttribute(name) {
+		return this.getAttribute(name) !== null;
+	}
+	setAttribute(name, value) {
+		const attribute = ATTRIBUTES[name.toLowerCase()];
+		if (!attribute) return;
+		const target = this;
+		switch (attribute.type) {
+			case "bool":
+				target[attribute.prop] = true;
+				break;
+			case "number":
+				target[attribute.prop] = Number.parseInt(value, 10) || 0;
+				break;
+			default: target[attribute.prop] = String(value);
+		}
+	}
+	removeAttribute(name) {
+		const attribute = ATTRIBUTES[name.toLowerCase()];
+		if (!attribute) return;
+		const core = $(this);
+		if (attribute.prop === "src") {
+			core.src = "";
+			core.hasSrcAttribute = false;
+			core.invoke("removeAttribute", ["src"]);
+			return;
+		}
+		const target = this;
+		switch (attribute.type) {
+			case "bool":
+				target[attribute.prop] = false;
+				break;
+			case "nullable":
+				target[attribute.prop] = null;
+				break;
+			case "number":
+				target[attribute.prop] = 0;
+				break;
+			default: target[attribute.prop] = attribute.prop === "preload" ? "metadata" : "";
+		}
+	}
+	play() {
+		const core = $(this);
+		if (core.disposed) return Promise.reject(new DOMException("The element has been disposed.", "InvalidStateError"));
+		const [seq, promise] = core.bridge.call({
+			kind: "call",
+			id: core.id,
+			method: "play",
+			args: []
+		});
+		core.applyLocal(seq, { paused: false });
+		return promise;
+	}
+	pause() {
+		$(this).invoke("pause", [], { paused: true });
+	}
+	load() {
+		const core = $(this);
+		core.markLoad(core.invoke("load", [], {
+			...LOAD_RESET,
+			networkState: 0
+		}));
+	}
+	canPlayType(type) {
+		return $(this).bridge.canPlayType(String(type));
+	}
+	getVideoPlaybackQuality() {
+		return $(this).state.quality ?? {
+			creationTime: performance.now(),
+			droppedVideoFrames: 0,
+			totalVideoFrames: 0
+		};
+	}
+	requestVideoFrameCallback(callback) {
+		const core = $(this);
+		const handle = core.nextFrameCallbackId++;
+		core.frameCallbacks.set(handle, callback);
+		return handle;
+	}
+	cancelVideoFrameCallback(handle) {
+		$(this).frameCallbacks.delete(handle);
+	}
+	requestPictureInPicture() {
+		return Promise.reject(new DOMException("Picture-in-Picture is not available in workers.", "NotSupportedError"));
+	}
+};
+Object.defineProperty(WorkerVideoElement.prototype, FRAME_SOURCE, {
+	configurable: true,
+	value() {
+		return this.currentFrame;
+	}
+});
+for (const type of MEDIA_EVENTS) Object.defineProperty(WorkerVideoElement.prototype, `on${type}`, {
+	configurable: true,
+	enumerable: true,
+	get() {
+		return $(this).handlers.get(type)?.handler ?? null;
+	},
+	set(handler) {
+		const core = $(this);
+		const existing = core.handlers.get(type);
+		if (typeof handler !== "function") {
+			if (existing) this.removeEventListener(type, existing.listener);
+			core.handlers.delete(type);
+			return;
+		}
+		if (existing) {
+			existing.handler = handler;
+			return;
+		}
+		const entry = {
+			handler,
+			listener: (event) => {
+				if (entry.handler?.call(this, event) === false) event.preventDefault();
+			}
+		};
+		core.handlers.set(type, entry);
+		this.addEventListener(type, entry.listener);
+	}
+});
+function createVideoElement(options) {
+	return new WorkerVideoElement(options);
+}
+//#endregion
+//#region src/worker/document.ts
+const PATCHED = Symbol.for("html-video-element-webworker-polyfill.patched");
+function polyfillDocument(options) {
+	assertWorker("polyfillDocument()");
+	const scope = globalThis;
+	scope.HTMLVideoElement ??= WorkerVideoElement;
+	scope.HTMLMediaElement ??= WorkerVideoElement;
+	scope.MediaError ??= WorkerMediaError;
+	scope.TimeRanges ??= WorkerTimeRanges;
+	const existing = scope.document;
+	if (existing && typeof existing.createElement === "function") {
+		if (existing[PATCHED]) return;
+		const original = existing.createElement.bind(existing);
+		existing.createElement = (tagName, elementOptions) => isVideo(tagName) ? new WorkerVideoElement(options) : original(tagName, elementOptions);
+		existing[PATCHED] = true;
+		return;
+	}
+	scope.document = {
+		createElement(tagName) {
+			if (isVideo(tagName)) return new WorkerVideoElement(options);
+			throw new DOMException(`document.createElement("${tagName}") is not supported in a worker; only "video" is polyfilled.`, "NotSupportedError");
+		},
+		[PATCHED]: true
+	};
+}
+function isVideo(tagName) {
+	return String(tagName).toLowerCase() === "video";
+}
+//#endregion
+export { WorkerTimeRanges as a, WorkerMediaError as i, WorkerVideoElement as n, configureVideoTransport as o, createVideoElement as r, polyfillDocument as t };
+
+//# sourceMappingURL=document-GIe-DKmi.js.map