@livepeer-frameworks/player-core 0.1.1 → 0.1.2

package/dist/esm/core/TimerManager.js

@@ -0,0 +1,174 @@
+/**
+ * TimerManager - Centralized timer management for memory leak prevention
+ *
+ * Tracks all setTimeout/setInterval calls and provides bulk cleanup.
+ * Based on MistMetaPlayer's MistVideo.timers pattern.
+ *
+ * Usage:
+ * ```ts
+ * const timers = new TimerManager();
+ *
+ * // Start a timeout
+ * const id = timers.start(() => console.log('fired'), 1000);
+ *
+ * // Start an interval
+ * const intervalId = timers.startInterval(() => console.log('tick'), 500);
+ *
+ * // Stop a specific timer
+ * timers.stop(id);
+ *
+ * // Stop all timers (on cleanup/destroy)
+ * timers.stopAll();
+ * ```
+ */
+class TimerManager {
+    constructor(options) {
+        this.timers = new Map();
+        this.nextId = 1;
+        this.debug = options?.debug ?? false;
+    }
+    /**
+     * Start a timeout
+     * @param callback Function to call after delay
+     * @param delay Delay in milliseconds
+     * @param label Optional label for debugging
+     * @returns Timer ID (internal, not the native timeout ID)
+     */
+    start(callback, delay, label) {
+        const internalId = this.nextId++;
+        const endTime = Date.now() + delay;
+        const nativeId = setTimeout(() => {
+            this.timers.delete(internalId);
+            try {
+                callback();
+            }
+            catch (e) {
+                console.error("[TimerManager] Callback error:", e);
+            }
+        }, delay);
+        this.timers.set(internalId, {
+            id: nativeId,
+            endTime,
+            isInterval: false,
+            label,
+        });
+        if (this.debug) {
+            console.debug(`[TimerManager] Started timeout ${internalId}${label ? ` (${label})` : ""} for ${delay}ms`);
+        }
+        return internalId;
+    }
+    /**
+     * Start an interval
+     * @param callback Function to call repeatedly
+     * @param interval Interval in milliseconds
+     * @param label Optional label for debugging
+     * @returns Timer ID (internal, not the native interval ID)
+     */
+    startInterval(callback, interval, label) {
+        const internalId = this.nextId++;
+        const nativeId = setInterval(() => {
+            try {
+                callback();
+            }
+            catch (e) {
+                console.error("[TimerManager] Interval callback error:", e);
+            }
+        }, interval);
+        this.timers.set(internalId, {
+            id: nativeId,
+            endTime: Infinity, // Intervals don't have an end time
+            isInterval: true,
+            label,
+        });
+        if (this.debug) {
+            console.debug(`[TimerManager] Started interval ${internalId}${label ? ` (${label})` : ""} every ${interval}ms`);
+        }
+        return internalId;
+    }
+    /**
+     * Stop a specific timer
+     * @param internalId The timer ID returned by start() or startInterval()
+     */
+    stop(internalId) {
+        const entry = this.timers.get(internalId);
+        if (!entry) {
+            return false;
+        }
+        if (entry.isInterval) {
+            clearInterval(entry.id);
+        }
+        else {
+            clearTimeout(entry.id);
+        }
+        this.timers.delete(internalId);
+        if (this.debug) {
+            console.debug(`[TimerManager] Stopped ${entry.isInterval ? "interval" : "timeout"} ${internalId}${entry.label ? ` (${entry.label})` : ""}`);
+        }
+        return true;
+    }
+    /**
+     * Stop all active timers
+     * Call this on component unmount/destroy to prevent memory leaks
+     */
+    stopAll() {
+        const count = this.timers.size;
+        for (const [_internalId, entry] of this.timers) {
+            if (entry.isInterval) {
+                clearInterval(entry.id);
+            }
+            else {
+                clearTimeout(entry.id);
+            }
+        }
+        this.timers.clear();
+        if (this.debug && count > 0) {
+            console.debug(`[TimerManager] Stopped all ${count} timers`);
+        }
+    }
+    /**
+     * Get count of active timers
+     */
+    get activeCount() {
+        return this.timers.size;
+    }
+    /**
+     * Check if a timer is active
+     */
+    isActive(internalId) {
+        return this.timers.has(internalId);
+    }
+    /**
+     * Get remaining time for a timeout (0 for intervals or expired)
+     */
+    getRemainingTime(internalId) {
+        const entry = this.timers.get(internalId);
+        if (!entry || entry.isInterval) {
+            return 0;
+        }
+        return Math.max(0, entry.endTime - Date.now());
+    }
+    /**
+     * Get debug info about all active timers
+     */
+    getDebugInfo() {
+        const info = [];
+        for (const [internalId, entry] of this.timers) {
+            info.push({
+                id: internalId,
+                type: entry.isInterval ? "interval" : "timeout",
+                label: entry.label,
+                remainingMs: entry.isInterval ? undefined : Math.max(0, entry.endTime - Date.now()),
+            });
+        }
+        return info;
+    }
+    /**
+     * Cleanup - alias for stopAll()
+     */
+    destroy() {
+        this.stopAll();
+    }
+}
+
+export { TimerManager };
+//# sourceMappingURL=TimerManager.js.map

package/dist/esm/core/TimerManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimerManager.js","sources":["../../../../src/core/TimerManager.ts"],"sourcesContent":["/**\n * TimerManager - Centralized timer management for memory leak prevention\n *\n * Tracks all setTimeout/setInterval calls and provides bulk cleanup.\n * Based on MistMetaPlayer's MistVideo.timers pattern.\n *\n * Usage:\n * ```ts\n * const timers = new TimerManager();\n *\n * // Start a timeout\n * const id = timers.start(() => console.log('fired'), 1000);\n *\n * // Start an interval\n * const intervalId = timers.startInterval(() => console.log('tick'), 500);\n *\n * // Stop a specific timer\n * timers.stop(id);\n *\n * // Stop all timers (on cleanup/destroy)\n * timers.stopAll();\n * ```\n */\n\ninterface TimerEntry {\n  /** Timer ID from setTimeout/setInterval */\n  id: ReturnType<typeof setTimeout>;\n  /** Expected end time (for timeouts) */\n  endTime: number;\n  /** Whether this is an interval */\n  isInterval: boolean;\n  /** Optional label for debugging */\n  label?: string;\n}\n\nexport class TimerManager {\n  private timers: Map<number, TimerEntry> = new Map();\n  private nextId = 1;\n  private debug: boolean;\n\n  constructor(options?: { debug?: boolean }) {\n    this.debug = options?.debug ?? false;\n  }\n\n  /**\n   * Start a timeout\n   * @param callback Function to call after delay\n   * @param delay Delay in milliseconds\n   * @param label Optional label for debugging\n   * @returns Timer ID (internal, not the native timeout ID)\n   */\n  start(callback: () => void, delay: number, label?: string): number {\n    const internalId = this.nextId++;\n    const endTime = Date.now() + delay;\n\n    const nativeId = setTimeout(() => {\n      this.timers.delete(internalId);\n      try {\n        callback();\n      } catch (e) {\n        console.error(\"[TimerManager] Callback error:\", e);\n      }\n    }, delay);\n\n    this.timers.set(internalId, {\n      id: nativeId,\n      endTime,\n      isInterval: false,\n      label,\n    });\n\n    if (this.debug) {\n      console.debug(\n        `[TimerManager] Started timeout ${internalId}${label ? ` (${label})` : \"\"} for ${delay}ms`\n      );\n    }\n\n    return internalId;\n  }\n\n  /**\n   * Start an interval\n   * @param callback Function to call repeatedly\n   * @param interval Interval in milliseconds\n   * @param label Optional label for debugging\n   * @returns Timer ID (internal, not the native interval ID)\n   */\n  startInterval(callback: () => void, interval: number, label?: string): number {\n    const internalId = this.nextId++;\n\n    const nativeId = setInterval(() => {\n      try {\n        callback();\n      } catch (e) {\n        console.error(\"[TimerManager] Interval callback error:\", e);\n      }\n    }, interval);\n\n    this.timers.set(internalId, {\n      id: nativeId,\n      endTime: Infinity, // Intervals don't have an end time\n      isInterval: true,\n      label,\n    });\n\n    if (this.debug) {\n      console.debug(\n        `[TimerManager] Started interval ${internalId}${label ? ` (${label})` : \"\"} every ${interval}ms`\n      );\n    }\n\n    return internalId;\n  }\n\n  /**\n   * Stop a specific timer\n   * @param internalId The timer ID returned by start() or startInterval()\n   */\n  stop(internalId: number): boolean {\n    const entry = this.timers.get(internalId);\n    if (!entry) {\n      return false;\n    }\n\n    if (entry.isInterval) {\n      clearInterval(entry.id);\n    } else {\n      clearTimeout(entry.id);\n    }\n\n    this.timers.delete(internalId);\n\n    if (this.debug) {\n      console.debug(\n        `[TimerManager] Stopped ${entry.isInterval ? \"interval\" : \"timeout\"} ${internalId}${entry.label ? ` (${entry.label})` : \"\"}`\n      );\n    }\n\n    return true;\n  }\n\n  /**\n   * Stop all active timers\n   * Call this on component unmount/destroy to prevent memory leaks\n   */\n  stopAll(): void {\n    const count = this.timers.size;\n\n    for (const [_internalId, entry] of this.timers) {\n      if (entry.isInterval) {\n        clearInterval(entry.id);\n      } else {\n        clearTimeout(entry.id);\n      }\n    }\n\n    this.timers.clear();\n\n    if (this.debug && count > 0) {\n      console.debug(`[TimerManager] Stopped all ${count} timers`);\n    }\n  }\n\n  /**\n   * Get count of active timers\n   */\n  get activeCount(): number {\n    return this.timers.size;\n  }\n\n  /**\n   * Check if a timer is active\n   */\n  isActive(internalId: number): boolean {\n    return this.timers.has(internalId);\n  }\n\n  /**\n   * Get remaining time for a timeout (0 for intervals or expired)\n   */\n  getRemainingTime(internalId: number): number {\n    const entry = this.timers.get(internalId);\n    if (!entry || entry.isInterval) {\n      return 0;\n    }\n    return Math.max(0, entry.endTime - Date.now());\n  }\n\n  /**\n   * Get debug info about all active timers\n   */\n  getDebugInfo(): Array<{\n    id: number;\n    type: \"timeout\" | \"interval\";\n    label?: string;\n    remainingMs?: number;\n  }> {\n    const info: Array<{\n      id: number;\n      type: \"timeout\" | \"interval\";\n      label?: string;\n      remainingMs?: number;\n    }> = [];\n\n    for (const [internalId, entry] of this.timers) {\n      info.push({\n        id: internalId,\n        type: entry.isInterval ? \"interval\" : \"timeout\",\n        label: entry.label,\n        remainingMs: entry.isInterval ? undefined : Math.max(0, entry.endTime - Date.now()),\n      });\n    }\n\n    return info;\n  }\n\n  /**\n   * Cleanup - alias for stopAll()\n   */\n  destroy(): void {\n    this.stopAll();\n  }\n}\n\nexport default TimerManager;\n"],"names":[],"mappings":"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"}

package/dist/esm/core/UrlUtils.js

@@ -0,0 +1,151 @@
+/**
+ * UrlUtils - URL manipulation utilities
+ *
+ * Based on MistMetaPlayer's urlappend functionality.
+ * Provides helpers for appending query parameters to URLs.
+ */
+/**
+ * Append query parameters to a URL
+ * Handles URLs that already have query parameters
+ *
+ * @param url - Base URL
+ * @param params - Parameters to append (string or object)
+ * @returns URL with appended parameters
+ *
+ * @example
+ * ```ts
+ * appendUrlParams('https://example.com/video.m3u8', 'token=abc&session=123')
+ * // => 'https://example.com/video.m3u8?token=abc&session=123'
+ *
+ * appendUrlParams('https://example.com/video.m3u8?existing=param', 'token=abc')
+ * // => 'https://example.com/video.m3u8?existing=param&token=abc'
+ *
+ * appendUrlParams('https://example.com/video.m3u8', { token: 'abc', session: '123' })
+ * // => 'https://example.com/video.m3u8?token=abc&session=123'
+ * ```
+ */
+function appendUrlParams(url, params) {
+    if (!params) {
+        return url;
+    }
+    // Convert object to query string
+    let queryString;
+    if (typeof params === "object") {
+        const entries = Object.entries(params)
+            .filter(([, value]) => value !== undefined && value !== null)
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        if (entries.length === 0) {
+            return url;
+        }
+        queryString = entries.join("&");
+    }
+    else {
+        queryString = params;
+        // Strip leading ? or & if present
+        if (queryString.startsWith("?") || queryString.startsWith("&")) {
+            queryString = queryString.slice(1);
+        }
+    }
+    if (!queryString) {
+        return url;
+    }
+    // Determine separator (? or &)
+    const separator = url.includes("?") ? "&" : "?";
+    return `${url}${separator}${queryString}`;
+}
+/**
+ * Parse query parameters from a URL
+ *
+ * @param url - URL to parse
+ * @returns Object with query parameters
+ */
+function parseUrlParams(url) {
+    const params = {};
+    try {
+        const urlObj = new URL(url);
+        urlObj.searchParams.forEach((value, key) => {
+            params[key] = value;
+        });
+    }
+    catch {
+        // If URL parsing fails, try manual parsing
+        const queryIndex = url.indexOf("?");
+        if (queryIndex === -1) {
+            return params;
+        }
+        const queryString = url.slice(queryIndex + 1);
+        const pairs = queryString.split("&");
+        for (const pair of pairs) {
+            const [key, value] = pair.split("=");
+            if (key) {
+                params[decodeURIComponent(key)] = value ? decodeURIComponent(value) : "";
+            }
+        }
+    }
+    return params;
+}
+/**
+ * Remove query parameters from a URL
+ *
+ * @param url - URL to strip
+ * @returns URL without query parameters
+ */
+function stripUrlParams(url) {
+    const queryIndex = url.indexOf("?");
+    return queryIndex === -1 ? url : url.slice(0, queryIndex);
+}
+/**
+ * Build a URL with query parameters
+ *
+ * @param baseUrl - Base URL
+ * @param params - Query parameters
+ * @returns Complete URL
+ */
+function buildUrl(baseUrl, params) {
+    return appendUrlParams(stripUrlParams(baseUrl), params);
+}
+/**
+ * Check if URL uses secure protocol (https/wss)
+ */
+function isSecureUrl(url) {
+    return url.startsWith("https://") || url.startsWith("wss://");
+}
+/**
+ * Convert HTTP URL to WebSocket URL
+ * http:// -> ws://
+ * https:// -> wss://
+ */
+function httpToWs(url) {
+    return url.replace(/^http/, "ws");
+}
+/**
+ * Convert WebSocket URL to HTTP URL
+ * ws:// -> http://
+ * wss:// -> https://
+ */
+function wsToHttp(url) {
+    return url.replace(/^ws/, "http");
+}
+/**
+ * Ensure URL uses the same protocol as the current page
+ * Useful for avoiding mixed content issues
+ */
+function matchPageProtocol(url) {
+    if (typeof window === "undefined") {
+        return url;
+    }
+    const pageIsSecure = window.location.protocol === "https:";
+    const urlIsSecure = isSecureUrl(url);
+    if (pageIsSecure && !urlIsSecure) {
+        // Upgrade to secure
+        return url.replace(/^http:/, "https:").replace(/^ws:/, "wss:");
+    }
+    if (!pageIsSecure && urlIsSecure) {
+        // Downgrade to insecure (not recommended, but avoids issues)
+        return url.replace(/^https:/, "http:").replace(/^wss:/, "ws:");
+    }
+    return url;
+}
+
+export { appendUrlParams, buildUrl, httpToWs, isSecureUrl, matchPageProtocol, parseUrlParams, stripUrlParams, wsToHttp };
+//# sourceMappingURL=UrlUtils.js.map

package/dist/esm/core/UrlUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UrlUtils.js","sources":["../../../../src/core/UrlUtils.ts"],"sourcesContent":["/**\n * UrlUtils - URL manipulation utilities\n *\n * Based on MistMetaPlayer's urlappend functionality.\n * Provides helpers for appending query parameters to URLs.\n */\n\n/**\n * Append query parameters to a URL\n * Handles URLs that already have query parameters\n *\n * @param url - Base URL\n * @param params - Parameters to append (string or object)\n * @returns URL with appended parameters\n *\n * @example\n * ```ts\n * appendUrlParams('https://example.com/video.m3u8', 'token=abc&session=123')\n * // => 'https://example.com/video.m3u8?token=abc&session=123'\n *\n * appendUrlParams('https://example.com/video.m3u8?existing=param', 'token=abc')\n * // => 'https://example.com/video.m3u8?existing=param&token=abc'\n *\n * appendUrlParams('https://example.com/video.m3u8', { token: 'abc', session: '123' })\n * // => 'https://example.com/video.m3u8?token=abc&session=123'\n * ```\n */\nexport function appendUrlParams(\n  url: string,\n  params: string | Record<string, string | number | boolean | undefined | null>\n): string {\n  if (!params) {\n    return url;\n  }\n\n  // Convert object to query string\n  let queryString: string;\n  if (typeof params === \"object\") {\n    const entries = Object.entries(params)\n      .filter(([, value]) => value !== undefined && value !== null)\n      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);\n\n    if (entries.length === 0) {\n      return url;\n    }\n    queryString = entries.join(\"&\");\n  } else {\n    queryString = params;\n    // Strip leading ? or & if present\n    if (queryString.startsWith(\"?\") || queryString.startsWith(\"&\")) {\n      queryString = queryString.slice(1);\n    }\n  }\n\n  if (!queryString) {\n    return url;\n  }\n\n  // Determine separator (? or &)\n  const separator = url.includes(\"?\") ? \"&\" : \"?\";\n  return `${url}${separator}${queryString}`;\n}\n\n/**\n * Parse query parameters from a URL\n *\n * @param url - URL to parse\n * @returns Object with query parameters\n */\nexport function parseUrlParams(url: string): Record<string, string> {\n  const params: Record<string, string> = {};\n\n  try {\n    const urlObj = new URL(url);\n    urlObj.searchParams.forEach((value, key) => {\n      params[key] = value;\n    });\n  } catch {\n    // If URL parsing fails, try manual parsing\n    const queryIndex = url.indexOf(\"?\");\n    if (queryIndex === -1) {\n      return params;\n    }\n\n    const queryString = url.slice(queryIndex + 1);\n    const pairs = queryString.split(\"&\");\n    for (const pair of pairs) {\n      const [key, value] = pair.split(\"=\");\n      if (key) {\n        params[decodeURIComponent(key)] = value ? decodeURIComponent(value) : \"\";\n      }\n    }\n  }\n\n  return params;\n}\n\n/**\n * Remove query parameters from a URL\n *\n * @param url - URL to strip\n * @returns URL without query parameters\n */\nexport function stripUrlParams(url: string): string {\n  const queryIndex = url.indexOf(\"?\");\n  return queryIndex === -1 ? url : url.slice(0, queryIndex);\n}\n\n/**\n * Build a URL with query parameters\n *\n * @param baseUrl - Base URL\n * @param params - Query parameters\n * @returns Complete URL\n */\nexport function buildUrl(\n  baseUrl: string,\n  params: Record<string, string | number | boolean | undefined | null>\n): string {\n  return appendUrlParams(stripUrlParams(baseUrl), params);\n}\n\n/**\n * Check if URL uses secure protocol (https/wss)\n */\nexport function isSecureUrl(url: string): boolean {\n  return url.startsWith(\"https://\") || url.startsWith(\"wss://\");\n}\n\n/**\n * Convert HTTP URL to WebSocket URL\n * http:// -> ws://\n * https:// -> wss://\n */\nexport function httpToWs(url: string): string {\n  return url.replace(/^http/, \"ws\");\n}\n\n/**\n * Convert WebSocket URL to HTTP URL\n * ws:// -> http://\n * wss:// -> https://\n */\nexport function wsToHttp(url: string): string {\n  return url.replace(/^ws/, \"http\");\n}\n\n/**\n * Ensure URL uses the same protocol as the current page\n * Useful for avoiding mixed content issues\n */\nexport function matchPageProtocol(url: string): string {\n  if (typeof window === \"undefined\") {\n    return url;\n  }\n\n  const pageIsSecure = window.location.protocol === \"https:\";\n  const urlIsSecure = isSecureUrl(url);\n\n  if (pageIsSecure && !urlIsSecure) {\n    // Upgrade to secure\n    return url.replace(/^http:/, \"https:\").replace(/^ws:/, \"wss:\");\n  }\n\n  if (!pageIsSecure && urlIsSecure) {\n    // Downgrade to insecure (not recommended, but avoids issues)\n    return url.replace(/^https:/, \"http:\").replace(/^wss:/, \"ws:\");\n  }\n\n  return url;\n}\n\nexport default {\n  appendUrlParams,\n  parseUrlParams,\n  stripUrlParams,\n  buildUrl,\n  isSecureUrl,\n  httpToWs,\n  wsToHttp,\n  matchPageProtocol,\n};\n"],"names":[],"mappings":"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"}

package/dist/esm/core/detector.js

@@ -0,0 +1,279 @@
+import { translateCodec } from './CodecUtils.js';
+
+/**
+ * Browser and Codec Detection
+ * Ported from MistMetaPlayer v3.1.0
+ *
+ * Detects browser capabilities and codec support
+ * Removes legacy IE/Flash detection code
+ */
+/**
+ * Detect browser information
+ */
+function getBrowserInfo() {
+    const ua = navigator.userAgent.toLowerCase();
+    return {
+        isChrome: /chrome|crios/.test(ua) && !/edge|edg/.test(ua),
+        isFirefox: /firefox/.test(ua),
+        isSafari: /safari/.test(ua) && !/chrome|crios/.test(ua),
+        isEdge: /edge|edg/.test(ua),
+        isAndroid: /android/.test(ua),
+        isIOS: /iphone|ipad|ipod/.test(ua),
+        isMobile: /mobile|android|iphone|ipad|ipod/.test(ua),
+        supportsMediaSource: "MediaSource" in window,
+        supportsWebRTC: "RTCPeerConnection" in window,
+        supportsWebSocket: "WebSocket" in window,
+    };
+}
+/**
+ * Test codec support using MediaSource API
+ */
+function testCodecSupport(mimeType, codec) {
+    if (!("MediaSource" in window)) {
+        return false;
+    }
+    if (!MediaSource.isTypeSupported) {
+        return true; // Can't test, assume it works
+    }
+    const fullType = `${mimeType};codecs="${codec}"`;
+    return MediaSource.isTypeSupported(fullType);
+}
+/**
+ * Get comprehensive codec support info
+ */
+function getCodecSupport() {
+    return {
+        h264: testCodecSupport("video/mp4", "avc1.42E01E"),
+        h265: testCodecSupport("video/mp4", "hev1.1.6.L93.90"),
+        vp8: testCodecSupport("video/webm", "vp8"),
+        vp9: testCodecSupport("video/webm", "vp09.00.10.08"),
+        av1: testCodecSupport("video/mp4", "av01.0.04M.08"),
+        aac: testCodecSupport("video/mp4", "mp4a.40.2"),
+        mp3: testCodecSupport("audio/mpeg", "mp3"),
+        opus: testCodecSupport("audio/webm", "opus"),
+    };
+}
+/**
+ * Check if tracks are playable by testing codecs
+ */
+function checkTrackPlayability(tracks, containerType) {
+    const playable = [];
+    const supported = [];
+    const tracksByType = {};
+    // Group tracks by type
+    for (const track of tracks) {
+        if (track.type === "meta")
+            continue;
+        if (!tracksByType[track.type]) {
+            tracksByType[track.type] = [];
+        }
+        tracksByType[track.type].push(track);
+    }
+    // Test each track type
+    for (const [trackType, typeTracks] of Object.entries(tracksByType)) {
+        let hasPlayableTrack = false;
+        for (const track of typeTracks) {
+            const codecString = translateCodec(track);
+            if (testCodecSupport(containerType, codecString)) {
+                supported.push(track.codec);
+                hasPlayableTrack = true;
+            }
+        }
+        if (hasPlayableTrack) {
+            playable.push(trackType);
+        }
+    }
+    return { playable, supported };
+}
+/**
+ * Check protocol/scheme mismatch (http/https)
+ */
+function checkProtocolMismatch(sourceUrl) {
+    const pageProtocol = window.location.protocol;
+    const sourceProtocol = new URL(sourceUrl).protocol;
+    // Allow file:// to access http://
+    if (pageProtocol === "file:" && sourceProtocol === "http:") {
+        return false; // No mismatch
+    }
+    return pageProtocol !== sourceProtocol;
+}
+/**
+ * Check if current page is loaded over file://
+ */
+function isFileProtocol() {
+    return window.location.protocol === "file:";
+}
+/**
+ * Get Android version (returns null if not Android)
+ */
+function getAndroidVersion() {
+    const match = navigator.userAgent.match(/Android (\d+)(?:\.(\d+))?(?:\.(\d+))*/i);
+    if (!match)
+        return null;
+    const major = parseInt(match[1], 10);
+    const minor = match[2] ? parseInt(match[2], 10) : 0;
+    return major + minor / 10;
+}
+/**
+ * Browser-specific compatibility checks
+ */
+function getBrowserCompatibility() {
+    const browser = getBrowserInfo();
+    const android = getAndroidVersion();
+    return {
+        // Native HLS support
+        supportsNativeHLS: browser.isSafari || browser.isIOS || (android && android >= 7),
+        // MSE support
+        supportsMSE: browser.supportsMediaSource,
+        // WebSocket support
+        supportsWebSocket: browser.supportsWebSocket,
+        // WebRTC support
+        supportsWebRTC: browser.supportsWebRTC && "RTCRtpReceiver" in window,
+        // Specific player recommendations
+        preferVideoJs: android && android < 7, // VideoJS better for older Android
+        avoidMEWSOnMac: browser.isSafari, // MEWS breaks often on Safari/macOS
+        // File protocol limitations
+        fileProtocolLimitations: isFileProtocol(),
+    };
+}
+// ============================================================================
+// WebRTC Codec Compatibility
+// ============================================================================
+/**
+ * Codecs that are compatible with WebRTC (WHEP/MistServer native)
+ * These are the only codecs that can be used in RTP streams
+ */
+const WEBRTC_COMPATIBLE_CODECS = {
+    video: ["H264", "VP8", "VP9", "AV1"],
+    // Note: AAC is NOT natively supported in browser WebRTC - OPUS is standard
+    // MistServer may transcode to OPUS for WebRTC output
+    audio: ["OPUS", "PCMU", "PCMA", "G711", "G722"],
+};
+/**
+ * Codecs that are explicitly incompatible with WebRTC
+ */
+const WEBRTC_INCOMPATIBLE_CODECS = {
+    video: ["HEVC", "H265", "THEORA", "MPEG2"],
+    audio: ["AC3", "EAC3", "EC3", "MP3", "FLAC", "VORBIS", "DTS"],
+};
+/**
+ * Check if browser supports a codec via WebRTC
+ * Uses RTCRtpReceiver.getCapabilities() for dynamic browser detection (reference: webrtc.js:38-46)
+ * Falls back to static list if API unavailable
+ */
+function isBrowserWebRTCCodecSupported(type, codec) {
+    // Try dynamic browser API first (reference: webrtc.js:39)
+    if (typeof RTCRtpReceiver !== "undefined" && RTCRtpReceiver.getCapabilities) {
+        try {
+            const capabilities = RTCRtpReceiver.getCapabilities(type);
+            if (capabilities?.codecs) {
+                const targetMime = `${type}/${codec}`.toLowerCase();
+                return capabilities.codecs.some((c) => c.mimeType.toLowerCase() === targetMime);
+            }
+        }
+        catch {
+            // Fall through to static list
+        }
+    }
+    // Fallback to static list for older browsers/SSR
+    const compatibleCodecs = WEBRTC_COMPATIBLE_CODECS[type];
+    return compatibleCodecs.includes(codec.toUpperCase());
+}
+/**
+ * Check if stream tracks are compatible with WebRTC playback
+ *
+ * Uses RTCRtpReceiver.getCapabilities() to dynamically query browser support,
+ * matching the reference MistServer implementation (webrtc.js:38-46).
+ *
+ * @param tracks - Array of track metadata from MistServer
+ * @returns Compatibility assessment
+ */
+function checkWebRTCCodecCompatibility(tracks) {
+    const videoTracks = tracks.filter((t) => t.type === "video");
+    const audioTracks = tracks.filter((t) => t.type === "audio");
+    const compatibleVideoCodecs = [];
+    const compatibleAudioCodecs = [];
+    const incompatibleCodecs = [];
+    // Check video tracks using dynamic browser detection
+    for (const track of videoTracks) {
+        if (isBrowserWebRTCCodecSupported("video", track.codec)) {
+            compatibleVideoCodecs.push(track.codec);
+        }
+        else {
+            incompatibleCodecs.push(`video:${track.codec}`);
+        }
+    }
+    // Check audio tracks using dynamic browser detection
+    for (const track of audioTracks) {
+        if (isBrowserWebRTCCodecSupported("audio", track.codec)) {
+            compatibleAudioCodecs.push(track.codec);
+        }
+        else {
+            incompatibleCodecs.push(`audio:${track.codec}`);
+        }
+    }
+    // Video is compatible if there's at least one compatible video codec
+    // (or no video tracks at all - audio-only streams are fine)
+    const videoCompatible = videoTracks.length === 0 || compatibleVideoCodecs.length > 0;
+    // Audio is compatible if there's at least one compatible audio codec
+    // (or no audio tracks at all - video-only streams are fine)
+    const audioCompatible = audioTracks.length === 0 || compatibleAudioCodecs.length > 0;
+    return {
+        videoCompatible,
+        audioCompatible,
+        compatible: videoCompatible && audioCompatible,
+        incompatibleCodecs,
+        details: {
+            videoTracks: videoTracks.length,
+            audioTracks: audioTracks.length,
+            compatibleVideoCodecs,
+            compatibleAudioCodecs,
+        },
+    };
+}
+/**
+ * Check if stream tracks are compatible with MSE playback in this browser
+ *
+ * Unlike WebRTC, MSE compatibility varies by browser. HEVC works in Safari
+ * but not Firefox. This function actually tests MediaSource.isTypeSupported().
+ *
+ * @param tracks - Array of track metadata
+ * @param containerType - MIME type (e.g., 'video/mp4')
+ */
+function checkMSECodecCompatibility(tracks, containerType = "video/mp4") {
+    const videoTracks = tracks.filter((t) => t.type === "video");
+    const audioTracks = tracks.filter((t) => t.type === "audio");
+    const unsupportedCodecs = [];
+    let hasCompatibleVideo = videoTracks.length === 0;
+    let hasCompatibleAudio = audioTracks.length === 0;
+    // Test each video track
+    for (const track of videoTracks) {
+        const codecString = translateCodec(track);
+        if (testCodecSupport(containerType, codecString)) {
+            hasCompatibleVideo = true;
+        }
+        else {
+            unsupportedCodecs.push(`video:${track.codec}`);
+        }
+    }
+    // Test each audio track
+    for (const track of audioTracks) {
+        const codecString = translateCodec(track);
+        const audioContainer = track.codec === "MP3" ? "audio/mpeg" : containerType;
+        if (testCodecSupport(audioContainer, codecString)) {
+            hasCompatibleAudio = true;
+        }
+        else {
+            unsupportedCodecs.push(`audio:${track.codec}`);
+        }
+    }
+    return {
+        videoCompatible: hasCompatibleVideo,
+        audioCompatible: hasCompatibleAudio,
+        compatible: hasCompatibleVideo && hasCompatibleAudio,
+        unsupportedCodecs,
+    };
+}
+
+export { WEBRTC_COMPATIBLE_CODECS, WEBRTC_INCOMPATIBLE_CODECS, checkMSECodecCompatibility, checkProtocolMismatch, checkTrackPlayability, checkWebRTCCodecCompatibility, getAndroidVersion, getBrowserCompatibility, getBrowserInfo, getCodecSupport, isFileProtocol, testCodecSupport, translateCodec };
+//# sourceMappingURL=detector.js.map