stormcloud-video-player 0.8.72 → 0.8.74

package/lib/player/OptimizedPodRequest.cjs

@@ -0,0 +1,719 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = function __export(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function __copyProps(to, from, except, desc) {
+    if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function get() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toCommonJS = function __toCommonJS(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+// src/player/OptimizedPodRequest.ts
+var OptimizedPodRequest_exports = {};
+__export(OptimizedPodRequest_exports, {
+    DEFAULT_REQUEST_SAFETY_MS: function DEFAULT_REQUEST_SAFETY_MS1() {
+        return DEFAULT_REQUEST_SAFETY_MS;
+    },
+    GAM_AD_OPPORTUNITY_DURATION_MS: function GAM_AD_OPPORTUNITY_DURATION_MS1() {
+        return GAM_AD_OPPORTUNITY_DURATION_MS;
+    },
+    computePodResponseDiagnostics: function computePodResponseDiagnostics1() {
+        return computePodResponseDiagnostics;
+    },
+    finalizeGamRequestUrl: function finalizeGamRequestUrl1() {
+        return finalizeGamRequestUrl;
+    },
+    isOptimizedPodUrl: function isOptimizedPodUrl1() {
+        return isOptimizedPodUrl;
+    },
+    isPodRequestAbortedError: function isPodRequestAbortedError1() {
+        return isPodRequestAbortedError;
+    },
+    measureBreakCapacity: function measureBreakCapacity1() {
+        return measureBreakCapacity;
+    },
+    resolveAdPodConfig: function resolveAdPodConfig1() {
+        return resolveAdPodConfig;
+    },
+    resolvePodParams: function resolvePodParams1() {
+        return resolvePodParams;
+    },
+    validateGamRequestUrl: function validateGamRequestUrl1() {
+        return validateGamRequestUrl;
+    }
+});
+module.exports = __toCommonJS(OptimizedPodRequest_exports);
+// src/utils/vastEnvironmentSignals.ts
+var DEVICE_TYPE_HINT = {
+    FEATURE_PHONE: 1,
+    SMARTPHONE: 2,
+    DESKTOP: 3,
+    TABLET: 4,
+    CONNECTED_TV: 5,
+    GAME_CONSOLE: 6,
+    SET_TOP_BOX: 7
+};
+var DEVICE_TYPE_HINT_ALIASES = {
+    featurephone: DEVICE_TYPE_HINT.FEATURE_PHONE,
+    smartphone: DEVICE_TYPE_HINT.SMARTPHONE,
+    mobile: DEVICE_TYPE_HINT.SMARTPHONE,
+    phone: DEVICE_TYPE_HINT.SMARTPHONE,
+    desktop: DEVICE_TYPE_HINT.DESKTOP,
+    pc: DEVICE_TYPE_HINT.DESKTOP,
+    tablet: DEVICE_TYPE_HINT.TABLET,
+    ctv: DEVICE_TYPE_HINT.CONNECTED_TV,
+    tv: DEVICE_TYPE_HINT.CONNECTED_TV,
+    connectedtv: DEVICE_TYPE_HINT.CONNECTED_TV,
+    smarttv: DEVICE_TYPE_HINT.CONNECTED_TV,
+    console: DEVICE_TYPE_HINT.GAME_CONSOLE,
+    gameconsole: DEVICE_TYPE_HINT.GAME_CONSOLE,
+    stb: DEVICE_TYPE_HINT.SET_TOP_BOX,
+    settopbox: DEVICE_TYPE_HINT.SET_TOP_BOX
+};
+var PERSISTENT_ID_COOKIE_MAX_AGE = 60 * 60 * 24 * 365 * 5;
+// src/utils/vastMacros.ts
+var INVALID_VAST_PARAM_KEY = /^\s|\s$/;
+function removeBrokenAppNameOrphans(params, appName) {
+    var toDelete = [];
+    params.forEach(function(_value, key) {
+        if (!key || INVALID_VAST_PARAM_KEY.test(key)) {
+            toDelete.push(key);
+        }
+    });
+    if (appName && appName.includes("&")) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = appName.split("&").slice(1)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var suffix = _step.value;
+                var trimmed = suffix.replace(/^\s+/, "");
+                if (!trimmed) continue;
+                toDelete.push(suffix, " ".concat(trimmed), trimmed);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+    try {
+        for(var _iterator1 = new Set(toDelete)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+            var key = _step1.value;
+            if (key) params.delete(key);
+        }
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+            }
+        } finally{
+            if (_didIteratorError1) {
+                throw _iteratorError1;
+            }
+        }
+    }
+}
+function normalizeVastTagUrl(raw) {
+    if (!raw) return raw;
+    try {
+        var url = new URL(raw);
+        var anValue = url.searchParams.get("an");
+        if (anValue !== null) {
+            var orphanFragments = [];
+            url.searchParams.forEach(function(_value, key) {
+                if (key && INVALID_VAST_PARAM_KEY.test(key)) {
+                    orphanFragments.push(key.trim());
+                }
+            });
+            if (orphanFragments.length > 0) {
+                var reconstructed = [
+                    anValue.replace(/\s+$/, "")
+                ].concat(_to_consumable_array(orphanFragments)).filter(Boolean).join(" & ");
+                url.searchParams.forEach(function(_value, key) {
+                    if (key && INVALID_VAST_PARAM_KEY.test(key)) {
+                        url.searchParams.delete(key);
+                    }
+                });
+                url.searchParams.set("an", reconstructed);
+                return url.toString().replace(/([?&]an=)([^&]*)/, function(_match, prefix, val) {
+                    return prefix + val.replace(/\+/g, "%20");
+                });
+            }
+        }
+        removeBrokenAppNameOrphans(url.searchParams);
+        return url.toString();
+    } catch (unused) {
+        return raw;
+    }
+}
+var SCVP_MACRO_DETECT = /\[SCVP-|%5BSCVP-|\(SCVP-|%28SCVP-/i;
+var SCVP_MACRO_PATTERN = /\[SCVP-([A-Z0-9-]+)\]|\(SCVP-([A-Z0-9-]+)\)/gi;
+var SCVP_WHOLE_VALUE_PATTERN = /^\s*(?:\[SCVP-([A-Z0-9-]+)\]|\(SCVP-([A-Z0-9-]+)\))\s*$/i;
+var NESTED_QUERY_PARAM_KEYS = /* @__PURE__ */ new Set([
+    "cust_params"
+]);
+var SCVP_POD_MACROS = /* @__PURE__ */ new Set([
+    "PMND",
+    "PMXD",
+    "PMAD"
+]);
+function safeDecode(value) {
+    try {
+        return decodeURIComponent(value.replace(/\+/g, " "));
+    } catch (unused) {
+        return value;
+    }
+}
+function findScvpMacroNames(url) {
+    if (!url) return [];
+    var names = /* @__PURE__ */ new Set();
+    var text = url;
+    for(var pass = 0; pass < 3; pass++){
+        text.replace(SCVP_MACRO_PATTERN, function(_m, bracketName, parenName) {
+            names.add(String(bracketName || parenName).toUpperCase());
+            return "";
+        });
+        var decoded = safeDecode(text);
+        if (decoded === text) break;
+        text = decoded;
+    }
+    return Array.from(names);
+}
+var keepNone = function keepNone() {
+    return false;
+};
+function substituteScvpParams(params, values, unresolved, keep, nested) {
+    var out = [];
+    var replaceMacro = function replaceMacro(match, bracketName, parenName) {
+        var name = String(bracketName || parenName).toUpperCase();
+        var value = values.get(name);
+        if (value != null) return value;
+        if (keep(name)) return match;
+        unresolved.add(name);
+        return "";
+    };
+    params.forEach(function(value, key) {
+        var whole = value.match(SCVP_WHOLE_VALUE_PATTERN);
+        if (whole) {
+            var name = String(whole[1] || whole[2]).toUpperCase();
+            var resolved = values.get(name);
+            if (resolved != null) {
+                out.push([
+                    key,
+                    resolved
+                ]);
+            } else if (keep(name)) {
+                out.push([
+                    key,
+                    value
+                ]);
+            } else {
+                unresolved.add(name);
+            }
+            return;
+        }
+        if (!SCVP_MACRO_DETECT.test(value)) {
+            out.push([
+                key,
+                value
+            ]);
+            return;
+        }
+        if (!nested && NESTED_QUERY_PARAM_KEYS.has(key)) {
+            var inner = substituteScvpParams(new URLSearchParams(value), values, unresolved, keep, true);
+            if (inner.length > 0) {
+                out.push([
+                    key,
+                    inner.map(function(param) {
+                        var _param = _sliced_to_array(param, 2), k = _param[0], v = _param[1];
+                        return "".concat(encodeURIComponent(k), "=").concat(encodeURIComponent(v));
+                    }).join("&")
+                ]);
+            }
+            return;
+        }
+        out.push([
+            key,
+            value.replace(SCVP_MACRO_PATTERN, replaceMacro)
+        ]);
+    });
+    return out;
+}
+function substituteScvpMacros(baseUrl, values) {
+    var keep = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : keepNone;
+    var unresolved = /* @__PURE__ */ new Set();
+    var url;
+    try {
+        url = new URL(normalizeVastTagUrl(baseUrl));
+    } catch (unused) {
+        var replaced = baseUrl.replace(SCVP_MACRO_PATTERN, function(match, bracketName, parenName) {
+            var name = String(bracketName || parenName).toUpperCase();
+            var value = values.get(name);
+            if (value != null) return encodeURIComponent(value);
+            if (keep(name)) return match;
+            unresolved.add(name);
+            return "";
+        });
+        return {
+            url: replaced,
+            unresolved: Array.from(unresolved)
+        };
+    }
+    var entries = substituteScvpParams(url.searchParams, values, unresolved, keep, false);
+    var search = new URLSearchParams();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+            search.append(key, value);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    url.search = search.toString();
+    return {
+        url: url.toString(),
+        unresolved: Array.from(unresolved)
+    };
+}
+// src/player/OptimizedPodRequest.ts
+var DEFAULT_REQUEST_SAFETY_MS = 1500;
+var GAM_AD_OPPORTUNITY_DURATION_MS = 3e4;
+var POD_PARAM_KEYS = [
+    "pmnd",
+    "pmxd",
+    "pmad"
+];
+var POSITIVE_INT = /^[1-9]\d*$/;
+var NON_NEGATIVE_INT = /^(0|[1-9]\d*)$/;
+function nonNegativeInt(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+}
+function positiveInt(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : void 0;
+}
+function resolveAdPodConfig(config) {
+    var _config_adPodConfig, _nonNegativeInt, _nonNegativeInt1, _positiveInt;
+    var pod = (_config_adPodConfig = config.adPodConfig) !== null && _config_adPodConfig !== void 0 ? _config_adPodConfig : {};
+    return {
+        requestSafetyMs: (_nonNegativeInt = nonNegativeInt(pod.requestSafetyMs)) !== null && _nonNegativeInt !== void 0 ? _nonNegativeInt : DEFAULT_REQUEST_SAFETY_MS,
+        minPodDurationMs: (_nonNegativeInt1 = nonNegativeInt(pod.minPodDurationMs)) !== null && _nonNegativeInt1 !== void 0 ? _nonNegativeInt1 : 0,
+        maxAdsPerBreak: pod.maxAdsPerBreak === void 0 ? positiveInt(config.podMaxAds) : positiveInt(pod.maxAdsPerBreak),
+        maxPodDurationMs: (_positiveInt = positiveInt(pod.maxPodDurationMs)) !== null && _positiveInt !== void 0 ? _positiveInt : positiveInt(config.podMaxDurationMs),
+        exactDuration: config.podExactDuration === true
+    };
+}
+function measureBreakCapacity(timing, nowMonoMs) {
+    var _timing_breakEndMonoMs;
+    var scheduled = timing.scheduledBreakDurationMs;
+    if (scheduled == null || !(scheduled > 0) || timing.breakStartMonoMs == null) {
+        return void 0;
+    }
+    var endMonoMs = (_timing_breakEndMonoMs = timing.breakEndMonoMs) !== null && _timing_breakEndMonoMs !== void 0 ? _timing_breakEndMonoMs : timing.breakStartMonoMs + scheduled;
+    var untilEnd = Math.min(scheduled, endMonoMs - nowMonoMs);
+    var unplayed = scheduled - Math.max(0, timing.playedDurationMs);
+    return {
+        scheduledBreakDurationMs: scheduled,
+        elapsedBeforeGamRequestMs: Math.max(0, nowMonoMs - timing.breakStartMonoMs),
+        remainingAtGamDispatchMs: Math.max(0, Math.min(untilEnd, unplayed))
+    };
+}
+function resolvePodParams(input) {
+    var capacity = input.capacity, config = input.config;
+    var pmxd;
+    var source;
+    if (capacity) {
+        pmxd = Math.floor(capacity.remainingAtGamDispatchMs - config.requestSafetyMs);
+        source = "break_remaining";
+    } else if (config.maxPodDurationMs != null) {
+        pmxd = config.maxPodDurationMs;
+        source = "configured_cap";
+    } else if (input.tagMaxDurationMs != null) {
+        pmxd = input.tagMaxDurationMs;
+        source = "tag_cap";
+    } else {
+        return {
+            kind: "omit"
+        };
+    }
+    var minUsable = Math.max(1, Math.floor(input.minUsablePmxdMs));
+    if (!Number.isFinite(pmxd) || pmxd < minUsable) {
+        return {
+            kind: "abort",
+            reason: capacity ? "insufficient_break_capacity" : "invalid_pod_cap",
+            pmxdCandidateMs: Number.isFinite(pmxd) ? pmxd : 0
+        };
+    }
+    var pmnd = config.exactDuration ? pmxd : Math.min(config.minPodDurationMs, pmxd);
+    return {
+        kind: "send",
+        params: {
+            pmnd: pmnd,
+            pmxd: pmxd,
+            pmad: config.maxAdsPerBreak
+        },
+        source: source
+    };
+}
+function podRequestAborted(reason, message, diagnostics) {
+    var error = new Error("Optimized pod request not sent (".concat(reason, "): ").concat(message));
+    error.podRequestAborted = true;
+    error.reason = reason;
+    error.diagnostics = diagnostics;
+    return error;
+}
+function isPodRequestAbortedError(error) {
+    return !!error && error.podRequestAborted === true;
+}
+function firstPositiveIntParam(params, key) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = params.getAll(key)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var value = _step.value;
+            if (POSITIVE_INT.test(value.trim())) return Number(value.trim());
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return void 0;
+}
+function isOptimizedPodUrl(url) {
+    if (findScvpMacroNames(url).some(function(name) {
+        return SCVP_POD_MACROS.has(name);
+    })) return true;
+    try {
+        var params = new URL(url).searchParams;
+        return POD_PARAM_KEYS.some(function(key) {
+            return params.has(key);
+        });
+    } catch (unused) {
+        return false;
+    }
+}
+function finalizeGamRequestUrl(rawUrl, ctx) {
+    var nowEpochMs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : Date.now();
+    var optimizedPod = isOptimizedPodUrl(rawUrl);
+    var capacity = ctx.capacity;
+    var base = {
+        breakId: ctx.breakId,
+        optimizedPod: optimizedPod,
+        scteBreakDurationMs: capacity === null || capacity === void 0 ? void 0 : capacity.scheduledBreakDurationMs,
+        elapsedBeforeGamRequestMs: capacity === null || capacity === void 0 ? void 0 : capacity.elapsedBeforeGamRequestMs,
+        remainingAtGamDispatchMs: capacity === null || capacity === void 0 ? void 0 : capacity.remainingAtGamDispatchMs,
+        safetyReserveMs: ctx.config.requestSafetyMs
+    };
+    var decision = {
+        kind: "omit"
+    };
+    if (optimizedPod) {
+        var tagMaxDurationMs;
+        try {
+            tagMaxDurationMs = firstPositiveIntParam(new URL(rawUrl).searchParams, "pmxd");
+        } catch (unused) {}
+        decision = resolvePodParams({
+            capacity: capacity,
+            config: ctx.config,
+            minUsablePmxdMs: ctx.minUsablePmxdMs,
+            tagMaxDurationMs: tagMaxDurationMs
+        });
+        if (decision.kind === "abort") {
+            throw podRequestAborted(decision.reason, "pmxd would be ".concat(decision.pmxdCandidateMs, "ms (minimum ").concat(ctx.minUsablePmxdMs, "ms)"), base);
+        }
+    }
+    var pod = decision.kind === "send" ? decision.params : void 0;
+    var values = /* @__PURE__ */ new Map();
+    if (pod) {
+        values.set("PMND", String(pod.pmnd));
+        values.set("PMXD", String(pod.pmxd));
+        if (pod.pmad != null) values.set("PMAD", String(pod.pmad));
+    }
+    var substituted = substituteScvpMacros(rawUrl, values);
+    var finalUrl;
+    try {
+        var url = new URL(normalizeVastTagUrl(substituted.url));
+        if (pod) {
+            url.searchParams.set("pmnd", String(pod.pmnd));
+            url.searchParams.set("pmxd", String(pod.pmxd));
+            if (pod.pmad != null) url.searchParams.set("pmad", String(pod.pmad));
+            else url.searchParams.delete("pmad");
+        } else {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = POD_PARAM_KEYS[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var key = _step.value;
+                    url.searchParams.delete(key);
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+        finalUrl = url.toString();
+    } catch (unused) {
+        throw podRequestAborted("invalid_url", "GAM request URL could not be parsed", base);
+    }
+    var problems = validateGamRequestUrl(finalUrl, {
+        optimizedPod: !!pod,
+        remainingMs: decision.kind === "send" && decision.source === "break_remaining" ? capacity === null || capacity === void 0 ? void 0 : capacity.remainingAtGamDispatchMs : void 0
+    });
+    if (problems.length > 0) {
+        throw podRequestAborted("invalid_url", problems.join("; "), base);
+    }
+    var givn = null;
+    try {
+        givn = new URL(finalUrl).searchParams.get("givn");
+    } catch (unused) {}
+    return {
+        url: finalUrl,
+        diagnostics: {
+            breakId: ctx.breakId,
+            optimizedPod: !!pod,
+            pmxdSource: decision.kind === "send" ? decision.source : void 0,
+            scteBreakDurationMs: capacity === null || capacity === void 0 ? void 0 : capacity.scheduledBreakDurationMs,
+            elapsedBeforeGamRequestMs: capacity === null || capacity === void 0 ? void 0 : capacity.elapsedBeforeGamRequestMs,
+            remainingAtGamDispatchMs: capacity === null || capacity === void 0 ? void 0 : capacity.remainingAtGamDispatchMs,
+            safetyReserveMs: ctx.config.requestSafetyMs,
+            pmndSent: pod === null || pod === void 0 ? void 0 : pod.pmnd,
+            pmxdSent: pod === null || pod === void 0 ? void 0 : pod.pmxd,
+            pmadSent: pod === null || pod === void 0 ? void 0 : pod.pmad,
+            palNoncePresent: !!givn,
+            gamRequestDispatchTimestamp: new Date(nowEpochMs).toISOString(),
+            strippedMacros: substituted.unresolved.filter(function(name) {
+                return !SCVP_POD_MACROS.has(name);
+            })
+        }
+    };
+}
+function validateGamRequestUrl(url, expect) {
+    var problems = [];
+    var leftover = findScvpMacroNames(url);
+    if (leftover.length > 0) problems.push("unresolved SCVP macros: ".concat(leftover.join(", ")));
+    var params;
+    try {
+        params = new URL(url).searchParams;
+    } catch (unused) {
+        return problems.concat("URL could not be parsed");
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = POD_PARAM_KEYS[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            if (params.getAll(key).length > 1) problems.push("duplicate ".concat(key));
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (!expect.optimizedPod) {
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = POD_PARAM_KEYS[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var key1 = _step1.value;
+                if (params.has(key1)) problems.push("".concat(key1, " present on a non-pod request"));
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+        return problems;
+    }
+    var pmxd = params.get("pmxd");
+    var pmnd = params.get("pmnd");
+    var pmad = params.get("pmad");
+    if (pmxd == null || !POSITIVE_INT.test(pmxd)) problems.push("pmxd must be a positive integer (got ".concat(pmxd, ")"));
+    if (pmnd == null || !NON_NEGATIVE_INT.test(pmnd)) problems.push("pmnd must be a non-negative integer (got ".concat(pmnd, ")"));
+    if (pmxd != null && pmnd != null && Number(pmnd) > Number(pmxd)) problems.push("pmnd exceeds pmxd");
+    if (pmad != null && !POSITIVE_INT.test(pmad)) problems.push("pmad must be a positive integer or absent (got ".concat(pmad, ")"));
+    if (expect.remainingMs != null && pmxd != null && Number(pmxd) > expect.remainingMs) {
+        problems.push("pmxd ".concat(pmxd, " exceeds remaining break ").concat(expect.remainingMs, "ms"));
+    }
+    return problems;
+}
+function computePodResponseDiagnostics(pmxdSent, vastAdCount, totalVastCreativeDurationMs) {
+    var estimatedUnusedPodMs = Math.max(0, pmxdSent - totalVastCreativeDurationMs);
+    return {
+        vastAdCount: vastAdCount,
+        totalVastCreativeDurationMs: totalVastCreativeDurationMs,
+        estimatedUnusedPodMs: estimatedUnusedPodMs,
+        estimatedUnmatchedCount: Math.floor(estimatedUnusedPodMs / GAM_AD_OPPORTUNITY_DURATION_MS)
+    };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+    DEFAULT_REQUEST_SAFETY_MS: DEFAULT_REQUEST_SAFETY_MS,
+    GAM_AD_OPPORTUNITY_DURATION_MS: GAM_AD_OPPORTUNITY_DURATION_MS,
+    computePodResponseDiagnostics: computePodResponseDiagnostics,
+    finalizeGamRequestUrl: finalizeGamRequestUrl,
+    isOptimizedPodUrl: isOptimizedPodUrl,
+    isPodRequestAbortedError: isPodRequestAbortedError,
+    measureBreakCapacity: measureBreakCapacity,
+    resolveAdPodConfig: resolveAdPodConfig,
+    resolvePodParams: resolvePodParams,
+    validateGamRequestUrl: validateGamRequestUrl
+});
+//# sourceMappingURL=OptimizedPodRequest.cjs.map