@codenkay/video-nsgplayer-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1288 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthManager: () => AuthManager,
+  AuthParamsStore: () => AuthParamsStore,
+  DEFAULT_CONTROLS: () => DEFAULT_CONTROLS,
+  DEFAULT_LIVE_EDGE_TOLERANCE_SECONDS: () => DEFAULT_LIVE_EDGE_TOLERANCE_SECONDS,
+  DEFAULT_PLAYER_BEHAVIOR: () => DEFAULT_PLAYER_BEHAVIOR,
+  DEFAULT_PLAYER_CONFIG: () => DEFAULT_PLAYER_CONFIG,
+  DEFAULT_THEME: () => DEFAULT_THEME,
+  DEFAULT_WATERMARK: () => DEFAULT_WATERMARK,
+  EventEmitter: () => EventEmitter,
+  PACKAGE_VERSION: () => PACKAGE_VERSION,
+  PLAYBACK_RATES: () => PLAYBACK_RATES,
+  PlaybackSourceManager: () => PlaybackSourceManager,
+  PlayerErrorCode: () => PlayerErrorCode,
+  RefreshManager: () => RefreshManager,
+  assertNoSecretsInConfig: () => assertNoSecretsInConfig,
+  createPlayerError: () => createPlayerError,
+  createVideoPlayer: () => createVideoPlayer,
+  getLiveEdgeTime: () => getLiveEdgeTime,
+  isAtLiveEdge: () => isAtLiveEdge,
+  mergePlayerConfig: () => mergePlayerConfig,
+  redactObject: () => redactObject,
+  redactSensitive: () => redactSensitive,
+  redactValue: () => redactValue,
+  seekToLiveEdge: () => seekToLiveEdge,
+  themeToCssVars: () => themeToCssVars
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors/PlayerError.ts
+var PlayerErrorCode = /* @__PURE__ */ ((PlayerErrorCode2) => {
+  PlayerErrorCode2["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
+  PlayerErrorCode2["AUTHENTICATION_FAILED"] = "AUTHENTICATION_FAILED";
+  PlayerErrorCode2["AUTH_TOKEN_REFRESH_FAILED"] = "AUTH_TOKEN_REFRESH_FAILED";
+  PlayerErrorCode2["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+  PlayerErrorCode2["TOKEN_REFRESH_FAILED"] = "TOKEN_REFRESH_FAILED";
+  PlayerErrorCode2["SOURCE_RESOLUTION_FAILED"] = "SOURCE_RESOLUTION_FAILED";
+  PlayerErrorCode2["MANIFEST_LOAD_FAILED"] = "MANIFEST_LOAD_FAILED";
+  PlayerErrorCode2["SEGMENT_LOAD_FAILED"] = "SEGMENT_LOAD_FAILED";
+  PlayerErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  PlayerErrorCode2["PLAYBACK_ERROR"] = "PLAYBACK_ERROR";
+  PlayerErrorCode2["UNSUPPORTED_BROWSER"] = "UNSUPPORTED_BROWSER";
+  PlayerErrorCode2["AUTOPLAY_BLOCKED"] = "AUTOPLAY_BLOCKED";
+  PlayerErrorCode2["UNKNOWN"] = "UNKNOWN";
+  return PlayerErrorCode2;
+})(PlayerErrorCode || {});
+function createPlayerError(code, message, options) {
+  return {
+    code,
+    message: redactSensitive(message),
+    category: options?.category ?? "unknown",
+    fatal: options?.fatal ?? true,
+    retryable: options?.retryable ?? false,
+    timestamp: Date.now(),
+    cause: options?.cause
+  };
+}
+function redactSensitive(input) {
+  return input.replace(/(Bearer\s+)[^\s]+/gi, "$1[REDACTED]").replace(/([?&](token|expires|signature|sig)=)[^&]+/gi, "$1[REDACTED]").replace(/(Authorization:\s*)[^\s]+/gi, "$1[REDACTED]");
+}
+
+// src/auth/AuthManager.ts
+var AuthManager = class {
+  constructor(auth, refreshBeforeExpiryMs, logger, onRefreshed, onError, maxUnauthorizedRetries = 1) {
+    this.auth = auth;
+    this.refreshBeforeExpiryMs = refreshBeforeExpiryMs;
+    this.logger = logger;
+    this.onRefreshed = onRefreshed;
+    this.onError = onError;
+    this.token = null;
+    this.inFlight = null;
+    this.timer = null;
+    this.destroyed = false;
+    /** Consecutive unauthorized refresh attempts (reset on success). */
+    this.unauthorizedAttempts = 0;
+    this.maxUnauthorizedRetries = Math.max(0, maxUnauthorizedRetries);
+  }
+  getAccessToken() {
+    return this.token?.accessToken ?? null;
+  }
+  getExpiresAt() {
+    return this.token?.expiresAt ?? null;
+  }
+  async ensureToken(context) {
+    if (!this.auth?.getToken) return null;
+    if (this.destroyed) return null;
+    if (this.token && context.reason !== "unauthorized" && context.reason !== "manual" && this.token.expiresAt - Date.now() > this.refreshBeforeExpiryMs) {
+      return this.token;
+    }
+    return this.refresh(context);
+  }
+  async refresh(context) {
+    if (!this.auth?.getToken) {
+      throw createPlayerError(
+        "INVALID_CONFIGURATION" /* INVALID_CONFIGURATION */,
+        "auth.getToken is required for authenticated playback",
+        { category: "config", fatal: true, retryable: false }
+      );
+    }
+    if (context.reason === "unauthorized") {
+      if (this.unauthorizedAttempts >= this.maxUnauthorizedRetries) {
+        const message = "Auth token refresh aborted: exceeded bounded unauthorized retry limit";
+        this.onError?.(message, false);
+        throw createPlayerError(
+          "AUTH_TOKEN_REFRESH_FAILED" /* AUTH_TOKEN_REFRESH_FAILED */,
+          message,
+          { category: "auth", fatal: true, retryable: false }
+        );
+      }
+      this.unauthorizedAttempts += 1;
+    }
+    if (this.inFlight) return this.inFlight;
+    this.inFlight = (async () => {
+      try {
+        const next = await this.auth.getToken(context);
+        if (!next?.accessToken || typeof next.expiresAt !== "number" || next.expiresAt <= 0) {
+          throw createPlayerError(
+            "AUTHENTICATION_FAILED" /* AUTHENTICATION_FAILED */,
+            "auth.getToken returned an invalid token payload",
+            { category: "auth", fatal: true, retryable: true }
+          );
+        }
+        this.token = next;
+        if (context.reason !== "unauthorized") {
+          this.unauthorizedAttempts = 0;
+        }
+        this.scheduleProactiveRefresh();
+        this.onRefreshed?.(next);
+        this.logger.debug("Auth token refreshed", {
+          reason: context.reason,
+          expiresAt: next.expiresAt
+        });
+        return next;
+      } catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "AUTH_TOKEN_REFRESH_FAILED" /* AUTH_TOKEN_REFRESH_FAILED */) {
+          throw error;
+        }
+        const message = error instanceof Error ? error.message : "Auth token refresh failed";
+        const retryable = this.unauthorizedAttempts <= this.maxUnauthorizedRetries;
+        this.onError?.(message, retryable);
+        throw createPlayerError(
+          "AUTH_TOKEN_REFRESH_FAILED" /* AUTH_TOKEN_REFRESH_FAILED */,
+          message,
+          { category: "auth", fatal: !retryable, retryable, cause: error }
+        );
+      } finally {
+        this.inFlight = null;
+      }
+    })();
+    return this.inFlight;
+  }
+  scheduleProactiveRefresh() {
+    if (this.timer) clearTimeout(this.timer);
+    if (!this.token || this.destroyed) return;
+    const delay = Math.max(
+      5e3,
+      this.token.expiresAt - Date.now() - this.refreshBeforeExpiryMs
+    );
+    this.timer = setTimeout(() => {
+      void this.refresh({
+        reason: "expiring",
+        videoId: void 0
+      }).catch(() => {
+      });
+    }, delay);
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    this.token = null;
+    this.inFlight = null;
+  }
+};
+
+// src/config/defaults.ts
+var PLAYBACK_RATES = [0.5, 0.75, 1, 1.25, 1.5, 2];
+var PACKAGE_VERSION = "0.1.0";
+var DEFAULT_PLAYER_BEHAVIOR = {
+  autoplay: true,
+  startMuted: true,
+  volume: 1,
+  startPosition: 0,
+  skipSeconds: 10,
+  speedOptionCount: PLAYBACK_RATES.length,
+  zoomEnabled: true,
+  defaultZoom: 1,
+  playbackRates: PLAYBACK_RATES
+};
+var DEFAULT_CONTROLS = {
+  enabled: true,
+  showQuality: true,
+  showSpeed: true,
+  showCaptions: true,
+  showAudio: true,
+  showVolume: true,
+  showFullscreen: true,
+  showZoom: true,
+  showSkip: true,
+  showLive: true,
+  seekCueDurationMs: 720,
+  keyboardShortcuts: true
+};
+var DEFAULT_THEME = {
+  playIconPreset: "triangle",
+  playButtonBackground: "#ffffff",
+  playButtonIconColor: "#ffffff",
+  seekTrackColor: "#334155",
+  seekProgressColor: "#38bdf8",
+  seekBufferedColor: "#64748b",
+  timeColor: "#e2e8f0",
+  controlIconColor: "#f1f5f9",
+  focusRingColor: "#38bdf8",
+  spinnerColor: "#38bdf8",
+  volumeIconColor: "#f1f5f9",
+  volumeTrackColor: "#334155",
+  volumeProgressColor: "#38bdf8",
+  qualityOptionTextColor: "#e2e8f0",
+  qualityOptionBackground: "#020617",
+  qualityOptionActiveBackground: "#0c4a6e",
+  qualityOptionActiveTextColor: "#bae6fd",
+  speedOptionTextColor: "#e2e8f0",
+  speedOptionBackground: "#020617",
+  speedOptionActiveBackground: "#0c4a6e",
+  speedOptionActiveTextColor: "#bae6fd",
+  zoomIconColor: "#f1f5f9",
+  skipIconColor: "#f1f5f9",
+  skipCueBackground: "#ffffff",
+  skipCueTextColor: "#ffffff",
+  liveDotColor: "#ef4444"
+};
+var DEFAULT_WATERMARK = {
+  enabled: true,
+  text: "",
+  durationMs: 1e4,
+  intervalMaxMs: 3e5
+};
+var DEFAULT_PLAYER_CONFIG = {
+  player: DEFAULT_PLAYER_BEHAVIOR,
+  controls: DEFAULT_CONTROLS,
+  theme: DEFAULT_THEME,
+  watermark: DEFAULT_WATERMARK,
+  streaming: {
+    engine: "hls",
+    hls: {
+      enableWorker: true,
+      lowLatencyMode: true,
+      backBufferLength: 90,
+      fatalRecoveryLimit: 3
+    }
+  },
+  logging: { enabled: false, level: "error" },
+  debug: { enabled: false, network: false, events: false, state: false },
+  accessibility: { reducedMotion: false }
+};
+var FORBIDDEN_SECRET_KEYS = [
+  "clientsecret",
+  "apisecret",
+  "privatekey",
+  "video_api_secret",
+  "basicauthpassword",
+  "password"
+];
+function assertNoSecretsInConfig(raw) {
+  if (!raw || typeof raw !== "object") return;
+  const walk = (obj, path) => {
+    for (const [key, value] of Object.entries(obj)) {
+      const lower = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (FORBIDDEN_SECRET_KEYS.some((k) => lower.includes(k))) {
+        throw new Error(
+          `INVALID_CONFIGURATION: Forbidden secret key "${path}${key}" must never be passed to the browser SDK. Keep clientSecret on your server/BFF and use auth.getToken().`
+        );
+      }
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        walk(value, `${path}${key}.`);
+      }
+    }
+  };
+  walk(raw, "");
+}
+function mergePlayerConfig(partial) {
+  assertNoSecretsInConfig(partial);
+  return {
+    player: { ...DEFAULT_PLAYER_BEHAVIOR, ...partial?.player },
+    controls: { ...DEFAULT_CONTROLS, ...partial?.controls },
+    theme: { ...DEFAULT_THEME, ...partial?.theme },
+    watermark: { ...DEFAULT_WATERMARK, ...partial?.watermark },
+    streaming: {
+      engine: "hls",
+      hls: {
+        ...DEFAULT_PLAYER_CONFIG.streaming.hls,
+        ...partial?.streaming?.hls
+      }
+    },
+    logging: { ...DEFAULT_PLAYER_CONFIG.logging, ...partial?.logging },
+    debug: { ...DEFAULT_PLAYER_CONFIG.debug, ...partial?.debug },
+    accessibility: {
+      ...DEFAULT_PLAYER_CONFIG.accessibility,
+      ...partial?.accessibility
+    }
+  };
+}
+function themeToCssVars(theme) {
+  return {
+    "--player-play-btn-bg": theme.playButtonBackground,
+    "--player-play-btn-icon": theme.playButtonIconColor,
+    "--player-seek-track": theme.seekTrackColor,
+    "--player-seek-progress": theme.seekProgressColor,
+    "--player-seek-buffered": theme.seekBufferedColor,
+    "--player-time": theme.timeColor,
+    "--player-control-icon": theme.controlIconColor,
+    "--player-focus-ring": theme.focusRingColor,
+    "--player-spinner": theme.spinnerColor,
+    "--player-volume-icon": theme.volumeIconColor,
+    "--player-volume-track": theme.volumeTrackColor,
+    "--player-volume-progress": theme.volumeProgressColor,
+    "--player-quality-text": theme.qualityOptionTextColor,
+    "--player-quality-bg": theme.qualityOptionBackground,
+    "--player-quality-active-bg": theme.qualityOptionActiveBackground,
+    "--player-quality-active-text": theme.qualityOptionActiveTextColor,
+    "--player-speed-text": theme.speedOptionTextColor,
+    "--player-speed-bg": theme.speedOptionBackground,
+    "--player-speed-active-bg": theme.speedOptionActiveBackground,
+    "--player-speed-active-text": theme.speedOptionActiveTextColor,
+    "--player-zoom-icon": theme.zoomIconColor,
+    "--player-skip-icon": theme.skipIconColor,
+    "--player-skip-cue-bg": theme.skipCueBackground,
+    "--player-skip-cue-text": theme.skipCueTextColor,
+    "--player-live-dot": theme.liveDotColor
+  };
+}
+
+// src/events/EventEmitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, handler) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(handler);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const handler of set) {
+      try {
+        handler(...args);
+      } catch {
+      }
+    }
+  }
+  removeAll() {
+    this.listeners.clear();
+  }
+};
+
+// src/security/redaction.ts
+var SENSITIVE_KEYS = /^(authorization|cookie|set-cookie|x-api-key|token|accessToken|access_token|clientSecret|password)$/i;
+function redactValue(key, value) {
+  if (SENSITIVE_KEYS.test(key)) return "[REDACTED]";
+  if (typeof value === "string") {
+    if (/^https?:\/\//i.test(value) && /[?&](token|expires)=/i.test(value)) {
+      try {
+        const url = new URL(value);
+        for (const param of ["token", "expires", "signature", "sig"]) {
+          if (url.searchParams.has(param)) {
+            url.searchParams.set(param, "[REDACTED]");
+          }
+        }
+        return url.toString();
+      } catch {
+        return "[REDACTED_URL]";
+      }
+    }
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return redactObject(value);
+  }
+  return value;
+}
+function redactObject(obj) {
+  const out = {};
+  for (const [key, value] of Object.entries(obj)) {
+    out[key] = redactValue(key, value);
+  }
+  return out;
+}
+
+// src/logging/Logger.ts
+var LEVELS = ["silent", "error", "warn", "info", "debug", "trace"];
+var Logger = class {
+  constructor(config) {
+    this.config = config;
+  }
+  update(config) {
+    this.config = { ...this.config, ...config };
+  }
+  shouldLog(level) {
+    if (!this.config.enabled || this.config.level === "silent") return false;
+    return LEVELS.indexOf(level) <= LEVELS.indexOf(this.config.level);
+  }
+  write(level, message, details) {
+    if (!this.shouldLog(level)) return;
+    const payload = details ? redactObject(details) : void 0;
+    const fn = console[level] ?? console.log;
+    if (payload) fn(`[nsg-player] ${message}`, payload);
+    else fn(`[nsg-player] ${message}`);
+  }
+  error(message, details) {
+    this.write("error", message, details);
+  }
+  warn(message, details) {
+    this.write("warn", message, details);
+  }
+  info(message, details) {
+    this.write("info", message, details);
+  }
+  debug(message, details) {
+    this.write("debug", message, details);
+  }
+};
+
+// src/auth/AuthParamsStore.ts
+var AuthParamsStore = class {
+  constructor(initial) {
+    if (initial instanceof URLSearchParams) {
+      this.params = new URLSearchParams(initial);
+    } else if (initial) {
+      this.params = new URLSearchParams(initial);
+    } else {
+      this.params = new URLSearchParams();
+    }
+  }
+  getSnapshot() {
+    return new URLSearchParams(this.params);
+  }
+  toRecord() {
+    const out = {};
+    this.params.forEach((value, key) => {
+      out[key] = value;
+    });
+    return out;
+  }
+  update(next) {
+    this.params = next instanceof URLSearchParams ? new URLSearchParams(next) : new URLSearchParams(next);
+  }
+  applyToUrl(rawUrl, baseOrigin) {
+    const target = new URL(rawUrl, baseOrigin ?? (typeof location !== "undefined" ? location.origin : "http://localhost"));
+    this.params.forEach((value, key) => {
+      target.searchParams.set(key, value);
+    });
+    return target.toString();
+  }
+};
+
+// src/playback/PlaybackSourceManager.ts
+var PlaybackSourceManager = class {
+  constructor(playback, logger) {
+    this.playback = playback;
+    this.logger = logger;
+    this.source = null;
+    this.inFlight = null;
+    this.authParams = new AuthParamsStore();
+  }
+  getSource() {
+    return this.source;
+  }
+  getExpiresAt() {
+    return this.source?.expiresAt ?? null;
+  }
+  async load(context) {
+    if (!this.playback?.getSource) {
+      throw createPlayerError(
+        "INVALID_CONFIGURATION" /* INVALID_CONFIGURATION */,
+        "playback.getSource is required when not using sourceUrl",
+        { category: "config", fatal: true, retryable: false }
+      );
+    }
+    return this.run(context, () => this.playback.getSource(context));
+  }
+  async refresh(context) {
+    const refresher = this.playback?.refreshSource ?? this.playback?.getSource;
+    if (!refresher) {
+      throw createPlayerError(
+        "INVALID_CONFIGURATION" /* INVALID_CONFIGURATION */,
+        "playback.refreshSource or playback.getSource is required",
+        { category: "config", fatal: true, retryable: false }
+      );
+    }
+    return this.run(context, () => refresher(context));
+  }
+  applyDirectSource(source) {
+    this.source = source;
+    this.applyAuthParams(source);
+  }
+  async run(context, fn) {
+    if (this.inFlight) return this.inFlight;
+    this.inFlight = (async () => {
+      try {
+        const next = await fn();
+        if (!next?.url || typeof next.expiresAt !== "number") {
+          throw createPlayerError(
+            "SOURCE_RESOLUTION_FAILED" /* SOURCE_RESOLUTION_FAILED */,
+            "Playback source callback returned an invalid payload",
+            { category: "playback", fatal: true, retryable: true }
+          );
+        }
+        this.source = next;
+        this.applyAuthParams(next);
+        this.logger.debug("Playback source resolved", {
+          reason: context.reason,
+          expiresAt: next.expiresAt
+        });
+        return next;
+      } catch (error) {
+        if (error && typeof error === "object" && "code" in error) throw error;
+        throw createPlayerError(
+          "SOURCE_RESOLUTION_FAILED" /* SOURCE_RESOLUTION_FAILED */,
+          error instanceof Error ? error.message : "Source resolution failed",
+          { category: "playback", fatal: true, retryable: true, cause: error }
+        );
+      } finally {
+        this.inFlight = null;
+      }
+    })();
+    return this.inFlight;
+  }
+  applyAuthParams(source) {
+    if (source.authParams) {
+      this.authParams.update(source.authParams);
+      return;
+    }
+    try {
+      const url = new URL(source.url);
+      const params = {};
+      url.searchParams.forEach((value, key) => {
+        params[key] = value;
+      });
+      if (source.token) params.token = source.token;
+      this.authParams.update(params);
+    } catch {
+      if (source.token) {
+        this.authParams.update({ token: source.token });
+      }
+    }
+  }
+  destroy() {
+    this.source = null;
+    this.inFlight = null;
+  }
+};
+
+// src/playback/RefreshManager.ts
+var RefreshManager = class {
+  constructor(options) {
+    this.options = options;
+    this.timer = null;
+    this.coalesceTimer = null;
+    this.inFlight = false;
+    this.consecutiveFailures = 0;
+    this.stopped = false;
+    this.pendingReason = null;
+  }
+  start(initialExpiresAt) {
+    this.schedule(initialExpiresAt);
+  }
+  requestRenew(reason = "frag_error") {
+    if (this.stopped || this.options.isDestroyed()) return;
+    this.pendingReason = reason;
+    if (this.coalesceTimer) return;
+    this.coalesceTimer = setTimeout(() => {
+      this.coalesceTimer = null;
+      const reasonToUse = this.pendingReason ?? "frag_error";
+      this.pendingReason = null;
+      void this.renew(reasonToUse);
+    }, this.options.coalesceMs);
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) clearTimeout(this.timer);
+    if (this.coalesceTimer) clearTimeout(this.coalesceTimer);
+    this.timer = null;
+    this.coalesceTimer = null;
+  }
+  schedule(expiresAt) {
+    if (this.timer) clearTimeout(this.timer);
+    if (this.stopped) return;
+    const delay = Math.max(
+      5e3,
+      expiresAt - Date.now() - this.options.refreshBeforeExpiryMs
+    );
+    this.timer = setTimeout(() => {
+      void this.renew("proactive");
+    }, delay);
+  }
+  async renew(reason) {
+    if (this.stopped || this.options.isDestroyed() || this.inFlight) {
+      if (this.inFlight) this.pendingReason = reason;
+      return;
+    }
+    this.inFlight = true;
+    this.options.onRenewing?.();
+    try {
+      await this.options.authManager.ensureToken({
+        reason: reason === "proactive" ? "expiring" : "unauthorized",
+        videoId: this.options.videoId
+      });
+      const source = await this.options.sourceManager.refresh({
+        videoId: this.options.videoId,
+        reason: reason === "proactive" ? "expiring" : reason === "manual" ? "manual" : "auth_error"
+      });
+      this.consecutiveFailures = 0;
+      this.options.onRenewed?.(source.expiresAt);
+      this.schedule(source.expiresAt);
+      this.options.logger.debug("Playback source renewed", { reason });
+    } catch (error) {
+      this.consecutiveFailures += 1;
+      const message = error instanceof Error ? error.message : "Playback refresh failed";
+      this.options.logger.warn("Playback refresh failed", {
+        reason,
+        failure: this.consecutiveFailures
+      });
+      if (this.consecutiveFailures >= this.options.renewMaxRetries) {
+        this.options.onFatal?.(message);
+      } else {
+        const backoff = this.options.renewBackoffMs * this.consecutiveFailures;
+        this.timer = setTimeout(() => {
+          void this.renew(reason);
+        }, backoff);
+      }
+    } finally {
+      this.inFlight = false;
+      if (this.pendingReason && !this.stopped) {
+        const pending = this.pendingReason;
+        this.pendingReason = null;
+        void this.renew(pending);
+      }
+    }
+  }
+};
+
+// src/playback/liveEdge.ts
+var DEFAULT_LIVE_EDGE_TOLERANCE_SECONDS = 3;
+function getLiveEdgeTime(media) {
+  const { seekable, duration } = media;
+  try {
+    if (seekable.length > 0) {
+      const end = seekable.end(seekable.length - 1);
+      if (Number.isFinite(end) && end >= 0) {
+        return end;
+      }
+    }
+  } catch {
+  }
+  if (Number.isFinite(duration) && duration > 0) {
+    return duration;
+  }
+  return null;
+}
+function isAtLiveEdge(media, toleranceSeconds = DEFAULT_LIVE_EDGE_TOLERANCE_SECONDS) {
+  const edge = getLiveEdgeTime(media);
+  if (edge === null) {
+    return true;
+  }
+  const lag = edge - media.currentTime;
+  return lag <= Math.max(0, toleranceSeconds);
+}
+function seekToLiveEdge(media, options) {
+  const tolerance = options?.toleranceSeconds ?? DEFAULT_LIVE_EDGE_TOLERANCE_SECONDS;
+  const edgeOffset = options?.edgeOffsetSeconds ?? 0.25;
+  const edge = getLiveEdgeTime(media);
+  if (edge === null) {
+    return { moved: false, reason: "edge_unavailable", edge: null };
+  }
+  if (isAtLiveEdge(media, tolerance)) {
+    return { moved: false, reason: "already_at_live", edge };
+  }
+  const target = Math.max(0, edge - edgeOffset);
+  media.currentTime = target;
+  return { moved: true, edge };
+}
+
+// src/streaming/HlsEngine.ts
+var HlsEngine = class {
+  constructor(options) {
+    this.options = options;
+    this.hls = null;
+    this.destroyed = false;
+    this.supportMode = "unsupported";
+    this.networkRecoveryCount = 0;
+    this.mediaRecoveryCount = 0;
+    this.qualities = [];
+    this.qualitySelection = "auto";
+  }
+  async start() {
+    const { videoEl, playbackUrl, autoplay, startMuted, volume, startPosition } = this.options;
+    videoEl.muted = startMuted;
+    if (typeof volume === "number") videoEl.volume = Math.min(1, Math.max(0, volume));
+    const Hls = (await import("hls.js")).default;
+    if (Hls.isSupported()) {
+      this.supportMode = "hls.js";
+      this.options.callbacks.onSupportMode?.("hls.js");
+      await this.startWithHlsJs(Hls, playbackUrl);
+    } else if (videoEl.canPlayType("application/vnd.apple.mpegurl")) {
+      this.supportMode = "native";
+      this.options.callbacks.onSupportMode?.("native");
+      videoEl.src = this.options.authParams.applyToUrl(playbackUrl);
+      this.bindMediaEvents();
+      this.options.callbacks.onStateChange?.("ready");
+    } else {
+      this.supportMode = "unsupported";
+      this.options.callbacks.onSupportMode?.("unsupported");
+      this.options.callbacks.onFatalError?.("HLS is not supported in this browser");
+      return;
+    }
+    if (typeof startPosition === "number" && startPosition > 0) {
+      videoEl.currentTime = startPosition;
+    }
+    if (autoplay) {
+      try {
+        await videoEl.play();
+      } catch {
+        if (!videoEl.muted) {
+          videoEl.muted = true;
+          try {
+            await videoEl.play();
+          } catch {
+            this.options.logger.warn("Autoplay blocked");
+          }
+        }
+      }
+    }
+  }
+  async startWithHlsJs(Hls, playbackUrl) {
+    const { videoEl, authParams, hlsConfig, callbacks } = this.options;
+    this.hls = new Hls({
+      enableWorker: hlsConfig.enableWorker,
+      lowLatencyMode: hlsConfig.lowLatencyMode,
+      backBufferLength: hlsConfig.backBufferLength,
+      xhrSetup: (xhr, url) => {
+        void xhr;
+        void url;
+      }
+    });
+    this.hls.attachMedia(videoEl);
+    this.hls.loadSource(authParams.applyToUrl(playbackUrl));
+    this.hls.on(Hls.Events.MANIFEST_PARSED, (_event, data) => {
+      this.qualities = (data.levels ?? []).map((level, index) => ({
+        index,
+        height: level.height ?? 0,
+        width: level.width ?? 0,
+        bitrate: level.bitrate ?? 0,
+        label: level.height != null && level.height > 0 ? `${level.height}p` : `Level ${index}`
+      }));
+      callbacks.onQualitiesChange?.(this.qualities);
+      callbacks.onStateChange?.("ready");
+    });
+    this.hls.on(Hls.Events.ERROR, (_event, data) => {
+      if (!data.fatal) {
+        if (data.type === Hls.ErrorTypes.NETWORK_ERROR && (data.details === Hls.ErrorDetails.FRAG_LOAD_ERROR || data.details === Hls.ErrorDetails.LEVEL_LOAD_ERROR || data.details === Hls.ErrorDetails.KEY_LOAD_ERROR)) {
+          callbacks.onAuthRecoveryNeeded?.(
+            data.details === Hls.ErrorDetails.KEY_LOAD_ERROR ? "key_error" : data.details === Hls.ErrorDetails.LEVEL_LOAD_ERROR ? "level_error" : "frag_error"
+          );
+        }
+        return;
+      }
+      if (data.type === Hls.ErrorTypes.NETWORK_ERROR) {
+        this.networkRecoveryCount += 1;
+        if (this.networkRecoveryCount <= hlsConfig.fatalRecoveryLimit) {
+          callbacks.onAuthRecoveryNeeded?.("fatal_network");
+          this.hls?.startLoad();
+          return;
+        }
+      }
+      if (data.type === Hls.ErrorTypes.MEDIA_ERROR) {
+        this.mediaRecoveryCount += 1;
+        if (this.mediaRecoveryCount <= hlsConfig.fatalRecoveryLimit) {
+          this.hls?.recoverMediaError();
+          return;
+        }
+      }
+      callbacks.onFatalError?.(data.details || "Fatal HLS error");
+    });
+    this.bindMediaEvents();
+  }
+  bindMediaEvents() {
+    const { videoEl, callbacks } = this.options;
+    videoEl.addEventListener("playing", () => callbacks.onStateChange?.("playing"));
+    videoEl.addEventListener("pause", () => {
+      if (!videoEl.ended) callbacks.onStateChange?.("paused");
+    });
+    videoEl.addEventListener("waiting", () => callbacks.onStateChange?.("buffering"));
+    videoEl.addEventListener("ended", () => {
+      callbacks.onStateChange?.("ended");
+      callbacks.onEnded?.();
+    });
+  }
+  updateAuthParams() {
+    if (this.supportMode === "native" && this.options.videoEl) {
+      const time = this.options.videoEl.currentTime;
+      const wasPaused = this.options.videoEl.paused;
+      this.options.videoEl.src = this.options.authParams.applyToUrl(
+        this.options.playbackUrl
+      );
+      this.options.videoEl.currentTime = time;
+      if (!wasPaused) void this.options.videoEl.play();
+    }
+  }
+  resumeAfterAuthRenew() {
+    this.hls?.startLoad();
+    this.updateAuthParams();
+  }
+  setQuality(selection) {
+    this.qualitySelection = selection;
+    if (!this.hls) return;
+    this.hls.currentLevel = selection === "auto" ? -1 : selection;
+    this.options.callbacks.onQualitySelectionChange?.(selection);
+  }
+  getQuality() {
+    return this.qualitySelection;
+  }
+  getQualities() {
+    return this.qualities;
+  }
+  getSupportMode() {
+    return this.supportMode;
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.hls?.destroy();
+    this.hls = null;
+    const { videoEl } = this.options;
+    videoEl.removeAttribute("src");
+    videoEl.load();
+  }
+};
+
+// src/player/createVideoPlayer.ts
+function expiryStatus(expiresAt, safetyMs) {
+  if (expiresAt === null || expiresAt <= 0) return "unknown";
+  const remaining = expiresAt - Date.now();
+  if (remaining <= 0) return "expired";
+  if (remaining <= safetyMs) return "expiring_soon";
+  return "valid";
+}
+function generateSessionId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `ps_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function createVideoPlayer(options) {
+  assertNoSecretsInConfig(options);
+  let config = mergePlayerConfig({
+    player: options.player,
+    controls: options.controls,
+    theme: options.theme,
+    watermark: options.watermark,
+    streaming: options.streaming,
+    logging: options.logging,
+    debug: options.debug,
+    accessibility: options.accessibility
+  });
+  const events = new EventEmitter();
+  const logger = new Logger(config.logging);
+  const playbackSessionId = generateSessionId();
+  let state = "idle";
+  let destroyed = false;
+  let lastError = null;
+  let videoEl = options.mount ?? null;
+  let engine = null;
+  let refreshManager = null;
+  let fullscreenEl = null;
+  let isLiveStream = false;
+  const setState = (next) => {
+    if (destroyed && next !== "destroyed") return;
+    state = next;
+    events.emit("statechange", { state: next });
+  };
+  const authManager = new AuthManager(
+    options.auth,
+    options.auth?.refreshBeforeExpiryMs ?? 6e4,
+    logger,
+    (token) => events.emit("authrefresh", { expiresAt: token.expiresAt }),
+    (message, retryable) => events.emit("autherror", { message, retryable })
+  );
+  const sourceManager = new PlaybackSourceManager(options.playback, logger);
+  const ensureVideoElement = () => {
+    if (!videoEl) {
+      throw createPlayerError(
+        "INVALID_CONFIGURATION" /* INVALID_CONFIGURATION */,
+        "A video element must be provided via mount before starting playback",
+        { category: "config", fatal: true, retryable: false }
+      );
+    }
+    return videoEl;
+  };
+  const startPlayback = async () => {
+    if (destroyed) return;
+    setState("loading");
+    lastError = null;
+    const videoId = options.videoId ?? "unknown";
+    try {
+      await authManager.ensureToken({
+        reason: "initial",
+        videoId: options.videoId
+      });
+      let playbackUrl;
+      let expiresAt;
+      if (options.sourceUrl) {
+        const source = {
+          url: options.sourceUrl,
+          expiresAt: Date.now() + 24 * 60 * 60 * 1e3,
+          live: /\/hls-web-live\//i.test(options.sourceUrl)
+        };
+        sourceManager.applyDirectSource(source);
+        playbackUrl = source.url;
+        expiresAt = source.expiresAt;
+        isLiveStream = Boolean(source.live);
+      } else {
+        const source = await sourceManager.load({
+          videoId,
+          reason: "initial"
+        });
+        playbackUrl = source.url;
+        expiresAt = source.expiresAt;
+        isLiveStream = Boolean(source.live);
+      }
+      const el = ensureVideoElement();
+      engine?.destroy();
+      engine = new HlsEngine({
+        videoEl: el,
+        playbackUrl,
+        authParams: sourceManager.authParams,
+        autoplay: config.player.autoplay,
+        startMuted: config.player.startMuted,
+        startPosition: config.player.startPosition,
+        volume: config.player.volume,
+        hlsConfig: config.streaming.hls,
+        logger,
+        callbacks: {
+          onStateChange: (s) => {
+            setState(s);
+            if (s === "ready") events.emit("ready");
+            if (s === "playing") {
+              events.emit("play");
+              events.emit("playing");
+            }
+            if (s === "paused") events.emit("pause");
+            if (s === "buffering") events.emit("buffering");
+            if (s === "ended") events.emit("ended");
+          },
+          onFatalError: (message) => {
+            lastError = createPlayerError(
+              "PLAYBACK_ERROR" /* PLAYBACK_ERROR */,
+              message,
+              { category: "playback", fatal: true, retryable: true }
+            );
+            setState("error");
+            events.emit("error", {
+              code: lastError.code,
+              message: lastError.message,
+              fatal: true
+            });
+          },
+          onAuthRecoveryNeeded: (reason) => {
+            refreshManager?.requestRenew(
+              reason
+            );
+          },
+          onQualitiesChange: () => {
+          },
+          onQualitySelectionChange: (selection) => {
+            const level = engine?.getQualities().find((q) => q.index === selection);
+            events.emit("qualitychange", {
+              selection,
+              label: typeof selection === "number" ? level?.label : "auto"
+            });
+          },
+          onEnded: () => events.emit("ended")
+        }
+      });
+      await engine.start();
+      if (!options.sourceUrl && options.playback) {
+        refreshManager?.stop();
+        refreshManager = new RefreshManager({
+          videoId,
+          authManager,
+          sourceManager,
+          refreshBeforeExpiryMs: options.playback.refreshBeforeExpiryMs ?? 3e4,
+          renewMaxRetries: options.playback.renewMaxRetries ?? 3,
+          renewBackoffMs: options.playback.renewBackoffMs ?? 2e3,
+          coalesceMs: options.playback.authRecoveryCoalesceMs ?? 1e3,
+          logger,
+          isDestroyed: () => destroyed,
+          onRenewing: () => setState("renewing"),
+          onRenewed: (nextExpiresAt) => {
+            engine?.resumeAfterAuthRenew();
+            events.emit("tokenrefresh", { expiresAt: nextExpiresAt });
+            events.emit("sourcechange", { expiresAt: nextExpiresAt });
+          },
+          onFatal: (message) => {
+            lastError = createPlayerError(
+              "TOKEN_REFRESH_FAILED" /* TOKEN_REFRESH_FAILED */,
+              message,
+              { category: "auth", fatal: true, retryable: true }
+            );
+            setState("error");
+            events.emit("error", {
+              code: lastError.code,
+              message: lastError.message,
+              fatal: true
+            });
+          }
+        });
+        refreshManager.start(expiresAt);
+      }
+      options.analytics?.onEvent?.({
+        type: "PLAYER_INITIALIZED",
+        payload: { videoId, playbackSessionId }
+      });
+    } catch (error) {
+      const playerError = error && typeof error === "object" && "code" in error ? error : createPlayerError(
+        "UNKNOWN" /* UNKNOWN */,
+        error instanceof Error ? error.message : "Failed to start player",
+        { category: "unknown", fatal: true, retryable: true, cause: error }
+      );
+      lastError = playerError;
+      setState("error");
+      events.emit("error", {
+        code: playerError.code,
+        message: playerError.message,
+        fatal: playerError.fatal
+      });
+      throw playerError;
+    }
+  };
+  if (options.mount) {
+    void startPlayback().catch(() => {
+    });
+  }
+  const api = {
+    async play() {
+      await ensureVideoElement().play();
+    },
+    pause() {
+      ensureVideoElement().pause();
+    },
+    seek(time) {
+      const el = ensureVideoElement();
+      const duration = Number.isFinite(el.duration) ? el.duration : time;
+      el.currentTime = Math.min(Math.max(0, time), duration);
+    },
+    goToLive() {
+      const el = ensureVideoElement();
+      return seekToLiveEdge(el);
+    },
+    isLive() {
+      return isLiveStream;
+    },
+    isAtLiveEdge() {
+      if (!isLiveStream || !videoEl) {
+        return true;
+      }
+      return isAtLiveEdge(videoEl);
+    },
+    getCurrentTime() {
+      return videoEl?.currentTime ?? 0;
+    },
+    getDuration() {
+      return videoEl?.duration ?? 0;
+    },
+    setVolume(volume) {
+      const el = ensureVideoElement();
+      el.volume = Math.min(1, Math.max(0, volume));
+      events.emit("volumechange", { volume: el.volume, muted: el.muted });
+    },
+    getVolume() {
+      return videoEl?.volume ?? 0;
+    },
+    mute() {
+      const el = ensureVideoElement();
+      el.muted = true;
+      events.emit("volumechange", { volume: el.volume, muted: true });
+    },
+    unmute() {
+      const el = ensureVideoElement();
+      el.muted = false;
+      events.emit("volumechange", { volume: el.volume, muted: false });
+    },
+    isMuted() {
+      return videoEl?.muted ?? false;
+    },
+    setPlaybackRate(rate) {
+      ensureVideoElement().playbackRate = rate;
+    },
+    getPlaybackRate() {
+      return videoEl?.playbackRate ?? 1;
+    },
+    getState() {
+      return state;
+    },
+    getBufferedRanges() {
+      const el = videoEl;
+      if (!el) return [];
+      const ranges = [];
+      for (let i = 0; i < el.buffered.length; i += 1) {
+        ranges.push({ start: el.buffered.start(i), end: el.buffered.end(i) });
+      }
+      return ranges;
+    },
+    getQuality() {
+      return engine?.getQuality() ?? "auto";
+    },
+    setQuality(selection) {
+      if (selection === "auto") {
+        engine?.setQuality("auto");
+        return;
+      }
+      if (typeof selection === "number") {
+        engine?.setQuality(selection);
+        return;
+      }
+      const match = engine?.getQualities().find((q) => q.label === selection || `${q.height}p` === selection);
+      if (match) engine?.setQuality(match.index);
+    },
+    getAvailableQualities() {
+      return engine?.getQualities() ?? [];
+    },
+    async enterFullscreen() {
+      const target = fullscreenEl ?? videoEl?.parentElement ?? videoEl;
+      if (target && "requestFullscreen" in target) {
+        await target.requestFullscreen();
+        events.emit("fullscreenchange", { isFullscreen: true });
+      }
+    },
+    async exitFullscreen() {
+      if (document.fullscreenElement) {
+        await document.exitFullscreen();
+        events.emit("fullscreenchange", { isFullscreen: false });
+      }
+    },
+    isFullscreen() {
+      return Boolean(document.fullscreenElement);
+    },
+    async reload() {
+      refreshManager?.stop();
+      engine?.destroy();
+      await startPlayback();
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      refreshManager?.stop();
+      refreshManager = null;
+      engine?.destroy();
+      engine = null;
+      authManager.destroy();
+      sourceManager.destroy();
+      setState("destroyed");
+      events.emit("destroy");
+      events.removeAll();
+      options.analytics?.onEvent?.({ type: "PLAYER_DESTROYED" });
+    },
+    getDiagnostics() {
+      const buffered = api.getBufferedRanges();
+      return {
+        playerVersion: PACKAGE_VERSION,
+        currentState: state,
+        hlsSupport: engine?.getSupportMode() ?? "unsupported",
+        videoId: options.videoId ?? null,
+        currentTime: api.getCurrentTime(),
+        duration: api.getDuration(),
+        bufferedEnd: buffered.length ? buffered[buffered.length - 1].end : 0,
+        currentQuality: api.getQuality() === "auto" ? "auto" : engine?.getQualities().find((q) => q.index === api.getQuality())?.label ?? null,
+        playbackSessionId,
+        authExpiryStatus: expiryStatus(
+          authManager.getExpiresAt(),
+          options.auth?.refreshBeforeExpiryMs ?? 6e4
+        ),
+        sourceExpiryStatus: expiryStatus(
+          sourceManager.getExpiresAt(),
+          options.playback?.refreshBeforeExpiryMs ?? 3e4
+        ),
+        lastError: lastError?.message ?? null
+      };
+    },
+    getConfig() {
+      return config;
+    },
+    updateConfig(partial) {
+      config = mergePlayerConfig({
+        player: { ...config.player, ...partial?.player },
+        controls: { ...config.controls, ...partial?.controls },
+        theme: { ...config.theme, ...partial?.theme },
+        watermark: { ...config.watermark, ...partial?.watermark },
+        streaming: {
+          engine: "hls",
+          hls: { ...config.streaming.hls, ...partial?.streaming?.hls }
+        },
+        logging: { ...config.logging, ...partial?.logging },
+        debug: { ...config.debug, ...partial?.debug },
+        accessibility: {
+          ...config.accessibility,
+          ...partial?.accessibility
+        }
+      });
+      logger.update(config.logging);
+    },
+    on: events.on.bind(events),
+    off: events.off.bind(events)
+  };
+  api.attach = async (el, container) => {
+    videoEl = el;
+    fullscreenEl = container ?? null;
+    await startPlayback();
+  };
+  return api;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthManager,
+  AuthParamsStore,
+  DEFAULT_CONTROLS,
+  DEFAULT_LIVE_EDGE_TOLERANCE_SECONDS,
+  DEFAULT_PLAYER_BEHAVIOR,
+  DEFAULT_PLAYER_CONFIG,
+  DEFAULT_THEME,
+  DEFAULT_WATERMARK,
+  EventEmitter,
+  PACKAGE_VERSION,
+  PLAYBACK_RATES,
+  PlaybackSourceManager,
+  PlayerErrorCode,
+  RefreshManager,
+  assertNoSecretsInConfig,
+  createPlayerError,
+  createVideoPlayer,
+  getLiveEdgeTime,
+  isAtLiveEdge,
+  mergePlayerConfig,
+  redactObject,
+  redactSensitive,
+  redactValue,
+  seekToLiveEdge,
+  themeToCssVars
+});
+//# sourceMappingURL=index.cjs.map