eb-player 2.4.2 → 2.5.0

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.4.2";
+    var __EB_PLAYER_VERSION__ = "2.5.0";
 
     /**
      * Finite State Machine for player playback state transitions.
@@ -5236,6 +5236,11 @@
             if (text.trim().startsWith('{')) {
                 return TokenResponse.fromJson({ src, json: text });
             }
+            const fullUrlResponse = parseFullUrlResponse(text);
+            if (fullUrlResponse) {
+                const responseParameters = { token: null, tokenPath: null, ...fullUrlResponse };
+                return new TokenResponse({ src, responseParameters });
+            }
             const params = new URLSearchParams(text.trim().replace(/^\?/, ''));
             const token = params.get('token') ?? null;
             const expiresStr = params.get('expires');
@@ -5274,8 +5279,11 @@
     // Akamai response parameter parsing (inlined from CDNtoken/akamaiResponseParameters.js)
     // ---------------------------------------------------------------------------
     function parseAkamaiResponse({ src, text }) {
-        const fullUrl = `${src}${text ? `?${text}` : ''}`;
-        const srcUrl = new URL(fullUrl);
+        // The token server may answer with a complete replacement URL (Akamai "URL
+        // rewrite": a token path segment inserted after the origin, plus a query
+        // `hdnea`). That URL is the result, not a fragment to merge into `src`.
+        const fullUrl = parseFullUrlResponse(text)?.fullUrl ?? null;
+        const srcUrl = new URL(fullUrl ?? `${src}${text ? `?${text}` : ''}`);
         let hdntl = null;
         let exp = null;
         let hmac = null;
@@ -5309,7 +5317,83 @@
             if (aclMatch)
                 acl = aclMatch[1];
         }
-        return { expires: exp, hdntl: tokenValue, hmac, acl, hdnea };
+        return { expires: exp, hdntl: tokenValue, hmac, acl, hdnea, fullUrl };
+    }
+    // ---------------------------------------------------------------------------
+    // Full-URL token responses (Akamai ESI Token Authority / URL rewrite)
+    // ---------------------------------------------------------------------------
+    const ABSOLUTE_URL_PATTERN = /^https?:\/\//i;
+    /**
+     * Detects a token response that is itself a complete URL, e.g.
+     * `https://cdn/<token-segment>/path/asset.m3u8?hdnea=exp=...~acl=...~hmac=...`.
+     * `expires` comes from an `expires` query param when present, otherwise from
+     * the `exp=` field of the `hdnea`/`hdntl` token.
+     */
+    function parseFullUrlResponse(text) {
+        const fullUrl = text.trim();
+        if (!ABSOLUTE_URL_PATTERN.test(fullUrl)) {
+            return null;
+        }
+        const expiresParam = new URL(fullUrl).searchParams.get('expires');
+        if (expiresParam) {
+            return { fullUrl, expires: parseInt(expiresParam, 10) };
+        }
+        return { fullUrl, expires: parseAkamaiResponse({ src: fullUrl, text: '' }).expires };
+    }
+    function fullUrlOf(tokenResponse) {
+        const params = tokenResponse?.responseParameters;
+        return params && 'fullUrl' in params ? params.fullUrl ?? null : null;
+    }
+    function rewriteGrantOf(tokenResponse) {
+        const params = tokenResponse?.responseParameters;
+        const fullUrl = fullUrlOf(tokenResponse);
+        if (!tokenResponse || !params || !fullUrl) {
+            return null;
+        }
+        const original = new URL(tokenResponse.src);
+        const rewritten = new URL(fullUrl);
+        if (!rewritten.pathname.endsWith(original.pathname)) {
+            return null;
+        }
+        const insertedPath = rewritten.pathname.slice(0, rewritten.pathname.length - original.pathname.length);
+        return {
+            fullUrl,
+            originalBase: original.origin,
+            rewrittenBase: rewritten.origin + insertedPath,
+            search: rewritten.search,
+            expires: params.expires
+        };
+    }
+    /**
+     * Maps a URL back to its un-rewritten form (token segment and `hdnea`/`hdntl`
+     * query removed). Feeding an already-rewritten URL to the token server makes
+     * it stack a second token segment, so refreshes must go through this first.
+     * Returns null when the URL is not under the grant.
+     */
+    function unrewriteUrl(url, grant) {
+        if (!url.startsWith(`${grant.rewrittenBase}/`)) {
+            return null;
+        }
+        const original = new URL(grant.originalBase + url.slice(grant.rewrittenBase.length));
+        original.searchParams.delete('hdnea');
+        original.searchParams.delete('hdntl');
+        return original.toString();
+    }
+    /**
+     * Applies a grant to a URL (original or already rewritten): the token segment
+     * is inserted after the origin and the server's query string appended
+     * verbatim. Returns null when the URL lives on another origin.
+     */
+    function rewriteUrl(url, grant) {
+        const original = new URL(unrewriteUrl(url, grant) ?? url);
+        if (original.origin !== grant.originalBase) {
+            return null;
+        }
+        original.searchParams.delete('hdnea');
+        original.searchParams.delete('hdntl');
+        const ownQuery = original.search;
+        const query = ownQuery ? `${ownQuery}&${grant.search.slice(1)}` : grant.search;
+        return `${grant.rewrittenBase}${original.pathname}${query}`;
     }
     // ---------------------------------------------------------------------------
     // Internal wait helper
@@ -5636,6 +5720,13 @@
                     if (!this.isTokenExpired(akamaiParams.expires)) {
                         return url;
                     }
+                    // A cached full-URL grant covers every URL under the same origin
+                    // (child playlists, segments) without another token request.
+                    const grant = rewriteGrantOf(this.lastTokenResponse);
+                    const reused = grant && !this.isTokenExpired(grant.expires) ? rewriteUrl(url, grant) : null;
+                    if (reused) {
+                        return reused;
+                    }
                     // Remove hdntl / hdnea path segments before requesting new token
                     const pathSegments = srcUrl.pathname.split('/');
                     srcUrl.pathname = pathSegments
@@ -5655,6 +5746,10 @@
                     if (cachedResponse) {
                         const cachedParams = cachedResponse.responseParameters;
                         if (cachedParams && !this.isTokenExpired(cachedParams.expires)) {
+                            const grant = rewriteGrantOf(cachedResponse);
+                            if (grant) {
+                                return rewriteUrl(url, grant) ?? url;
+                            }
                             const { token, expires: cachedExpires, tokenPath } = cachedParams;
                             return CDNTokenManager.appendTokenParams(url, token, cachedExpires, tokenPath);
                         }
@@ -5675,7 +5770,11 @@
             const sharesPrefixScopedGrant = this.tokenType === TOKEN_TYPES.EASY_B
                 || this.tokenType === TOKEN_TYPES.VENOM
                 || this.tokenType === TOKEN_TYPES.BUNNY;
-            const fetchSrc = (sharesPrefixScopedGrant && this.sourceUrl) ? this.sourceUrl : srcUrl.toString();
+            // A previous full-URL grant may have rewritten this URL; ask the token
+            // server about the original, or it stacks a second token segment.
+            const previousGrant = rewriteGrantOf(this.lastTokenResponse);
+            const originalUrl = (previousGrant && unrewriteUrl(srcUrl.toString(), previousGrant)) ?? srcUrl.toString();
+            const fetchSrc = (sharesPrefixScopedGrant && this.sourceUrl) ? this.sourceUrl : originalUrl;
             try {
                 const tokenResponse = await this.fetchToken({ src: fetchSrc });
                 if (tokenResponse === null) {
@@ -5691,6 +5790,20 @@
                     }
                     return url;
                 }
+                // Full-URL response: the server's URL is the result. When the response
+                // was minted for another URL (deduplicated in-flight fetch, or the
+                // easy_b asset-level source), apply its grant to this one instead.
+                const fullUrl = fullUrlOf(tokenResponse);
+                if (fullUrl) {
+                    if (tokenResponse.src === originalUrl) {
+                        return fullUrl;
+                    }
+                    const grant = rewriteGrantOf(tokenResponse);
+                    const rewritten = grant ? rewriteUrl(originalUrl, grant) : null;
+                    if (rewritten) {
+                        return rewritten;
+                    }
+                }
                 switch (this.tokenType) {
                     case TOKEN_TYPES.BUNNY:
                     case TOKEN_TYPES.VENOM: