demuxe 0.3.0-beta.3

package/web/generated/internal/wasm-player.js

@@ -0,0 +1,372 @@
+import { PlayerError } from './errors.js';
+/** One isolated software engine per player; bounded remote ranges and local File reads; ArrayBuffer inputs remain capped. */
+export class WasmPlayer extends EventTarget {
+    loading = new AbortController();
+    worker;
+    workerOwner;
+    audioContext;
+    audioNode;
+    analyser;
+    gainNode;
+    gainValue = 1;
+    timing;
+    lastTiming;
+    nextId = 100;
+    pending = new Map();
+    destroyed = false;
+    destruction;
+    onDestroyed;
+    readyTimer;
+    rejectReady;
+    eventWaiters = new Set();
+    hasFile = false;
+    opening = false;
+    refreshAuthorization;
+    audioHeader;
+    outputChannels;
+    requestedOutput;
+    deviceChannels;
+    diagnostics;
+    browserCodecsAbsent = false;
+    properties = new Map();
+    ready;
+    constructor(canvas, { disableBrowserCodecs = false, measureOutput = false, mode = 'software', softwarePresenter = 'rgb', audioOutput = 'stereo', audioFallback = 'stereo', resourceLimits = {}, fonts = [], assetBase = new URL('../../../', import.meta.url) } = {}) {
+        super();
+        const decoder = mode === 'hybrid' ? 'webcodecs' : 'software';
+        if (!crossOriginIsolated)
+            throw new Error('This player requires a secure, cross-origin isolated page.');
+        this.audioContext = new AudioContext({ latencyHint: 'interactive' });
+        this.requestedOutput = audioOutput;
+        this.deviceChannels = this.audioContext.destination.maxChannelCount;
+        const wanted = audioOutput === 'auto' ? (this.deviceChannels >= 8 ? 8 : this.deviceChannels >= 6 ? 6 : 2) : audioOutput === '7.1' ? 8 : audioOutput === '5.1' ? 6 : 2;
+        if (wanted > this.deviceChannels && audioFallback === 'reject') {
+            void this.audioContext.close();
+            throw Error('Requested audio layout is unavailable on this output device');
+        }
+        this.outputChannels = wanted <= this.deviceChannels ? wanted : 2;
+        try {
+            this.audioContext.destination.channelCount = this.outputChannels;
+        }
+        catch (error) {
+            void this.audioContext.close();
+            throw error;
+        }
+        this.audioContext.destination.channelCountMode = 'explicit';
+        // A disposable same-origin owner gives the browser a complete worker-tree
+        // teardown boundary, including native pthread workers and decoder resources.
+        this.workerOwner = canvas.ownerDocument.createElement('iframe');
+        this.workerOwner.hidden = true;
+        this.workerOwner.setAttribute('aria-hidden', 'true');
+        canvas.ownerDocument.body.append(this.workerOwner);
+        const owner = this.workerOwner.contentWindow;
+        try {
+            this.worker = new owner.Worker(new URL(mode === 'hybrid' ? 'web/filter-retained-engine-worker.js?mode=retained' : 'web/software-full-engine-worker.js', assetBase), { type: 'module' });
+        }
+        catch (error) {
+            this.workerOwner.remove();
+            void this.audioContext.close();
+            throw error;
+        }
+        const audio = new SharedArrayBuffer(64 + 8192 * this.outputChannels * 4);
+        this.audioHeader = new Int32Array(audio, 0, 16);
+        this.ready = new Promise((resolve, reject) => {
+            this.rejectReady = reject;
+            const timeout = this.readyTimer = setTimeout(() => reject(new Error('Player initialization timed out')), 60000);
+            this.worker.onerror = event => { clearTimeout(timeout); reject(new PlayerError('ASSET_LOAD_FAILED', 'Playback engine initialization failed: ' + event.message, null, null, 'operation', true)); this.fail(new Error(event.message)); };
+            this.worker.onmessage = ({ data }) => {
+                if (data.type === 'ready') {
+                    clearTimeout(timeout);
+                    this.browserCodecsAbsent = data.browserCodecsAbsent;
+                    this.sendTiming(true);
+                    resolve();
+                }
+                else if (data.type === 'error') {
+                    clearTimeout(timeout);
+                    const error = new Error(data.message);
+                    reject(new PlayerError('ASSET_LOAD_FAILED', 'Playback engine initialization failed: ' + error.message, null, null, 'operation', true));
+                    this.fail(error, data.id);
+                }
+                else if (data.type === 'destroyed') {
+                    if (this.diagnostics) {
+                        this.diagnostics.decoderStats = data.decoderStats;
+                        if (data.presentation)
+                            this.diagnostics.presentation = data.presentation;
+                    }
+                    this.onDestroyed?.();
+                }
+                else if (data.type === 'refresh') {
+                    void this.refreshAuthorization?.(data.resource).then(update => { if (!this.destroyed)
+                        this.worker.postMessage({ type: 'refreshed', id: data.id, update }); }, () => { if (!this.destroyed)
+                        this.worker.postMessage({ type: 'refreshed', id: data.id, error: true }); });
+                }
+                else if (data.type === 'output')
+                    this.dispatchEvent(new CustomEvent('output', { detail: data.data }));
+                else if (data.type === 'source')
+                    this.dispatchEvent(new CustomEvent('source', { detail: data.info }));
+                else if (data.type === 'diagnostics')
+                    this.diagnostics = data.data;
+                else if (data.type === 'log')
+                    this.dispatchEvent(new CustomEvent('log', { detail: data.message }));
+                else if (data.type === 'event') {
+                    const event = data.event;
+                    if (event.event === 'start-file')
+                        this.hasFile = true;
+                    if (event.event === 'end-file')
+                        this.hasFile = false;
+                    if (event.event === 'property-change' && event.name === 'track-list' && Array.isArray(event.data))
+                        event.data = event.data.map(track => ({ ...track, id: String(track.id) }));
+                    if (event.event === 'command-reply' && event.id) {
+                        const pending = this.pending.get(event.id);
+                        if (pending) {
+                            clearTimeout(pending.timer);
+                            this.pending.delete(event.id);
+                            event.error ? pending.reject(new Error(event.error)) : pending.resolve(event.result);
+                        }
+                    }
+                    if (event.event === 'property-change' && event.name === 'track-list' && Array.isArray(event.data)) {
+                        let external = 0;
+                        event.data = event.data.map(t => t.external ? { ...t, 'external-index': ++external } : t);
+                    }
+                    if (event.event === 'property-change' && event.name)
+                        this.properties.set(event.name, event.data);
+                    this.dispatchEvent(new CustomEvent('mpv', { detail: event }));
+                }
+            };
+            void (async () => {
+                await this.audioContext.audioWorklet.addModule(new URL('web/audio-worklet.js', assetBase));
+                if (this.destroyed)
+                    throw new Error('Player destroyed during initialization');
+                this.audioNode = new AudioWorkletNode(this.audioContext, 'demuxe-pcm', { numberOfInputs: 0, numberOfOutputs: 1, outputChannelCount: [this.outputChannels], channelCount: this.outputChannels, channelCountMode: 'explicit', processorOptions: { buffer: audio, capacity: 8192, channels: this.outputChannels, measureOutput } });
+                this.audioNode.port.onmessage = ({ data }) => { const stamp = this.audioContext.getOutputTimestamp(); const wallTime = stamp.performanceTime !== undefined && stamp.contextTime !== undefined ? performance.timeOrigin + stamp.performanceTime + (data.audioFrame / data.sampleRate - stamp.contextTime) * 1000 : null; this.dispatchEvent(new CustomEvent('output', { detail: { ...data, wallTime, stamp } })); };
+                this.analyser = this.audioContext.createAnalyser();
+                this.audioNode.connect(this.analyser);
+                this.audioNode.connect(this.audioContext.destination);
+                const response = await fetch(new URL('fixtures/DejaVuSans.ttf', assetBase), { signal: this.loading.signal });
+                if (!response.ok)
+                    throw new Error('Could not load the bundled subtitle font');
+                const font = await response.arrayBuffer();
+                if (this.destroyed)
+                    throw new Error('Player destroyed during initialization');
+                const offscreen = canvas.transferControlToOffscreen();
+                this.worker.postMessage({ type: 'init', canvas: offscreen, audio, font, fonts, audioChannels: this.outputChannels, maxDecodePixels: resourceLimits.maxDecodePixels, maxAllocationBytes: resourceLimits.maxAllocationBytes, sampleRate: this.audioContext.sampleRate, disableBrowserCodecs, measureOutput, decoder, softwarePresenter, decoderFaultAfter: 0 }, [offscreen, font]);
+                this.timing = setInterval(() => this.sendTiming(), 20);
+                this.sendTiming();
+            })().catch(error => { clearTimeout(timeout); reject(new PlayerError('ASSET_LOAD_FAILED', 'Playback engine initialization failed: ' + String(error), null, null, 'operation', true)); });
+        });
+    }
+    sendTiming(force = false) {
+        if (this.destroyed)
+            return;
+        // Fallback latency estimate, explicitly not an independent A/V sync measurement.
+        const latency = (this.audioContext.baseLatency || 0) + (this.audioContext.outputLatency || 0);
+        const latencyUs = Math.round(latency * 1e6), running = this.audioContext.state === 'running';
+        if (!force && this.lastTiming?.latencyUs === latencyUs && this.lastTiming.running === running)
+            return;
+        this.lastTiming = { latencyUs, running };
+        this.worker.postMessage({ type: 'timing', latencyUs, running });
+    }
+    fail(error, id, report = true) {
+        for (const [key, p] of this.pending)
+            if (!id || key === id) {
+                clearTimeout(p.timer);
+                p.reject(error);
+                this.pending.delete(key);
+            }
+        if (report)
+            for (const cancel of this.eventWaiters)
+                cancel(error);
+        if (report)
+            this.dispatchEvent(new CustomEvent('error', { detail: error.message }));
+    }
+    request(message, transfer = []) {
+        if (this.destroyed)
+            return Promise.reject(new Error('Player is destroyed'));
+        if (this.pending.size >= 128)
+            return Promise.reject(new Error('Command queue is full'));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error('Command timed out')); }, 15000);
+            this.pending.set(id, { resolve, reject, timer });
+            this.worker.postMessage({ ...message, id }, transfer);
+        });
+    }
+    async open(file, options = {}) {
+        if (this.destroyed)
+            throw new Error('Player is destroyed');
+        if (this.opening)
+            throw new Error('Another open is in progress');
+        this.opening = true;
+        try {
+            await this.openLocal(file, options);
+        }
+        finally {
+            this.opening = false;
+        }
+    }
+    async openRemote(source) {
+        if (this.destroyed)
+            throw new Error('Player is destroyed');
+        if (this.opening)
+            throw new Error('Another open is in progress');
+        this.opening = true;
+        try {
+            await this.ready;
+            if (this.hasFile)
+                await Promise.all([this.waitForEvent(e => e.event === 'end-file'), this.command('stop')]);
+            else
+                await this.command('stop');
+            if (source.demuxer && !/^[a-z0-9_]{1,64}$/.test(source.demuxer))
+                throw Error('Invalid demuxer hint');
+            await this.command('set', 'demuxer-lavf-format', source.demuxer ?? '');
+            const { refreshAuthorization, ...options } = source;
+            this.refreshAuthorization = refreshAuthorization;
+            const loaded = this.waitForEvent(e => e.event === 'file-loaded' || (e.event === 'end-file' && e.reason === 'error' ? new Error(String(e.file_error)) : false));
+            await Promise.all([loaded, this.request({ type: 'open-remote', options, canRefresh: !!refreshAuthorization })]);
+        }
+        finally {
+            this.opening = false;
+        }
+    }
+    waitForEvent(predicate) {
+        return new Promise((resolve, reject) => {
+            const finish = (error) => { clearTimeout(timeout); this.removeEventListener('mpv', listener); this.eventWaiters.delete(cancel); error ? reject(error) : resolve(); };
+            const cancel = (error) => finish(error);
+            const listener = (event) => { const result = predicate(event.detail); if (result)
+                finish(result instanceof Error ? result : undefined); };
+            const timeout = setTimeout(() => finish(new Error('Media operation timed out')), 25000);
+            this.eventWaiters.add(cancel);
+            this.addEventListener('mpv', listener);
+        });
+    }
+    async openLocal(file, options) {
+        await this.ready;
+        const size = file instanceof File ? file.size : file.byteLength;
+        if (!(file instanceof File) && size > 32 * 1024 * 1024)
+            throw new Error('ArrayBuffer sources are limited to 32 MiB');
+        if (this.hasFile)
+            await Promise.all([this.waitForEvent(event => event.event === 'end-file'), this.command('stop')]);
+        else
+            await this.command('stop');
+        const suffix = file instanceof File ? file.name.split('.').at(-1)?.toLowerCase() : undefined;
+        const demuxer = options.demuxer ?? (suffix === 'sbc' || suffix === 'msbc' ? 'sbc' : '');
+        if (demuxer && !/^[a-z0-9_]{1,64}$/.test(demuxer))
+            throw Error('Invalid demuxer hint');
+        await this.command('set', 'demuxer-lavf-format', demuxer);
+        const loaded = this.waitForEvent(event => event.event === 'file-loaded' || (event.event === 'end-file' && event.reason === 'error' ? new Error(String(event.file_error)) : false));
+        if (file instanceof File)
+            await Promise.all([loaded, this.request({ type: 'open-file', file })]);
+        else {
+            const bytes = file.slice(0);
+            await Promise.all([loaded, this.request({ type: 'open', bytes }, [bytes])]);
+        }
+    }
+    async inspectMetadata() {
+        const value = await this.request({ type: 'command', args: ['expand-text', '${seekable}'] });
+        if (value === 'yes' || value === 'no')
+            this.properties.set('seekable', value === 'yes');
+    }
+    async command(...args) { await this.ready; return this.request({ type: 'command', args }); }
+    async setPause(paused) {
+        if (this.properties.get('pause') === paused) {
+            await this.command('set', 'pause', paused ? 'yes' : 'no');
+            return;
+        }
+        await Promise.all([this.waitForEvent(e => e.event === 'property-change' && e.name === 'pause' && e.data === paused), this.command('set', 'pause', paused ? 'yes' : 'no')]);
+    }
+    async play() {
+        const resume = this.audioContext.resume();
+        void resume.catch(() => { });
+        if (this.audioContext.state === 'suspended' && !navigator.userActivation?.isActive)
+            throw new DOMException('Playback needs a user gesture', 'NotAllowedError');
+        await resume;
+        this.sendTiming();
+        await this.setPause(false);
+    }
+    pause() { return this.setPause(true); }
+    seek(seconds) { if (!Number.isFinite(seconds) || seconds < 0)
+        throw new Error('Invalid seek time'); Atomics.store(this.audioHeader, 2, 0); return this.ready.then(() => this.request({ type: 'seek', seconds })); }
+    rate(rate) { if (!Number.isFinite(rate) || rate < 0.5 || rate > 2)
+        throw new Error('Playback rate must be 0.5 to 2'); return this.command('set', 'speed', String(rate)); }
+    volume(percent) { if (!Number.isFinite(percent) || percent < 0 || percent > 100)
+        throw new Error('Invalid volume'); return this.command('set', 'volume', String(percent)); }
+    async gain(value) {
+        if (!Number.isFinite(value) || value < 0 || value > 1)
+            throw new Error('Gain must be between 0 and 1');
+        await this.ready;
+        if (this.destroyed)
+            throw new Error('Player is destroyed');
+        if (!this.gainNode && value !== 1) {
+            const gain = this.audioContext.createGain();
+            gain.channelCount = this.outputChannels;
+            gain.channelCountMode = 'explicit';
+            gain.channelInterpretation = 'discrete';
+            gain.gain.setValueAtTime(value, this.audioContext.currentTime);
+            this.audioNode.disconnect();
+            this.audioNode.connect(gain);
+            gain.connect(this.audioContext.destination);
+            gain.connect(this.analyser);
+            this.gainNode = gain;
+        }
+        this.gainNode?.gain.setValueAtTime(value, this.audioContext.currentTime);
+        this.gainValue = value;
+    }
+    selectTrack(type, id) {
+        if (!['audio', 'sub'].includes(type) || !/^(?:[1-9][0-9]*|auto|no)$/.test(id))
+            throw new Error('Invalid track selection');
+        return this.command('set', type === 'audio' ? 'aid' : 'sid', id);
+    }
+    async addSubtitle(subtitle) {
+        await this.ready;
+        const bytes = subtitle.bytes.slice(0);
+        const previous = (this.properties.get('track-list') ?? []).filter(t => t.external).length;
+        // Command acceptance can precede the track-list event. Selection must wait
+        // for the new source-scoped external identity to become observable.
+        const listed = this.waitForEvent(e => e.event === 'property-change' && e.name === 'track-list' && Array.isArray(e.data) && e.data.filter(t => t.external).length > previous);
+        await Promise.all([listed, this.request({ type: 'subtitle', ...subtitle, bytes }, [bytes])]);
+    }
+    subtitleVisible(visible) { return this.command('set', 'sub-visibility', visible ? 'yes' : 'no'); }
+    resize(width, height) { if (this.destroyed)
+        throw new Error('Player is destroyed'); if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width > 1920 || height > 1080)
+        throw new Error('Invalid output dimensions'); this.worker.postMessage({ type: 'resize', width, height }); }
+    audioDiagnostics() {
+        const samples = new Float32Array(this.analyser?.fftSize || 2048);
+        this.analyser?.getFloatTimeDomainData(samples);
+        return { gain: this.gainValue, gainStage: this.gainNode ? 'web-audio' : 'none', requestedOutput: this.requestedOutput, outputChannels: this.outputChannels, deviceChannels: this.deviceChannels, channelLayout: this.outputChannels === 8 ? '7.1' : this.outputChannels === 6 ? '5.1' : 'stereo', state: this.audioContext.state, sampleRate: this.audioContext.sampleRate, mediaFrames: Atomics.load(this.audioHeader, 5), underruns: Atomics.load(this.audioHeader, 6), rms: Math.sqrt(samples.reduce((sum, v) => sum + v * v, 0) / samples.length), latencyConfidence: 'reported-latency estimate' };
+    }
+    destroy() {
+        if (this.destruction)
+            return this.destruction;
+        this.destroyed = true;
+        this.loading.abort();
+        this.refreshAuthorization = undefined;
+        clearTimeout(this.readyTimer);
+        this.rejectReady?.(new Error('Player destroyed'));
+        for (const cancel of this.eventWaiters)
+            cancel(new Error('Player destroyed'));
+        this.fail(new Error('Player destroyed'), undefined, false);
+        clearInterval(this.timing);
+        Atomics.store(this.audioHeader, 2, 0);
+        this.audioNode?.port.postMessage('close');
+        this.audioNode?.disconnect();
+        this.audioNode?.port.close();
+        this.analyser?.disconnect();
+        this.gainNode?.disconnect();
+        this.destruction = (async () => {
+            let timeout;
+            try {
+                await new Promise((resolve, reject) => {
+                    this.onDestroyed = resolve;
+                    timeout = setTimeout(() => reject(new Error('Native cleanup timed out; worker containment applied')), 10000);
+                    this.worker.postMessage({ type: 'destroy' });
+                });
+            }
+            finally {
+                clearTimeout(timeout);
+                this.worker.terminate();
+                this.workerOwner.remove();
+                await this.audioContext.close();
+            }
+        })();
+        return this.destruction;
+    }
+}

package/web/generated/player/index.d.ts

@@ -0,0 +1,198 @@
+import { Player } from '../unified-player.js';
+import type { MediaSourceInput, OpenOptions, SubtitleOptions } from '../types.js';
+declare const Base: typeof HTMLElement;
+export declare const defaultLabels: Readonly<{
+    diagnostics: "Session diagnostics";
+    moreOptions: "More options";
+    back: "Seek backward 10 seconds";
+    forward: "Seek forward 10 seconds";
+    play: "Play";
+    pause: "Pause";
+    mute: "Mute";
+    unmute: "Unmute";
+    seek: "Playback position";
+    volume: "Volume";
+    settings: "Playback settings";
+    closeSettings: "Close settings";
+    speed: "Playback speed";
+    audio: "Audio";
+    subtitles: "Subtitles";
+    automatic: "Automatic";
+    off: "Off";
+    fullscreen: "Fullscreen";
+    exitFullscreen: "Exit fullscreen";
+    open: "Open media";
+    addSubtitle: "Add subtitles";
+    empty: "Something good to watch?";
+    drop: "Open a video or audio file from your device.";
+    loading: "Opening media…";
+    switching: "Updating playback…";
+    seeking: "Seeking…";
+    buffering: "Buffering…";
+    live: "LIVE";
+    unknown: "Unknown duration";
+    retry: "Retry";
+    resume: "Press Play to continue";
+    shortcuts: "K / Space: play · ← → / J L: seek · ↑ ↓: volume · M: mute · C: subtitles · [ ]: speed · 0–9 / Home / End: position · F: fullscreen";
+    noFullscreen: "Fullscreen is unavailable here. Open this page in a browser tab.";
+    noWindow: "Live playback · seek window unavailable";
+    openURL: "Open URL";
+    closeMedia: "Close media";
+    url: "Media URL";
+    format: "Source format";
+    streamLive: "Live stream";
+    addFiles: "Add files";
+    queue: "Queue";
+    clearQueue: "Clear queue";
+    previous: "Previous file";
+    next: "Next file";
+    remove: "Remove";
+    unnamed: "Unnamed media";
+    mediaFile: "Media file";
+    noMedia: "No media loaded";
+    loadedMedia: "Media loaded";
+    subtitleFile: "Subtitle file";
+}>;
+export type PlayerLabels = Partial<Record<keyof typeof defaultLabels, string>>;
+export type PlayerTitleMode = 'auto' | 'custom' | 'source' | 'none';
+export declare class DemuxePlayerElement extends Base {
+    static observedAttributes: string[];
+    private core?;
+    private queueItems;
+    private queueIndex;
+    private queueOperation?;
+    private queuePlayIntent?;
+    private queueSourceId;
+    private queueEndedId;
+    private queueSignature;
+    private queueRevision;
+    private queueRenderSignature;
+    private queueItem;
+    private resetQueue;
+    private activateQueue;
+    private addFiles;
+    private selectQueue;
+    private removeQueueItem;
+    private advanceQueue;
+    private renderQueue;
+    private sourceName;
+    private sourceNameId;
+    private sourceControls;
+    private diagnosticsControl;
+    private fileDrop;
+    private seekSeconds;
+    private autoHideDelay;
+    get titleMode(): PlayerTitleMode;
+    set titleMode(value: PlayerTitleMode);
+    get showSourceControls(): boolean;
+    set showSourceControls(value: boolean);
+    get showDiagnostics(): boolean;
+    set showDiagnostics(value: boolean);
+    get allowFileDrop(): boolean;
+    set allowFileDrop(value: boolean);
+    get seekStep(): number;
+    set seekStep(value: number);
+    get controlsAutoHideDelay(): number;
+    set controlsAutoHideDelay(value: number);
+    private updateTitle;
+    private updateSourceLabel;
+    private updateUtilities;
+    private terminal;
+    private cleanup;
+    private connecting?;
+    private connection;
+    private unsubscribe?;
+    private sourceAbort?;
+    private sourceVersion;
+    private lastSource?;
+    private lastOptions?;
+    private resolveReady;
+    private rejectReady;
+    private readiness;
+    private overrides;
+    private menuTrigger;
+    private seekPreviewTimer?;
+    private hideTimer?;
+    private revealControls;
+    private playFromControls;
+    private hideControls;
+    private dismissMenu;
+    private stageWasIdle;
+    private isScreenPress;
+    private wasSeeking;
+    private diagnosticsUpdated;
+    private dragging;
+    private dimensions;
+    private trackSignature;
+    private reflected;
+    private attributeScheduled;
+    private configuredAsset;
+    private resizeObserver?;
+    private lastAnnouncement;
+    private lastFailure?;
+    private fullscreenChanged;
+    constructor();
+    private newReady;
+    get ready(): Promise<Player>;
+    get player(): Player | undefined;
+    get src(): string;
+    set src(value: string);
+    get controls(): boolean;
+    set controls(value: boolean);
+    get autoplay(): boolean;
+    set autoplay(value: boolean);
+    get muted(): boolean;
+    set muted(value: boolean);
+    get poster(): string;
+    set poster(value: string);
+    get assetBase(): string | undefined;
+    set assetBase(value: string | undefined);
+    get labels(): Record<keyof typeof defaultLabels, string>;
+    set labels(value: PlayerLabels);
+    private $;
+    private input;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private openFromControls;
+    private scheduleSource;
+    private waitReady;
+    open(source: MediaSourceInput, options?: OpenOptions): Promise<void>;
+    private openSource;
+    close(): Promise<void>;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    seek(seconds: number): Promise<void>;
+    setVolume(value: number): Promise<void>;
+    setMuted(value: boolean): Promise<void>;
+    setPlaybackRate(value: number): Promise<void>;
+    selectAudioTrack(id: string | null): Promise<void>;
+    selectSubtitleTrack(id: string | null): Promise<void>;
+    addSubtitle(file: File, options?: SubtitleOptions): Promise<void>;
+    destroy(): Promise<void>;
+    private run;
+    private componentError;
+    private showError;
+    private clearError;
+    private announce;
+    private geometry;
+    private update;
+    private setDiagnostics;
+    private updateDiagnostics;
+    private bufferedProgress;
+    private timelineProgress;
+    private skip;
+    private trackOptions;
+    private settings;
+    private fullscreen;
+    private iconButton;
+    private labelControls;
+    private renderShell;
+}
+export declare function definePlayerElement(name?: string): typeof DemuxePlayerElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'demuxe-player': DemuxePlayerElement;
+    }
+}
+export {};