eb-player 2.1.0 → 2.1.1

package/dist/build/ebplayer.bundle.js

@@ -4,7 +4,7 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.EBPlayer = {}));
 })(this, (function (exports) { 'use strict';
 
-    var __EB_PLAYER_VERSION__ = "2.1.0";
+    var __EB_PLAYER_VERSION__ = "2.1.1";
 
     /**
      * Finite State Machine for player playback state transitions.
@@ -5852,9 +5852,22 @@
         }
     }
     /**
-     * Returns a loader class extending `BaseLoader`, built exactly like the
-     * existing playlist loader: call `super()`, bind the inherited `load`, then
-     * assign an own `load` property that reads `context.frag?.baseurl`.
+     * Returns a loader constructor extending `BaseLoader`: construct the base,
+     * bind the inherited `load`, then assign an own `load` property that reads
+     * `context.frag?.baseurl`.
+     *
+     * NOT a native `class`: this constructor is registered in the base
+     * `config.loader` slot, which the EasyBroadcast P2P SDK's hls adapter
+     * subclasses with transpiled ES5 inheritance — its wrapper constructor
+     * invokes the parent as `Parent.apply(this, arguments)`, which throws
+     * "Class constructor ... cannot be invoked without 'new'" on a native
+     * class (hls.js's own dist loaders are function-based for the same
+     * reason). The function below therefore supports both invocation modes:
+     * under `new` (hls.js pLoader/fLoader/loader slots) it defers to
+     * `Reflect.construct` so a native-class base still works; under an
+     * `.apply()`-style super call it initializes the wrapper's `this` in
+     * place, which requires the base to be function-based — true of every
+     * hls.js dist build this player loads.
      *
      * `tokenSource` is captured by closure — never stored on `this` and never
      * used to acquire or refresh a token.
@@ -5868,37 +5881,46 @@
         // hls.js needs the error signal each time to drive its own retry/fatal
         // escalation; only the console spam is deduplicated.
         let unsupportedTokenTypeLogged = false;
-        class SegmentTokenLoader extends BaseLoader {
-            constructor(loaderConfig) {
-                super(loaderConfig);
-                const originalLoad = this.load.bind(this);
-                this.load = function (context, loadConfig, callbacks) {
-                    // D-03/D-04: a token type outside the query-param family (akamai, or
-                    // none configured) must fail visibly rather than emit an unsigned
-                    // request. A silent passthrough here is the same undiagnosable 403
-                    // from the edge that D-04 forbids, so it gets the same treatment as
-                    // the akamai case: no delegation to the base loader, and a named
-                    // error surfaced through hls.js's own error callback.
-                    const tokenType = tokenSource.tokenType;
-                    if (!tokenType || !SEGMENT_SIGNING_TOKEN_TYPES.includes(tokenType)) {
-                        const message = segmentSigningUnsupportedMessage(tokenType);
-                        if (!unsupportedTokenTypeLogged) {
-                            unsupportedTokenTypeLogged = true;
-                            console.error(message);
-                        }
-                        callbacks.onError({ code: 0, text: message }, context, null, createEmptySegmentLoaderStats());
-                        return;
-                    }
-                    const baseUrl = context.frag?.baseurl;
-                    if (!baseUrl || !context.url) {
-                        originalLoad(context, loadConfig, callbacks);
-                        return;
+        function attachSigningLoad(instance) {
+            const originalLoad = instance.load.bind(instance);
+            instance.load = function (context, loadConfig, callbacks) {
+                // D-03/D-04: a token type outside the query-param family (akamai, or
+                // none configured) must fail visibly rather than emit an unsigned
+                // request. A silent passthrough here is the same undiagnosable 403
+                // from the edge that D-04 forbids, so it gets the same treatment as
+                // the akamai case: no delegation to the base loader, and a named
+                // error surfaced through hls.js's own error callback.
+                const tokenType = tokenSource.tokenType;
+                if (!tokenType || !SEGMENT_SIGNING_TOKEN_TYPES.includes(tokenType)) {
+                    const message = segmentSigningUnsupportedMessage(tokenType);
+                    if (!unsupportedTokenTypeLogged) {
+                        unsupportedTokenTypeLogged = true;
+                        console.error(message);
                     }
-                    context.url = signSegmentUrlFromPlaylist(context.url, baseUrl);
+                    callbacks.onError({ code: 0, text: message }, context, null, createEmptySegmentLoaderStats());
+                    return;
+                }
+                const baseUrl = context.frag?.baseurl;
+                if (!baseUrl || !context.url) {
                     originalLoad(context, loadConfig, callbacks);
-                };
+                    return;
+                }
+                context.url = signSegmentUrlFromPlaylist(context.url, baseUrl);
+                originalLoad(context, loadConfig, callbacks);
+            };
+        }
+        function SegmentTokenLoader(loaderConfig) {
+            if (new.target) {
+                const instance = Reflect.construct(BaseLoader, [loaderConfig], new.target);
+                attachSigningLoad(instance);
+                return instance;
             }
+            BaseLoader.call(this, loaderConfig);
+            attachSigningLoad(this);
+            return undefined;
         }
+        SegmentTokenLoader.prototype = Object.create(BaseLoader.prototype);
+        SegmentTokenLoader.prototype.constructor = SegmentTokenLoader;
         return SegmentTokenLoader;
     }
 
@@ -6133,7 +6155,19 @@
                 // own parent playlist. Off by default so segment request shapes stay
                 // byte-identical to today's when the flag is unset.
                 if (config.engineSettings.signSegmentsWithCdnToken === true) {
-                    driverConfig.fLoader = createSegmentTokenLoaderClass(Hls.DefaultConfig.loader, tm);
+                    const SegmentTokenLoader = createSegmentTokenLoaderClass(Hls.DefaultConfig.loader, tm);
+                    driverConfig.fLoader = SegmentTokenLoader;
+                    // The base `loader` slot must sign too: the EasyBroadcast P2P SDK's
+                    // hls adapter replaces `config.fLoader` at integrate() time with a
+                    // wrapper class that extends `config.loader` and overrides only
+                    // loadInternal(), routing segment fetches through its own
+                    // resource manager (V2V + CDN-fallback fetch of context.url
+                    // verbatim). Signing lives in load(), which the wrapper inherits,
+                    // so every URL entering that path — and hls.js's key loader, which
+                    // also instantiates `config.loader` — is signed before any request
+                    // is issued. Without this, V2V CDN fallbacks go out unsigned (403
+                    // on token-protected origins).
+                    driverConfig.loader = SegmentTokenLoader;
                 }
             }
             // Inject custom ABR controller unless disabled