@chunkify/analytics 0.1.0

package/dist/core.js

@@ -0,0 +1,660 @@
+import { analyticsEventTypes } from "./event-types.js";
+import { assertAnalyticsOptions } from "./options.js";
+const sdkVersion = "0.1.0"; // x-release-please-version
+function finiteNonNegative(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function nonNegativeDelta(current, baseline) {
+    return current === null || baseline === null ? null : finiteNonNegative(current - baseline);
+}
+function finitePositive(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function intrinsicVideoSize(media) {
+    try {
+        const customMedia = media;
+        const video = (customMedia.nativeEl?.localName === "video" ? customMedia.nativeEl : media);
+        const width = finitePositive(video.videoWidth);
+        const height = finitePositive(video.videoHeight);
+        return width !== null && height !== null ? { width, height } : { width: null, height: null };
+    }
+    catch {
+        return { width: null, height: null };
+    }
+}
+function normalizedRendition(rendition) {
+    if (!rendition)
+        return null;
+    const result = {
+        width: finiteNonNegative(rendition.width),
+        height: finiteNonNegative(rendition.height),
+        codec: typeof rendition.codec === "string" && rendition.codec ? rendition.codec : null,
+        bitrate_bps: finiteNonNegative(rendition.bitrate_bps),
+        frame_rate: finiteNonNegative(rendition.frame_rate),
+    };
+    return Object.values(result).every((value) => value === null) ? null : result;
+}
+function renditionKey(rendition) {
+    return JSON.stringify([rendition.width, rendition.height, rendition.codec, rendition.bitrate_bps, rendition.frame_rate]);
+}
+function renditionPlayingTime(current, now) {
+    if (!current.renditionTrackingAvailable)
+        return null;
+    const times = new Map([...current.renditionTimes].map(([key, value]) => [key, { ...value }]));
+    if (current.activeRendition && current.activeRenditionSince !== null) {
+        const key = renditionKey(current.activeRendition);
+        const entry = times.get(key) ?? { ...current.activeRendition, playing_time_ms: 0 };
+        entry.playing_time_ms += Math.max(0, now - current.activeRenditionSince);
+        times.set(key, entry);
+    }
+    return [...times.values()];
+}
+const emptyConnectorMetrics = {
+    selected_rendition_width: null,
+    selected_rendition_height: null,
+    selected_rendition_codec: null,
+    selected_rendition_bitrate_bps: null,
+    rendition_switch_count: null,
+    delivery_request_count: null,
+    delivery_transferred_bytes: null,
+    delivery_throughput_bps: null,
+};
+function connectorMetrics(connector, baseline) {
+    if (!connector || !baseline)
+        return { ...emptyConnectorMetrics };
+    let current;
+    try {
+        current = connector.snapshot();
+    }
+    catch {
+        return { ...emptyConnectorMetrics };
+    }
+    const switches = nonNegativeDelta(current.renditionSwitchCount, baseline.renditionSwitchCount);
+    const requests = nonNegativeDelta(current.deliveryRequestCount, baseline.deliveryRequestCount);
+    const bytes = nonNegativeDelta(current.deliveryTransferredBytes, baseline.deliveryTransferredBytes);
+    const deliveryDuration = nonNegativeDelta(current.deliveryDurationMs, baseline.deliveryDurationMs);
+    return {
+        selected_rendition_width: finiteNonNegative(current.renditionWidth),
+        selected_rendition_height: finiteNonNegative(current.renditionHeight),
+        selected_rendition_codec: typeof current.renditionCodec === "string" && current.renditionCodec ? current.renditionCodec : null,
+        selected_rendition_bitrate_bps: finiteNonNegative(current.renditionBitrate),
+        rendition_switch_count: switches,
+        delivery_request_count: requests,
+        delivery_transferred_bytes: bytes,
+        delivery_throughput_bps: bytes !== null && deliveryDuration !== null && deliveryDuration > 0
+            ? bytes * 8 * 1000 / deliveryDuration : null,
+    };
+}
+function deliveryHostname(media) {
+    try {
+        const url = new URL(media.currentSrc || media.src);
+        return url.protocol === "http:" || url.protocol === "https:" ? url.hostname : null;
+    }
+    catch {
+        return null;
+    }
+}
+function duration(media) {
+    return Number.isFinite(media.duration) && media.duration >= 0 ? media.duration : null;
+}
+function mediaErrorCategory(code) {
+    return code === 1 ? "aborted" : code === 2 ? "network" : code === 3 ? "decode"
+        : code === 4 ? "unsupported" : "unknown";
+}
+function frameCounts(media) {
+    const video = media;
+    if (typeof video.getVideoPlaybackQuality === "function") {
+        try {
+            const quality = video.getVideoPlaybackQuality();
+            if (Number.isInteger(quality.droppedVideoFrames) && quality.droppedVideoFrames >= 0 &&
+                Number.isInteger(quality.totalVideoFrames) && quality.totalVideoFrames >= 0) {
+                return { dropped: quality.droppedVideoFrames, total: quality.totalVideoFrames };
+            }
+        }
+        catch {
+            // Treat an inaccessible browser counter like an unavailable measurement.
+        }
+    }
+    const webkit = media;
+    if (!Number.isInteger(webkit.webkitDecodedFrameCount) || (webkit.webkitDecodedFrameCount ?? -1) < 0 ||
+        !Number.isInteger(webkit.webkitDroppedFrameCount) || (webkit.webkitDroppedFrameCount ?? -1) < 0)
+        return null;
+    return { dropped: webkit.webkitDroppedFrameCount, total: webkit.webkitDecodedFrameCount };
+}
+export function attachAnalytics(media, options) {
+    return createAnalyticsSession(media, options, false);
+}
+/** Engine adapters call this when they own source-change events. */
+export function attachAnalyticsWithManagedSource(media, options) {
+    return createAnalyticsSession(media, options, true);
+}
+function createAnalyticsSession(media, options, sourceManagedByEngine) {
+    assertAnalyticsOptions(options);
+    const frameVideo = media;
+    const { videoId, environment = null, viewerId = null, snapshotIntervalMs = 30000 } = options;
+    const destinations = [...options.destinations];
+    const includedEvents = new Set((options.includeEvents ?? analyticsEventTypes)
+        .map((event) => `chunkify.video.${event}`));
+    let view = null;
+    let destroyed = false;
+    let wantsPlay = false;
+    let seeking = false;
+    let snapshotTimer = null;
+    let connector = null;
+    let unsubscribeConnector = null;
+    let unsubscribeRenditions = null;
+    let selectedRendition = null;
+    function refreshIntrinsicVideoSize(current) {
+        const size = intrinsicVideoSize(media);
+        if (size.width === null || size.height === null)
+            return;
+        current.intrinsicVideoWidth = size.width;
+        current.intrinsicVideoHeight = size.height;
+    }
+    function cancelFirstVideoFrame(current) {
+        if (current.frameCallbackId === null)
+            return;
+        const callbackId = current.frameCallbackId;
+        current.frameCallbackId = null;
+        try {
+            frameVideo.cancelVideoFrameCallback?.(callbackId);
+        }
+        catch { }
+    }
+    function observeFirstVideoFrame(current) {
+        if (typeof frameVideo.requestVideoFrameCallback !== "function" ||
+            typeof frameVideo.cancelVideoFrameCallback !== "function")
+            return;
+        try {
+            current.frameCallbackId = frameVideo.requestVideoFrameCallback((observedAt) => {
+                if (current.frameCallbackId === null)
+                    return;
+                current.frameCallbackId = null;
+                if (view !== current)
+                    return;
+                // WebKit can report a presentationTime outside performance.now()'s clock.
+                if (!Number.isFinite(observedAt) || observedAt < current.startedAt)
+                    return;
+                current.firstVideoFrame = observedAt - current.startedAt;
+            });
+        }
+        catch {
+            // Frame timing is optional; an inaccessible browser API leaves it unavailable.
+        }
+    }
+    function closeActiveRendition(now) {
+        if (!view || !view.activeRendition || view.activeRenditionSince === null)
+            return;
+        const key = renditionKey(view.activeRendition);
+        const entry = view.renditionTimes.get(key) ?? { ...view.activeRendition, playing_time_ms: 0 };
+        entry.playing_time_ms += Math.max(0, now - view.activeRenditionSince);
+        view.renditionTimes.set(key, entry);
+        view.activeRendition = null;
+        view.activeRenditionSince = null;
+    }
+    function onRenditionChanged(rendition) {
+        const next = normalizedRendition(rendition);
+        const previous = selectedRendition;
+        if (previous && next && renditionKey(previous) === renditionKey(next))
+            return;
+        const now = performance.now();
+        closeActiveRendition(now);
+        selectedRendition = next;
+        if (view && view.playingSince !== null && selectedRendition) {
+            view.activeRendition = selectedRendition;
+            view.activeRenditionSince = now;
+        }
+        if (view && previous && next)
+            emitRenditionChange(view, previous, next);
+    }
+    function playheadSeconds() {
+        return Number.isFinite(media.currentTime) && media.currentTime >= 0 ? media.currentTime : null;
+    }
+    function envelope(current, event_name) {
+        return {
+            schema_version: 1, event_name, event_id: crypto.randomUUID(), sequence: ++current.sequence,
+            occurred_at: new Date().toISOString(), view_id: current.id, video_id: videoId,
+            sdk_name: "@chunkify/analytics", sdk_version: sdkVersion,
+            connector_name: connector?.name ?? "html-media", connector_version: connector?.version ?? sdkVersion,
+            player_name: connector?.playerName ?? null, player_version: connector?.playerVersion ?? null,
+            delivery_hostname: current.hostname, environment, viewer_id: viewerId,
+            reason: null, startup_outcome: null, error_category: null, error_code: null,
+            error_fatal: null, error_playhead_seconds: null,
+        };
+    }
+    function deliver(event) {
+        for (const destination of destinations) {
+            try {
+                // A failing destination must not interrupt playback or another destination.
+                void Promise.resolve(destination.send(event)).catch(() => { });
+            }
+            catch {
+                // Synchronous delivery failures are isolated for the same reason.
+            }
+        }
+    }
+    function changePlaybackState(next, current = view) {
+        if (!current || current.playbackState === next)
+            return;
+        if (current.playbackState === "ended" || current.playbackState === "stopped" ||
+            (current.playbackState === "error" && next !== "ended" && next !== "stopped"))
+            return;
+        const now = performance.now();
+        const previous = current.playbackState;
+        const elapsed = Math.max(0, now - current.playbackStateSince);
+        current.playbackState = next;
+        current.playbackStateSince = now;
+        if (!includedEvents.has("chunkify.video.playback_state_changed"))
+            return;
+        deliver({ ...envelope(current, "chunkify.video.playback_state_changed"),
+            event_name: "chunkify.video.playback_state_changed", playhead_seconds: playheadSeconds(),
+            from_state: previous, to_state: next, previous_state_duration_ms: elapsed });
+    }
+    function emitRenditionChange(current, previous, selected) {
+        if (!includedEvents.has("chunkify.video.rendition_changed"))
+            return;
+        deliver({ ...envelope(current, "chunkify.video.rendition_changed"),
+            event_name: "chunkify.video.rendition_changed", playhead_seconds: playheadSeconds(),
+            previous_rendition_width: previous.width, previous_rendition_height: previous.height,
+            previous_rendition_codec: previous.codec, previous_rendition_bitrate_bps: previous.bitrate_bps,
+            previous_rendition_frame_rate: previous.frame_rate,
+            selected_rendition_width: selected.width, selected_rendition_height: selected.height,
+            selected_rendition_codec: selected.codec, selected_rendition_bitrate_bps: selected.bitrate_bps,
+            selected_rendition_frame_rate: selected.frame_rate });
+    }
+    function emit(current, event_name, reason = null, error = null) {
+        if (!includedEvents.has(event_name))
+            return;
+        const now = performance.now();
+        const playingTime = current.playing + (current.playingSince === null ? 0 : now - current.playingSince);
+        const rebufferDuration = current.rebufferDuration + (current.rebufferSince === null ? 0 : now - current.rebufferSince);
+        const seekDuration = current.seekDuration + (current.seekSince === null ? 0 : now - current.seekSince);
+        const rebufferDenominator = playingTime + rebufferDuration;
+        const frames = frameCounts(media);
+        let viewFrames = null;
+        if (frames && current.frameBaseline && current.framePrevious && current.frameMetricsValid) {
+            if (frames.dropped < current.framePrevious.dropped || frames.total < current.framePrevious.total) {
+                current.frameMetricsValid = false;
+            }
+            else {
+                viewFrames = {
+                    dropped: frames.dropped - current.frameBaseline.dropped,
+                    total: frames.total - current.frameBaseline.total,
+                };
+            }
+        }
+        if (frames)
+            current.framePrevious = frames;
+        const engineMetrics = connectorMetrics(connector, current.connectorBaseline);
+        let startupOutcome = null;
+        if (event_name === "chunkify.video.view_ended") {
+            if (current.startup !== null)
+                startupOutcome = "started";
+            else if (current.fatalErrorBeforeStart)
+                startupOutcome = "failed_before_start";
+            else
+                startupOutcome = "ended_before_start";
+        }
+        refreshIntrinsicVideoSize(current);
+        const event = {
+            ...envelope(current, event_name), event_name, reason, startup_outcome: startupOutcome,
+            error_category: error?.category ?? null,
+            error_code: error?.code ?? null,
+            error_fatal: error?.fatal ?? null,
+            error_playhead_seconds: error?.playhead ?? null,
+            media_duration_seconds: current.duration,
+            startup_time_ms: current.startup,
+            first_video_frame_time_ms: current.firstVideoFrame,
+            playing_time_ms: playingTime,
+            rebuffer_count: current.rebufferCount,
+            rebuffer_duration_ms: rebufferDuration,
+            rebuffer_ratio: rebufferDenominator > 0 ? rebufferDuration / rebufferDenominator : null,
+            seek_count: current.seekCount,
+            seek_duration_ms: seekDuration,
+            maximum_playhead_seconds: current.maximumPlayhead,
+            furthest_progress_ratio: current.duration === null || current.duration === 0 ? null : Math.min(1, current.maximumPlayhead / current.duration),
+            video_intrinsic_width_css_px: current.intrinsicVideoWidth,
+            video_intrinsic_height_css_px: current.intrinsicVideoHeight,
+            dropped_video_frames: viewFrames?.dropped ?? null,
+            total_video_frames: viewFrames?.total ?? null,
+            ...engineMetrics,
+            rendition_playing_time: renditionPlayingTime(current, now),
+        };
+        deliver(event);
+    }
+    function startAttempt() {
+        if (destroyed)
+            return;
+        wantsPlay = true;
+        if (view) {
+            if (view.playbackState === "paused")
+                changePlaybackState("resuming");
+            return;
+        }
+        const initialFrames = frameCounts(media);
+        const initialVideoSize = intrinsicVideoSize(media);
+        const startedAt = performance.now();
+        const current = { id: crypto.randomUUID(), sequence: 0, startedAt,
+            startup: null, firstVideoFrame: null, frameCallbackId: null,
+            playing: 0, playingSince: null,
+            rebufferCount: 0, rebufferDuration: 0, rebufferSince: null,
+            seekCount: 0, seekDuration: 0, seekSince: null,
+            maximumPlayhead: Number.isFinite(media.currentTime) ? Math.max(0, media.currentTime) : 0,
+            nextSnapshotAt: snapshotIntervalMs,
+            duration: duration(media),
+            intrinsicVideoWidth: initialVideoSize.width, intrinsicVideoHeight: initialVideoSize.height,
+            hostname: deliveryHostname(media), source: media.src || media.currentSrc,
+            // NETWORK_IDLE (1) and NETWORK_LOADING (2) already have a selected resource.
+            resourceStarted: media.readyState > 0 || media.networkState === 1 || media.networkState === 2,
+            errorEmitted: false, fatalErrorBeforeStart: false,
+            frameBaseline: initialFrames, framePrevious: initialFrames,
+            frameMetricsValid: initialFrames !== null,
+            connectorBaseline: connector ? safeConnectorSnapshot(connector) : null,
+            renditionTrackingAvailable: Boolean(connector?.subscribeToRenditions),
+            renditionTimes: new Map(), activeRendition: null, activeRenditionSince: null,
+            playbackState: "startup", playbackStateSince: startedAt };
+        view = current;
+        if (includedEvents.size > 0)
+            observeFirstVideoFrame(current);
+        emit(current, "chunkify.video.view_started");
+        if (view !== current)
+            return;
+        if (media.error)
+            reportMediaError();
+    }
+    function stopPlaying() {
+        if (snapshotTimer !== null) {
+            clearTimeout(snapshotTimer);
+            snapshotTimer = null;
+        }
+        if (!view || view.playingSince === null)
+            return;
+        const now = performance.now();
+        closeActiveRendition(now);
+        view.playing += now - view.playingSince;
+        view.playingSince = null;
+    }
+    function stopRebuffering() {
+        if (!view || view.rebufferSince === null)
+            return;
+        view.rebufferDuration += performance.now() - view.rebufferSince;
+        view.rebufferSince = null;
+    }
+    function stopSeeking() {
+        if (!view || view.seekSince === null)
+            return;
+        view.seekDuration += performance.now() - view.seekSince;
+        view.seekSince = null;
+    }
+    function updatePlaybackPosition() {
+        if (!view)
+            return;
+        refreshIntrinsicVideoSize(view);
+        if (!Number.isFinite(media.currentTime))
+            return;
+        view.maximumPlayhead = Math.max(view.maximumPlayhead, media.currentTime);
+    }
+    function reportMediaError() {
+        if (!view)
+            return;
+        const current = view;
+        cancelFirstVideoFrame(current);
+        if (current.startup === null)
+            current.fatalErrorBeforeStart = true;
+        if (current.errorEmitted)
+            return;
+        updatePlaybackPosition();
+        current.errorEmitted = true;
+        const code = media.error && Number.isFinite(media.error.code) ? media.error.code : null;
+        emit(current, "chunkify.video.playback_error", null, {
+            category: mediaErrorCategory(code), code, fatal: true,
+            playhead: Number.isFinite(media.currentTime) ? Math.max(0, media.currentTime) : null,
+        });
+        if (view === current)
+            changePlaybackState("error");
+    }
+    function reportConnectorError(error) {
+        if (!view)
+            return;
+        const current = view;
+        if (error.fatal)
+            cancelFirstVideoFrame(current);
+        if (error.fatal && current.startup === null)
+            current.fatalErrorBeforeStart = true;
+        if (current.errorEmitted)
+            return;
+        if (error.fatal) {
+            stopPlaying();
+            stopRebuffering();
+            stopSeeking();
+            seeking = false;
+            wantsPlay = false;
+        }
+        updatePlaybackPosition();
+        current.errorEmitted = true;
+        emit(current, "chunkify.video.playback_error", null, {
+            category: error.category,
+            code: typeof error.code === "string" || typeof error.code === "number" ? error.code : null,
+            fatal: Boolean(error.fatal),
+            playhead: Number.isFinite(media.currentTime) ? Math.max(0, media.currentTime) : null,
+        });
+        if (error.fatal && view === current)
+            changePlaybackState("error");
+    }
+    function setConnector(next) {
+        if (destroyed)
+            return;
+        const previousUnsubscribe = unsubscribeConnector;
+        const previousRenditionUnsubscribe = unsubscribeRenditions;
+        unsubscribeConnector = null;
+        unsubscribeRenditions = null;
+        try {
+            previousUnsubscribe?.();
+        }
+        catch { }
+        try {
+            previousRenditionUnsubscribe?.();
+        }
+        catch { }
+        if (destroyed)
+            return;
+        onRenditionChanged(null);
+        connector = next;
+        if (view)
+            view.connectorBaseline = connector ? safeConnectorSnapshot(connector) : null;
+        if (view && connector?.subscribeToRenditions)
+            view.renditionTrackingAvailable = true;
+        if (connector) {
+            let unsubscribe = null;
+            try {
+                unsubscribe = connector.subscribeToErrors(reportConnectorError);
+            }
+            catch { }
+            let unsubscribeRendition = null;
+            try {
+                unsubscribeRendition = connector.subscribeToRenditions?.(onRenditionChanged) ?? null;
+            }
+            catch { }
+            if (destroyed) {
+                try {
+                    unsubscribe?.();
+                }
+                catch { }
+                try {
+                    unsubscribeRendition?.();
+                }
+                catch { }
+                return;
+            }
+            unsubscribeConnector = unsubscribe;
+            unsubscribeRenditions = unsubscribeRendition;
+        }
+    }
+    function scheduleSnapshot() {
+        if (!view || !includedEvents.has("chunkify.video.view_snapshot") || snapshotTimer !== null)
+            return;
+        const playingSince = view.playingSince;
+        if (playingSince === null)
+            return;
+        const current = view;
+        const playingTime = current.playing + performance.now() - playingSince;
+        snapshotTimer = globalThis.setTimeout(() => {
+            snapshotTimer = null;
+            if (view !== current || current.playingSince === null)
+                return;
+            updatePlaybackPosition();
+            metadata();
+            emit(current, "chunkify.video.view_snapshot");
+            const currentPlayingTime = current.playing + performance.now() - current.playingSince;
+            const nextFutureInterval = (Math.floor(currentPlayingTime / snapshotIntervalMs) + 1) * snapshotIntervalMs;
+            current.nextSnapshotAt = Math.max(current.nextSnapshotAt + snapshotIntervalMs, nextFutureInterval);
+            if (view === current)
+                scheduleSnapshot();
+        }, Math.max(0, current.nextSnapshotAt - playingTime));
+    }
+    function playing() {
+        if (!view || !wantsPlay || seeking)
+            return;
+        refreshIntrinsicVideoSize(view);
+        const now = performance.now();
+        view.resourceStarted = true;
+        view.startup ??= now - view.startedAt;
+        stopRebuffering();
+        view.playingSince ??= now;
+        if (view.activeRenditionSince === null && selectedRendition) {
+            view.activeRendition = selectedRendition;
+            view.activeRenditionSince = now;
+        }
+        changePlaybackState("playing");
+        scheduleSnapshot();
+    }
+    function finish(reason) {
+        if (!view)
+            return;
+        const current = view;
+        cancelFirstVideoFrame(current);
+        stopPlaying();
+        stopRebuffering();
+        stopSeeking();
+        updatePlaybackPosition();
+        view = null;
+        wantsPlay = false;
+        seeking = false;
+        changePlaybackState(reason === "ended" ? "ended" : "stopped", current);
+        emit(current, "chunkify.video.view_ended", reason);
+    }
+    function metadata() {
+        if (!view)
+            return;
+        view.duration = duration(media);
+        refreshIntrinsicVideoSize(view);
+        view.hostname = deliveryHostname(media);
+    }
+    const listeners = {
+        play: startAttempt, playing,
+        waiting() {
+            stopPlaying();
+            if (view && view.startup !== null && wantsPlay && !seeking && view.rebufferSince === null) {
+                view.rebufferCount++;
+                view.rebufferSince = performance.now();
+                changePlaybackState("buffering");
+            }
+        },
+        error() {
+            stopPlaying();
+            stopRebuffering();
+            stopSeeking();
+            seeking = false;
+            wantsPlay = false;
+            reportMediaError();
+        },
+        ended() { finish("ended"); },
+        emptied() {
+            if (sourceManagedByEngine)
+                return;
+            if (!view)
+                return;
+            // A new attempt can begin after src changes but before the old resource's
+            // queued emptied event arrives. That reset does not belong to the new view.
+            if (view.resourceStarted || (view.source && view.source !== (media.src || media.currentSrc)))
+                finish("source_changed");
+        },
+        loadstart() {
+            if (!view)
+                return;
+            const source = media.src || media.currentSrc;
+            if (!sourceManagedByEngine && view.source && view.source !== source) {
+                finish("source_changed");
+                return;
+            }
+            // <source> selection can first expose the URL after the initial attempt.
+            view.source = source;
+            view.resourceStarted = true;
+        },
+        pause() {
+            stopPlaying();
+            stopRebuffering();
+            wantsPlay = false;
+            if (view && !media.ended)
+                changePlaybackState("paused");
+        },
+        seeking() {
+            stopPlaying();
+            stopRebuffering();
+            updatePlaybackPosition();
+            if (view && !seeking) {
+                view.seekCount++;
+                view.seekSince = performance.now();
+            }
+            seeking = true;
+            changePlaybackState("seeking");
+        },
+        seeked() {
+            updatePlaybackPosition();
+            stopSeeking();
+            seeking = false;
+            changePlaybackState(wantsPlay ? "resuming" : "paused");
+        },
+        timeupdate: updatePlaybackPosition,
+        loadedmetadata: metadata, durationchange: metadata,
+    };
+    for (const [name, listener] of Object.entries(listeners))
+        media.addEventListener(name, listener);
+    const page = media.ownerDocument.defaultView;
+    const pagehide = () => finish("page_exit");
+    page?.addEventListener("pagehide", pagehide);
+    return {
+        startAttempt,
+        sourceChanged() { finish("source_changed"); },
+        setConnector,
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            for (const [name, listener] of Object.entries(listeners))
+                media.removeEventListener(name, listener);
+            page?.removeEventListener("pagehide", pagehide);
+            finish("destroyed");
+            try {
+                unsubscribeConnector?.();
+            }
+            catch { }
+            try {
+                unsubscribeRenditions?.();
+            }
+            catch { }
+            unsubscribeConnector = null;
+            unsubscribeRenditions = null;
+            connector = null;
+        },
+    };
+}
+function safeConnectorSnapshot(connector) {
+    try {
+        return connector.snapshot();
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=core.js.map