@gcorevideo/player 2.28.25 → 2.28.27

package/dist/core.js

@@ -1,4 +1,4 @@
-const APP_NAME = "gplayer";
+const APP_NAME = '_';
 class DebuggerWrapper {
     writer;
     namespace;
@@ -15,19 +15,19 @@ class DebuggerWrapper {
         this.currentWriter = nullWriter;
     }
     write = (m, ...args) => {
-        const tokens = args.map((_) => "%s");
-        if (typeof m === "string" || args.length > 0) {
-            tokens.unshift("%s");
+        const tokens = args.map((_) => '%s');
+        if (typeof m === 'string' || args.length > 0) {
+            tokens.unshift('%s');
         }
-        this.currentWriter(`${this.namespace}: ${tokens.join(' ')}`, m, ...args.map(a => JSON.stringify(a)));
+        this.currentWriter(`${this.namespace}: ${tokens.join(' ')}`, m, ...args.map((a) => JSON.stringify(a)));
     };
 }
 const currentPatterns = [];
 function parsePattern(pattern) {
-    if (pattern === "*") {
+    if (pattern === '*') {
         return /.?/;
     }
-    return new RegExp("^" + pattern.replace(/\*/g, "[@\\w-]+"), "i");
+    return new RegExp('^' + pattern.replace(/\*/g, '[@\\w-]+'), 'i');
 }
 function pass(namespace) {
     return currentPatterns.some((p) => p.test(namespace));
@@ -43,8 +43,8 @@ let Logger$1 = class Logger {
     error;
     debug;
     static items = [];
-    constructor(namespace, appName = APP_NAME) {
-        const ns = namespace ? `:${namespace}` : "";
+    constructor(appName = APP_NAME, namespace = '') {
+        const ns = namespace ? `:${namespace}` : '';
         const info = new DebuggerWrapper(console.info.bind(console), `${appName}:INFO${ns}`, pass(namespace));
         this.info = info.write;
         const warn = new DebuggerWrapper(console.warn.bind(console), `${appName}:WARN${ns}`, pass(namespace));
@@ -62,7 +62,7 @@ let Logger$1 = class Logger {
      * @param patterns - comma-separated list of patterns, can contain '*' as a wildcard
      */
     static enable(patterns) {
-        currentPatterns.splice(0, currentPatterns.length, ...patterns.split(",").filter(Boolean).map(parsePattern));
+        currentPatterns.splice(0, currentPatterns.length, ...patterns.split(',').filter(Boolean).map(parsePattern));
         Logger.toggleItems();
     }
     static disable() {
@@ -80,14 +80,35 @@ let Logger$1 = class Logger {
     }
 };
 
+/**
+ * A tracer that pushes a record through a chain of tracers
+ * @beta
+ */
+class ChainedTracer {
+    tracers;
+    constructor(tracers) {
+        this.tracers = tracers;
+    }
+    reportError(e) {
+        for (const tracer of this.tracers) {
+            tracer.reportError(e);
+        }
+    }
+    trace(msg, data) {
+        for (const tracer of this.tracers) {
+            tracer.trace(msg, data);
+        }
+    }
+}
+
 /**
  * A tracer that logs to the console
  * @public
  */
 class LogTracer {
     logger;
-    constructor(ns = "") {
-        this.logger = new Logger$1(ns);
+    constructor(appName = '') {
+        this.logger = new Logger$1(appName);
     }
     reportError(e) {
         this.logger.error(e);
@@ -96,19 +117,73 @@ class LogTracer {
         this.logger.debug(msg, data);
     }
 }
-// export class LogTracer implements Tracer {
-//   private tags: Record<string, TagValue> = {};
-//   reportError(e: Error) {
-//     logger.error(e, this.tags);
-//   }
-//   setTag(name: string, value: TagValue) {
-//     this.tags[name] = value;
-//   }
-//   trace(msg: string, data?: Record<string, unknown>) {
-//     const fullData = Object.assign({}, this.tags, data);
-//     logger.debug(msg, fullData);
-//   }
-// }
+
+const DEFAULT_DELAY = 1000;
+const MIN_DELAY = 1000;
+/**
+ * A tracer the pushes the records to a remote server.
+ * Used with fullstack Node.js applications (Nuxt.js, Next.js, etc.)
+ * @beta
+ */
+class RemoteTracer {
+    baseTracer;
+    tags;
+    buffer = [];
+    timerId = null;
+    delay;
+    /**
+     *
+     * @param baseTracer An additional tracer to be called next to this one. Deprecated. Use {@link ChainedTracer} instead.
+     * @param tags
+     * @param options
+     */
+    constructor(baseTracer, tags = {}, options = {}) {
+        this.baseTracer = baseTracer;
+        this.tags = tags;
+        this.delay = Math.max(options.delay ?? DEFAULT_DELAY, MIN_DELAY);
+    }
+    reportError(e) {
+        if (this.baseTracer) {
+            this.baseTracer.reportError(e);
+        }
+        const message = String(e);
+        const detail = e instanceof Error && 'detail' in e
+            ? e.detail
+            : undefined;
+        this.push(message, detail);
+    }
+    trace(message, detail) {
+        if (this.baseTracer) {
+            this.baseTracer.trace(message, detail);
+        }
+        this.push(message, detail);
+    }
+    setTag(key, value) {
+        this.tags[key] = value;
+    }
+    push(message, detail) {
+        const time = new Date().getTime();
+        this.buffer.push({ message, detail, time });
+        if (!this.timerId) {
+            this.timerId = setTimeout(() => {
+                this.timerId = null;
+                this.send(this.buffer.splice(0, this.buffer.length));
+            }, this.delay);
+        }
+    }
+    send(records) {
+        fetch('/api/traceb', {
+            method: 'POST',
+            body: JSON.stringify({
+                records,
+                tags: this.tags,
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        }).catch((e) => console.error(e));
+    }
+}
 
 /**
  * @beta
@@ -125,8 +200,8 @@ class SentryTracer {
     }
     trace(message, data) {
         this.scope.addBreadcrumb({
-            type: "default",
-            level: "info",
+            type: 'default',
+            level: 'info',
             message,
             data,
         });
@@ -12621,9 +12696,7 @@ function buildMediaSourcesList(sources, priorityTransport = 'dash') {
     }
     const [preferred, rest] = sources.reduce(([preferred, rest], item) => {
         for (const p of playbacks) {
-            if ([
-                'html5_audio', 'html_img', 'no_op'
-            ].includes(p.prototype.name)) {
+            if (['html5_audio', 'html_img', 'no_op'].includes(p.prototype.name)) {
                 continue;
             }
             const canPlay = p.canPlay(item.source, item.mimeType);
@@ -13799,7 +13872,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.14"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.15"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -18245,11 +18318,7 @@ class FragmentTracker {
     });
     fragmentEntity.loaded = null;
     if (Object.keys(fragmentEntity.range).length) {
-      fragmentEntity.buffered = true;
-      const endList = fragmentEntity.body.endList = frag.endList || fragmentEntity.body.endList;
-      if (endList) {
-        this.endListFragments[fragmentEntity.body.type] = fragmentEntity;
-      }
+      this.bufferedEnd(fragmentEntity, frag);
       if (!isPartial(fragmentEntity)) {
         // Remove older fragment parts from lookup after frag is tracked as buffered
         this.removeParts(frag.sn - 1, frag.type);
@@ -18259,6 +18328,13 @@ class FragmentTracker {
       this.removeFragment(fragmentEntity.body);
     }
   }
+  bufferedEnd(fragmentEntity, frag) {
+    fragmentEntity.buffered = true;
+    const endList = fragmentEntity.body.endList = frag.endList || fragmentEntity.body.endList;
+    if (endList) {
+      this.endListFragments[fragmentEntity.body.type] = fragmentEntity;
+    }
+  }
   removeParts(snToKeep, levelType) {
     const activeParts = this.activePartLists[levelType];
     if (!activeParts) {
@@ -18283,7 +18359,7 @@ class FragmentTracker {
     }
     if (fragmentEntity) {
       fragmentEntity.loaded = null;
-      fragmentEntity.buffered = true;
+      this.bufferedEnd(fragmentEntity, frag);
     }
   }
   getBufferedTimes(fragment, part, partial, timeRange) {
@@ -20332,6 +20408,14 @@ class LevelKey {
   static setKeyIdForUri(uri, keyId) {
     keyUriToKeyIdMap[uri] = keyId;
   }
+  static addKeyIdForUri(uri) {
+    const val = Object.keys(keyUriToKeyIdMap).length % Number.MAX_SAFE_INTEGER;
+    const keyId = new Uint8Array(16);
+    const dv = new DataView(keyId.buffer, 12, 4); // Just set the last 4 bytes
+    dv.setUint32(0, val);
+    keyUriToKeyIdMap[uri] = keyId;
+    return keyId;
+  }
   constructor(method, uri, format, formatversions = [1], iv = null, keyId) {
     this.uri = void 0;
     this.method = void 0;
@@ -22496,7 +22580,7 @@ class BaseStreamController extends TaskLoop {
     this.state = State.FRAG_LOADING;
 
     // Load key before streaming fragment data
-    const dataOnProgress = this.config.progressive;
+    const dataOnProgress = this.config.progressive && frag.type !== PlaylistLevelType.SUBTITLE;
     let result;
     if (dataOnProgress && keyLoadingPromise) {
       result = keyLoadingPromise.then(keyLoadedData => {
@@ -23344,11 +23428,12 @@ class BaseStreamController extends TaskLoop {
     }, false);
     if (!parsed) {
       var _this$transmuxer;
-      if (level.fragmentError === 0) {
-        // Mark and track the odd empty segment as a gap to avoid reloading
+      const mediaNotFound = ((_this$transmuxer = this.transmuxer) == null ? void 0 : _this$transmuxer.error) === null;
+      if (level.fragmentError === 0 || mediaNotFound && (level.fragmentError < 2 || frag.endList)) {
+        // Mark and track the odd (or last) empty segment as a gap to avoid reloading
         this.treatAsGap(frag, level);
       }
-      if (((_this$transmuxer = this.transmuxer) == null ? void 0 : _this$transmuxer.error) === null) {
+      if (mediaNotFound) {
         const error = new Error(`Found no media in fragment ${frag.sn} of ${this.playlistLabel()} ${frag.level} resetting transmuxer to fallback to playlist timing`);
         this.warn(error.message);
         this.hls.trigger(Events.ERROR, {
@@ -23809,7 +23894,7 @@ function requireEventemitter3 () {
 var eventemitter3Exports = requireEventemitter3();
 var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
-const version$2 = "1.6.14";
+const version$2 = "1.6.15";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -28987,7 +29072,7 @@ class MP4Remuxer extends Logger {
     // Clear the track samples. This also clears the samples array in the demuxer, since the reference is shared
     track.samples = [];
     const start = (firstPTS - initTime) / inputTimeScale;
-    const end = nextAudioTs / inputTimeScale;
+    const end = this.nextAudioTs / inputTimeScale;
     const type = 'audio';
     const audioData = {
       data1: moof,
@@ -36151,6 +36236,11 @@ class EMEController extends Logger {
       }
       const keyIdArray = 'buffer' in keyId ? new Uint8Array(keyId.buffer, keyId.byteOffset, keyId.byteLength) : new Uint8Array(keyId);
       if (mediaKeySessionContext.keySystem === KeySystems.PLAYREADY && keyIdArray.length === 16) {
+        // On some devices, the key ID has already been converted for endianness.
+        // In such cases, this key ID is the one we need to cache.
+        const originKeyIdWithStatusChange = arrayToHex(keyIdArray);
+        // Cache the original key IDs to ensure compatibility across all cases.
+        keyStatuses[originKeyIdWithStatusChange] = status;
         changeEndianness(keyIdArray);
       }
       const keyIdWithStatusChange = arrayToHex(keyIdArray);
@@ -38492,7 +38582,8 @@ class InterstitialsController extends Logger {
       if (backwardSeek && currentTime < start || currentTime >= start + duration) {
         var _playingItem$event;
         if ((_playingItem$event = playingItem.event) != null && _playingItem$event.appendInPlace) {
-          this.clearInterstitial(playingItem.event, playingItem);
+          // Return SourceBuffer(s) to primary player and flush
+          this.clearAssetPlayers(playingItem.event, playingItem);
           this.flushFrontBuffer(currentTime);
         }
         this.setScheduleToAssetAtTime(currentTime, playingAsset);
@@ -40202,11 +40293,14 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
     return player;
   }
   clearInterstitial(interstitial, toSegment) {
+    this.clearAssetPlayers(interstitial, toSegment);
+    // Remove asset list and resolved duration
+    interstitial.reset();
+  }
+  clearAssetPlayers(interstitial, toSegment) {
     interstitial.assetList.forEach(asset => {
       this.clearAssetPlayer(asset.identifier, toSegment);
     });
-    // Remove asset list and resolved duration
-    interstitial.reset();
   }
   resetAssetPlayer(assetId) {
     // Reset asset player so that it's timeline can be adjusted without reloading the MVP
@@ -40398,10 +40492,10 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
     // Fallback to Primary by on current or future events by updating schedule to skip errored interstitials/assets
     const flushStart = interstitial.timelineStart;
     const playingItem = this.effectivePlayingItem;
+    let timelinePos = this.timelinePos;
     // Update schedule now that interstitial/assets are flagged with `error` for fallback
     if (playingItem) {
-      this.log(`Fallback to primary from event "${interstitial.identifier}" start: ${flushStart} pos: ${this.timelinePos} playing: ${segmentToString(playingItem)} error: ${interstitial.error}`);
-      let timelinePos = this.timelinePos;
+      this.log(`Fallback to primary from event "${interstitial.identifier}" start: ${flushStart} pos: ${timelinePos} playing: ${segmentToString(playingItem)} error: ${interstitial.error}`);
       if (timelinePos === -1) {
         timelinePos = this.hls.startPosition;
       }
@@ -40413,14 +40507,15 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
         this.attachPrimary(flushStart, null);
         this.flushFrontBuffer(flushStart);
       }
-      if (!this.schedule) {
-        return;
-      }
-      const scheduleIndex = this.schedule.findItemIndexAtTime(timelinePos);
-      this.setSchedulePosition(scheduleIndex);
-    } else {
+    } else if (timelinePos === -1) {
       this.checkStart();
+      return;
     }
+    if (!this.schedule) {
+      return;
+    }
+    const scheduleIndex = this.schedule.findItemIndexAtTime(timelinePos);
+    this.setSchedulePosition(scheduleIndex);
   }
 
   // Asset List loading
@@ -40461,7 +40556,8 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
           // Abandon if new duration is reduced enough to land playback in primary start
           const index = this.schedule.findItemIndexAtTime(this.timelinePos);
           if (index !== scheduleIndex) {
-            interstitial.error = new Error(`Interstitial no longer within playback range ${this.timelinePos} ${interstitial}`);
+            interstitial.error = new Error(`Interstitial ${assets.length ? 'no longer within playback range' : 'asset-list is empty'} ${this.timelinePos} ${interstitial}`);
+            this.log(interstitial.error.message);
             this.updateSchedule(true);
             this.primaryFallback(interstitial);
             return;
@@ -47269,7 +47365,7 @@ class StreamController extends BaseStreamController {
   onAudioTrackSwitching(event, data) {
     const hls = this.hls;
     // if any URL found on new audio track, it is an alternate audio track
-    const fromAltAudio = this.altAudio === 2;
+    const fromAltAudio = this.altAudio !== 0;
     const altAudio = useAlternateAudio(data.url, hls);
     // if we switch on main audio, ensure that main fragment scheduling is synced with media.buffered
     // don't do anything if we switch to alt audio: audio stream controller is handling it.
@@ -47295,6 +47391,7 @@ class StreamController extends BaseStreamController {
       }
       // If switching from alt to main audio, flush all audio and trigger track switched
       if (fromAltAudio) {
+        this.altAudio = 0;
         this.fragmentTracker.removeAllFragments();
         hls.once(Events.BUFFER_FLUSHED, () => {
           if (!this.hls) {
@@ -48132,14 +48229,22 @@ class KeyLoader extends Logger {
       if (!keyInfo.decryptdata.keyId && (_frag$initSegment = frag.initSegment) != null && _frag$initSegment.data) {
         const keyIds = parseKeyIdsFromTenc(frag.initSegment.data);
         if (keyIds.length) {
-          const keyId = keyIds[0];
+          let keyId = keyIds[0];
           if (keyId.some(b => b !== 0)) {
             this.log(`Using keyId found in init segment ${arrayToHex(keyId)}`);
-            keyInfo.decryptdata.keyId = keyId;
             LevelKey.setKeyIdForUri(keyInfo.decryptdata.uri, keyId);
+          } else {
+            keyId = LevelKey.addKeyIdForUri(keyInfo.decryptdata.uri);
+            this.log(`Generating keyId to patch media ${arrayToHex(keyId)}`);
           }
+          keyInfo.decryptdata.keyId = keyId;
         }
       }
+      if (!keyInfo.decryptdata.keyId && !isMediaFragment(frag)) {
+        // Resolve so that unencrypted init segment is loaded
+        // key id is extracted from tenc box when processing key for next segment above
+        return Promise.resolve(keyLoadedData);
+      }
       const keySessionContextPromise = this.emeController.loadKey(keyLoadedData);
       return (keyInfo.keyLoadPromise = keySessionContextPromise.then(keySessionContext => {
         keyInfo.mediaKeySessionContext = keySessionContext;
@@ -51326,7 +51431,7 @@ class Player {
     }
 }
 
-var version$1 = "2.28.25";
+var version$1 = "2.28.27";
 
 var packages = {
 	"node_modules/@clappr/core": {
@@ -51334,7 +51439,7 @@ var packages = {
 	"node_modules/dashjs": {
 		version: "4.7.4"},
 	"node_modules/hls.js": {
-		version: "1.6.14"}};
+		version: "1.6.15"}};
 
 /**
  * Version information about the gplayer and its main dependencies
@@ -51350,4 +51455,4 @@ function version() {
     };
 }
 
-export { LogTracer, Logger$1 as Logger, PlaybackErrorCode, Player, PlayerEvent, SentryTracer, reportError, setTracer, trace, version };
+export { ChainedTracer, LogTracer, Logger$1 as Logger, PlaybackErrorCode, Player, PlayerEvent, RemoteTracer, SentryTracer, reportError, setTracer, trace, version };