rx-player 4.4.1 → 4.5.0-dev.2026012301

package/dist/es2017/parsers/manifest/dash/common/parse_mpd.js

@@ -1,291 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import config from "../../../../config";
-import log from "../../../../log";
-import arrayFind from "../../../../utils/array_find";
-import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
-import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
-import { getFilenameIndexInUrl } from "../../../../utils/url-utils";
-import ContentProtectionParser from "./content_protection_parser";
-import getClockOffset from "./get_clock_offset";
-import getHTTPUTCTimingURL from "./get_http_utc-timing_url";
-import getMinimumAndMaximumPositions from "./get_minimum_and_maximum_positions";
-import ManifestBoundsCalculator from "./manifest_bounds_calculator";
-import parseAvailabilityStartTime from "./parse_availability_start_time";
-import parsePeriods from "./parse_periods";
-import resolveBaseURLs from "./resolve_base_urls";
-/**
- * Checks if xlinks needs to be loaded before actually parsing the manifest.
- * @param {Object} mpdIR
- * @param {Object} args
- * @param {boolean} hasLoadedClock
- * @param {Array.<Object>} warnings
- * @returns {Object}
- */
-export default function parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkInfos = new WeakMap()) {
-    const { children: rootChildren, attributes: rootAttributes } = mpdIR;
-    if (isNullOrUndefined(args.externalClockOffset)) {
-        const isDynamic = rootAttributes.type === "dynamic";
-        const directTiming = arrayFind(rootChildren.utcTimings, (utcTiming) => {
-            return (utcTiming.schemeIdUri === "urn:mpeg:dash:utc:direct:2014" &&
-                !isNullOrUndefined(utcTiming.value));
-        });
-        const clockOffsetFromDirectUTCTiming = !isNullOrUndefined(directTiming) && !isNullOrUndefined(directTiming.value)
-            ? getClockOffset(directTiming.value)
-            : undefined;
-        const clockOffset = !isNullOrUndefined(clockOffsetFromDirectUTCTiming) &&
-            !isNaN(clockOffsetFromDirectUTCTiming)
-            ? clockOffsetFromDirectUTCTiming
-            : undefined;
-        if (!isNullOrUndefined(clockOffset) && hasLoadedClock !== true) {
-            args.externalClockOffset = clockOffset;
-        }
-        else if (isDynamic && hasLoadedClock !== true) {
-            const UTCTimingHTTPURL = getHTTPUTCTimingURL(mpdIR);
-            if (!isNullOrUndefined(UTCTimingHTTPURL) && UTCTimingHTTPURL.length > 0) {
-                // TODO fetch UTCTiming and XLinks at the same time
-                return {
-                    type: "needs-clock",
-                    value: {
-                        url: UTCTimingHTTPURL,
-                        continue: function continueParsingMPD(responseDataClock) {
-                            if (!responseDataClock.success) {
-                                warnings.push(responseDataClock.error);
-                                log.warn("dash", "Error on fetching the clock ressource", responseDataClock.error);
-                                return parseMpdIr(mpdIR, args, warnings, true);
-                            }
-                            args.externalClockOffset = getClockOffset(responseDataClock.data);
-                            return parseMpdIr(mpdIR, args, warnings, true);
-                        },
-                    },
-                };
-            }
-        }
-    }
-    const xlinksToLoad = [];
-    for (let i = 0; i < rootChildren.periods.length; i++) {
-        const { xlinkHref, xlinkActuate } = rootChildren.periods[i].attributes;
-        if (!isNullOrUndefined(xlinkHref) && xlinkActuate === "onLoad") {
-            xlinksToLoad.push({ index: i, ressource: xlinkHref });
-        }
-    }
-    if (xlinksToLoad.length === 0) {
-        return parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInfos);
-    }
-    return {
-        type: "needs-xlinks",
-        value: {
-            xlinksUrls: xlinksToLoad.map(({ ressource }) => ressource),
-            continue: function continueParsingMPD(loadedRessources) {
-                if (loadedRessources.length !== xlinksToLoad.length) {
-                    throw new Error("DASH parser: wrong number of loaded ressources.");
-                }
-                // Note: It is important to go from the last index to the first index in
-                // the resulting array, as we will potentially add elements to the array
-                for (let i = loadedRessources.length - 1; i >= 0; i--) {
-                    const index = xlinksToLoad[i].index;
-                    const { parsed: periodsIR, warnings: parsingWarnings, receivedTime, sendingTime, url, } = loadedRessources[i];
-                    if (parsingWarnings.length > 0) {
-                        warnings.push(...parsingWarnings);
-                    }
-                    for (const periodIR of periodsIR) {
-                        xlinkInfos.set(periodIR, { receivedTime, sendingTime, url });
-                    }
-                    // replace original "xlinked" periods by the real deal
-                    rootChildren.periods.splice(index, 1, ...periodsIR);
-                }
-                return parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkInfos);
-            },
-        },
-    };
-}
-/**
- * Parse the MPD intermediate representation into a regular Manifest.
- * @param {Object} mpdIR
- * @param {Object} args
- * @param {Array.<Object>} warnings
- * @param {Object} xlinkInfos
- * @returns {Object}
- */
-function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInfos) {
-    var _a, _b, _c, _d, _e;
-    const { children: rootChildren, attributes: rootAttributes } = mpdIR;
-    const isDynamic = rootAttributes.type === "dynamic";
-    const initialBaseUrl = args.url !== undefined
-        ? [{ url: args.url.substring(0, getFilenameIndexInUrl(args.url)) }]
-        : [];
-    const mpdBaseUrls = resolveBaseURLs(initialBaseUrl, rootChildren.baseURLs);
-    const availabilityStartTime = parseAvailabilityStartTime(rootAttributes, args.referenceDateTime);
-    const timeShiftBufferDepth = rootAttributes.timeShiftBufferDepth;
-    const maxSegmentDuration = rootAttributes.maxSegmentDuration;
-    const { externalClockOffset: clockOffset, unsafelyBaseOnPreviousManifest } = args;
-    const { externalClockOffset } = args;
-    const manifestBoundsCalculator = new ManifestBoundsCalculator({
-        availabilityStartTime,
-        isDynamic,
-        timeShiftBufferDepth,
-        serverTimestampOffset: externalClockOffset,
-    });
-    const contentProtectionParser = new ContentProtectionParser();
-    contentProtectionParser.addReferences((_a = rootChildren.contentProtections) !== null && _a !== void 0 ? _a : []);
-    const manifestInfos = {
-        availabilityStartTime,
-        baseURLs: mpdBaseUrls,
-        clockOffset,
-        contentProtectionParser,
-        duration: rootAttributes.duration,
-        isDynamic,
-        manifestBoundsCalculator,
-        manifestProfiles: mpdIR.attributes.profiles,
-        receivedTime: args.manifestReceivedTime,
-        unsafelyBaseOnPreviousManifest,
-        xlinkInfos,
-        xmlNamespaces: mpdIR.attributes.namespaces,
-    };
-    const parsedPeriods = parsePeriods(rootChildren.periods, manifestInfos);
-    contentProtectionParser.finalize();
-    const mediaPresentationDuration = rootAttributes.duration;
-    let lifetime;
-    let minimumTime;
-    let timeshiftDepth = null;
-    let maximumTimeData;
-    if (rootAttributes.minimumUpdatePeriod !== undefined &&
-        rootAttributes.minimumUpdatePeriod >= 0) {
-        lifetime =
-            rootAttributes.minimumUpdatePeriod === 0
-                ? config.getCurrent().DASH_FALLBACK_LIFETIME_WHEN_MINIMUM_UPDATE_PERIOD_EQUAL_0
-                : rootAttributes.minimumUpdatePeriod;
-    }
-    const { minimumSafePosition, maximumSafePosition, maximumUnsafePosition } = getMinimumAndMaximumPositions(parsedPeriods);
-    const now = getMonotonicTimeStamp();
-    if (!isDynamic) {
-        minimumTime = minimumSafePosition;
-        if (minimumTime === undefined) {
-            minimumTime = (_c = (_b = parsedPeriods[0]) === null || _b === void 0 ? void 0 : _b.start) !== null && _c !== void 0 ? _c : 0;
-        }
-        let finalMaximumSafePosition = mediaPresentationDuration !== null && mediaPresentationDuration !== void 0 ? mediaPresentationDuration : Infinity;
-        if (parsedPeriods[parsedPeriods.length - 1] !== undefined) {
-            const lastPeriod = parsedPeriods[parsedPeriods.length - 1];
-            const lastPeriodEnd = (_d = lastPeriod.end) !== null && _d !== void 0 ? _d : (lastPeriod.duration !== undefined
-                ? lastPeriod.start + lastPeriod.duration
-                : undefined);
-            if (lastPeriodEnd !== undefined && lastPeriodEnd < finalMaximumSafePosition) {
-                finalMaximumSafePosition = lastPeriodEnd;
-            }
-        }
-        if (maximumSafePosition !== undefined &&
-            maximumSafePosition < finalMaximumSafePosition) {
-            finalMaximumSafePosition = maximumSafePosition;
-        }
-        maximumTimeData = {
-            isLinear: false,
-            maximumSafePosition: finalMaximumSafePosition,
-            livePosition: undefined,
-            time: now,
-        };
-    }
-    else {
-        // Determine the maximum seekable position
-        let finalMaximumSafePosition;
-        if (maximumSafePosition !== undefined) {
-            finalMaximumSafePosition = maximumSafePosition;
-        }
-        else {
-            if (externalClockOffset === undefined) {
-                log.warn("dash", "use system clock to define maximum position");
-                finalMaximumSafePosition = Date.now() / 1000 - availabilityStartTime;
-            }
-            else {
-                const serverTime = getMonotonicTimeStamp() + externalClockOffset;
-                finalMaximumSafePosition = serverTime / 1000 - availabilityStartTime;
-            }
-        }
-        // Determine live edge (what position corresponds to live content, can be
-        // inferior or superior to the maximum anounced position in some specific
-        // scenarios). However, the `timeShiftBufferDepth` should be based on it.
-        let livePosition = manifestBoundsCalculator.getEstimatedLiveEdge();
-        if (livePosition === undefined) {
-            if (maximumUnsafePosition !== undefined) {
-                livePosition = maximumUnsafePosition;
-            }
-            else {
-                livePosition = finalMaximumSafePosition;
-            }
-            // manifestBoundsCalculator.forceLiveEdge(livePosition);
-        }
-        maximumTimeData = {
-            isLinear: true,
-            maximumSafePosition: finalMaximumSafePosition,
-            livePosition,
-            time: now,
-        };
-        // if the minimum calculated time is even below the buffer depth, perhaps we
-        // can go even lower in terms of depth
-        minimumTime = minimumSafePosition;
-        timeshiftDepth = timeShiftBufferDepth !== null && timeShiftBufferDepth !== void 0 ? timeShiftBufferDepth : null;
-        if (timeshiftDepth !== null) {
-            // The DASH spec implies that a segment is still available after a given
-            // `timeShiftBufferDepth` for a time equal to its duration
-            // (What I interpret from "ISO/IEC 23009-1 fifth edition 2022-08
-            // A.3.4 Media Segment list restrictions).
-            //
-            // This `timeshiftDepth` property is global for the whole Manifest (and
-            // not per segment), thus we cannot do exactly that, but we can take the
-            // anounced `maxSegmentDuration` by default instead. This may be a little
-            // too optimistic, but would in reality not lead to a lot of issues as
-            // this `timeshiftDepth` property is not the one that should be relied on
-            // to know which segment can or cannot be requested anymore.
-            timeshiftDepth += maxSegmentDuration !== null && maxSegmentDuration !== void 0 ? maxSegmentDuration : 0;
-        }
-        if (timeshiftDepth !== null &&
-            minimumTime !== undefined &&
-            livePosition - minimumTime > timeshiftDepth) {
-            timeshiftDepth = livePosition - minimumTime;
-        }
-    }
-    // `isLastPeriodKnown` should be `true` in two cases for DASH contents:
-    //   1. When the content is static, because we know that no supplementary
-    //      Period will be added.
-    //   2. If the content is dynamic, only when both the duration is known and
-    //      the `minimumUpdatePeriod` is not set. This corresponds to the case
-    //      explained in "4.6.4. Transition Phase between Live and On-Demand" of
-    //      the DASH-IF IOP v4.3 for live contents transitionning to on-demand.
-    const isLastPeriodKnown = !isDynamic ||
-        (mpdIR.attributes.minimumUpdatePeriod === undefined &&
-            (((_e = parsedPeriods[parsedPeriods.length - 1]) === null || _e === void 0 ? void 0 : _e.end) !== undefined ||
-                mpdIR.attributes.duration !== undefined));
-    const parsedMPD = {
-        availabilityStartTime,
-        clockOffset: args.externalClockOffset,
-        isDynamic,
-        isLive: isDynamic,
-        isLastPeriodKnown,
-        periods: parsedPeriods,
-        publishTime: rootAttributes.publishTime,
-        suggestedPresentationDelay: rootAttributes.suggestedPresentationDelay,
-        transportType: "dash",
-        timeBounds: {
-            minimumSafePosition: minimumTime,
-            timeshiftDepth,
-            maximumTimeData,
-        },
-        lifetime,
-        uris: isNullOrUndefined(args.url)
-            ? rootChildren.locations
-            : [args.url, ...rootChildren.locations],
-    };
-    return { type: "done", value: { parsed: parsedMPD, warnings } };
-}

package/dist/es2017/parsers/manifest/dash/common/parse_periods.d.ts

@@ -1,71 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import type { IManifest } from "../../../../manifest";
-import type { IParsedPeriod } from "../../types";
-import type { IPeriodIntermediateRepresentation } from "../node_parser_types";
-import type ContentProtectionParser from "./content_protection_parser";
-import type { IAdaptationSetContext } from "./parse_adaptation_sets";
-/** Information about each linked Xlink. */
-export type IXLinkInfos = WeakMap<IPeriodIntermediateRepresentation, {
-    /** Real URL (post-redirection) used to download this xlink. */
-    url?: string | undefined;
-    /** Time at which the request was sent (since the time origin), in ms. */
-    sendingTime?: number | undefined;
-    /** Time at which the request was received (since the time origin), in ms. */
-    receivedTime?: number | undefined;
-}>;
-/**
- * Process intermediate periods to create final parsed periods.
- * @param {Array.<Object>} periodsIR
- * @param {Object} context
- * @returns {Array.<Object>}
- */
-export default function parsePeriods(periodsIR: IPeriodIntermediateRepresentation[], context: IPeriodContext): IParsedPeriod[];
-/** Context needed when calling `parsePeriods`. */
-export interface IPeriodContext extends IInheritedAdaptationContext {
-    availabilityStartTime: number;
-    /**
-     * Difference between the server's clock, in milliseconds, and the
-     * monotonically-raising timestamp used by the RxPlayer.
-     */
-    clockOffset?: number | undefined;
-    /** Duration (mediaPresentationDuration) of the whole MPD, in seconds. */
-    duration?: number | undefined;
-    /**
-     * The parser should take this Manifest - which is a previously parsed
-     * Manifest for the same dynamic content - as a base to speed-up the parsing
-     * process.
-     * /!\ If unexpected differences exist between the two, there is a risk of
-     * de-synchronization with what is actually on the server,
-     * Use with moderation.
-     */
-    unsafelyBaseOnPreviousManifest: IManifest | null;
-    xlinkInfos: IXLinkInfos;
-    /**
-     * XML namespaces linked to the `<MPD>` element.
-     * May be needed to convert EventStream's Event elements back into the
-     * Document form.
-     */
-    xmlNamespaces?: Array<{
-        key: string;
-        value: string;
-    }> | undefined;
-    /** Parses contentProtection elements. */
-    contentProtectionParser: ContentProtectionParser;
-}
-type IInheritedAdaptationContext = Omit<IAdaptationSetContext, "availabilityTimeComplete" | "availabilityTimeOffset" | "duration" | "isLastPeriod" | "start" | "unsafelyBaseOnPreviousPeriod">;
-export {};
-//# sourceMappingURL=parse_periods.d.ts.map

package/dist/es2017/parsers/manifest/dash/common/parse_periods.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse_periods.d.ts","sourceRoot":"","sources":["../../../../../../src/parsers/manifest/dash/common/parse_periods.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAOtD,OAAO,KAAK,EAIV,aAAa,EACd,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAEV,iCAAiC,EAClC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,uBAAuB,MAAM,6BAA6B,CAAC;AAGvE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAMrE,2CAA2C;AAC3C,MAAM,MAAM,WAAW,GAAG,OAAO,CAC/B,iCAAiC,EACjC;IACE,+DAA+D;IAC/D,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC,CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,SAAS,EAAE,iCAAiC,EAAE,EAC9C,OAAO,EAAE,cAAc,GACtB,aAAa,EAAE,CA6HjB;AAgKD,kDAAkD;AAClD,MAAM,WAAW,cAAe,SAAQ,2BAA2B;IACjE,qBAAqB,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;;;;OAOG;IACH,8BAA8B,EAAE,SAAS,GAAG,IAAI,CAAC;IACjD,UAAU,EAAE,WAAW,CAAC;IAExB;;;;OAIG;IACH,aAAa,CAAC,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,SAAS,CAAC;IAClE,yCAAyC;IACzC,uBAAuB,EAAE,uBAAuB,CAAC;CAClD;AAED,KAAK,2BAA2B,GAAG,IAAI,CACrC,qBAAqB,EACnB,0BAA0B,GAC1B,wBAAwB,GACxB,UAAU,GACV,cAAc,GACd,OAAO,GACP,8BAA8B,CACjC,CAAC"}

package/dist/es2017/parsers/manifest/dash/common/parse_periods.js

@@ -1,266 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import log from "../../../../log";
-import flatMap from "../../../../utils/flat_map";
-import idGenerator from "../../../../utils/id_generator";
-import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
-import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
-import objectValues from "../../../../utils/object_values";
-import { utf8ToStr } from "../../../../utils/string_parsing";
-import flattenOverlappingPeriods from "./flatten_overlapping_periods";
-import getPeriodsTimeInformation from "./get_periods_time_infos";
-import parseAdaptationSets from "./parse_adaptation_sets";
-import resolveBaseURLs from "./resolve_base_urls";
-const generatePeriodID = idGenerator();
-/**
- * Process intermediate periods to create final parsed periods.
- * @param {Array.<Object>} periodsIR
- * @param {Object} context
- * @returns {Array.<Object>}
- */
-export default function parsePeriods(periodsIR, context) {
-    var _a, _b, _c, _d, _e;
-    const parsedPeriods = [];
-    const periodsTimeInformation = getPeriodsTimeInformation(periodsIR, context);
-    if (periodsTimeInformation.length !== periodsIR.length) {
-        throw new Error("MPD parsing error: the time information are incoherent.");
-    }
-    const { isDynamic, manifestBoundsCalculator } = context;
-    if (!isDynamic && !isNullOrUndefined(context.duration)) {
-        manifestBoundsCalculator.setLastPosition(context.duration);
-    }
-    // We parse it in reverse because we might need to deduce the buffer depth from
-    // the last Periods' indexes
-    for (let i = periodsIR.length - 1; i >= 0; i--) {
-        const isLastPeriod = i === periodsIR.length - 1;
-        const periodIR = periodsIR[i];
-        const xlinkInfos = context.xlinkInfos.get(periodIR);
-        const periodBaseURLs = resolveBaseURLs(context.baseURLs, periodIR.children.baseURLs);
-        const { periodStart, periodDuration, periodEnd } = periodsTimeInformation[i];
-        let periodID;
-        if (isNullOrUndefined(periodIR.attributes.id)) {
-            periodID = "gen-dash-period-" + generatePeriodID();
-            log.warn("dash", "No usable id found in the Period. Generating one.", {
-                periodId: periodID,
-            });
-        }
-        else {
-            periodID = periodIR.attributes.id;
-        }
-        // Avoid duplicate IDs
-        while (parsedPeriods.some((p) => p.id === periodID)) {
-            periodID += "-dup";
-        }
-        const receivedTime = xlinkInfos !== undefined ? xlinkInfos.receivedTime : context.receivedTime;
-        const unsafelyBaseOnPreviousPeriod = (_b = (_a = context.unsafelyBaseOnPreviousManifest) === null || _a === void 0 ? void 0 : _a.getPeriod(periodID)) !== null && _b !== void 0 ? _b : null;
-        const availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete;
-        const availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset;
-        const { manifestProfiles, contentProtectionParser } = context;
-        const { segmentTemplate } = periodIR.children;
-        contentProtectionParser.addReferences((_c = periodIR.children.contentProtections) !== null && _c !== void 0 ? _c : []);
-        const adapCtxt = {
-            availabilityTimeComplete,
-            availabilityTimeOffset,
-            baseURLs: periodBaseURLs,
-            contentProtectionParser,
-            manifestBoundsCalculator,
-            end: periodEnd,
-            isDynamic,
-            isLastPeriod,
-            manifestProfiles,
-            receivedTime,
-            segmentTemplate,
-            start: periodStart,
-            unsafelyBaseOnPreviousPeriod,
-        };
-        const { adaptations, thumbnailTracks } = parseAdaptationSets(periodIR.children.adaptations, adapCtxt);
-        const namespaces = ((_d = context.xmlNamespaces) !== null && _d !== void 0 ? _d : []).concat((_e = periodIR.attributes.namespaces) !== null && _e !== void 0 ? _e : []);
-        const streamEvents = generateStreamEvents(periodIR.children.eventStreams, periodStart, namespaces);
-        const parsedPeriod = {
-            id: periodID,
-            start: periodStart,
-            end: periodEnd,
-            duration: periodDuration,
-            thumbnailTracks,
-            adaptations,
-            streamEvents,
-        };
-        parsedPeriods.unshift(parsedPeriod);
-        if (!manifestBoundsCalculator.lastPositionIsKnown()) {
-            const lastPosition = getMaximumLastPosition(adaptations);
-            if (!isDynamic) {
-                if (typeof lastPosition === "number") {
-                    manifestBoundsCalculator.setLastPosition(lastPosition);
-                }
-            }
-            else {
-                if (typeof lastPosition === "number") {
-                    const positionTime = getMonotonicTimeStamp() / 1000;
-                    manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
-                }
-                else {
-                    const guessedLastPositionFromClock = guessLastPositionFromClock(context, periodStart);
-                    if (guessedLastPositionFromClock !== undefined) {
-                        const [guessedLastPosition, guessedPositionTime] = guessedLastPositionFromClock;
-                        manifestBoundsCalculator.setLastPosition(guessedLastPosition, guessedPositionTime);
-                    }
-                }
-            }
-        }
-    }
-    if (context.isDynamic && !manifestBoundsCalculator.lastPositionIsKnown()) {
-        // Guess a last time the last position
-        const guessedLastPositionFromClock = guessLastPositionFromClock(context, 0);
-        if (guessedLastPositionFromClock !== undefined) {
-            const [lastPosition, positionTime] = guessedLastPositionFromClock;
-            manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
-        }
-    }
-    return flattenOverlappingPeriods(parsedPeriods);
-}
-/**
- * Try to guess the "last position", which is the last position
- * available in the manifest in seconds, and the "position time", the
- * monotonically-raising timestamp used by the RxPlayer, at which the
- * last position was collected.
- *
- * These values allows to retrieve at any time in the future the new last
- * position, by substracting the position time to the last position, and
- * adding to it the new monotonically-raising timestamp.
- *
- * The last position and position time are returned by this function if and only if
- * it would indicate a last position superior to the `minimumTime` given.
- *
- * This last part allows for example to detect which Period is likely to be the
- * "current" one in multi-periods contents. By giving the Period's start as a
- * `minimumTime`, you ensure that you will get a value only if the current time
- * is in that period.
- *
- * This is useful as guessing the live time from the clock can be seen as a last
- * resort. By detecting that the current time is before the currently considered
- * Period, we can just parse and look at the previous Period. If we can guess
- * the live time more directly from that previous one, we might be better off
- * than just using the clock.
- *
- * @param {Object} context
- * @param {number} minimumTime
- * @returns {Array.<number|undefined>}
- */
-function guessLastPositionFromClock(context, minimumTime) {
-    if (!isNullOrUndefined(context.clockOffset)) {
-        const lastPosition = context.clockOffset / 1000 - context.availabilityStartTime;
-        const positionTime = getMonotonicTimeStamp() / 1000;
-        const timeInSec = positionTime + lastPosition;
-        if (timeInSec >= minimumTime) {
-            return [timeInSec, positionTime];
-        }
-    }
-    else {
-        const now = Date.now() / 1000;
-        if (now >= minimumTime) {
-            log.warn("dash", "no clock synchronization mechanism found. Using the system clock instead.");
-            const lastPosition = now - context.availabilityStartTime;
-            const positionTime = getMonotonicTimeStamp() / 1000;
-            return [lastPosition, positionTime];
-        }
-    }
-    return undefined;
-}
-/**
- * Try to extract the last position declared for any segments in a Period:
- *   - If at least a single index' last position is defined, take the maximum
- *     among them.
- *   - If segments are available but we cannot define the last position
- *     return undefined.
- *   - If no segment are available in that period, return null
- * @param {Object} adaptationsPerType
- * @returns {number|null|undefined}
- */
-function getMaximumLastPosition(adaptationsPerType) {
-    let maxEncounteredPosition = null;
-    let allIndexAreEmpty = true;
-    const adaptationsVal = objectValues(adaptationsPerType).filter((ada) => !isNullOrUndefined(ada));
-    const allAdaptations = flatMap(adaptationsVal, (adaptationsForType) => adaptationsForType);
-    for (const adaptation of allAdaptations) {
-        const representations = adaptation.representations;
-        for (const representation of representations) {
-            const position = representation.index.getLastAvailablePosition();
-            if (position !== null) {
-                allIndexAreEmpty = false;
-                if (typeof position === "number") {
-                    maxEncounteredPosition = isNullOrUndefined(maxEncounteredPosition)
-                        ? position
-                        : Math.max(maxEncounteredPosition, position);
-                }
-            }
-        }
-    }
-    if (!isNullOrUndefined(maxEncounteredPosition)) {
-        return maxEncounteredPosition;
-    }
-    else if (allIndexAreEmpty) {
-        return null;
-    }
-    return undefined;
-}
-/**
- * Generate parsed "eventStream" objects from a `StreamEvent` node's
- * intermediate Representation.
- * @param {Array.<Object>} baseIr - The array of every encountered StreamEvent's
- * intermediate representations for a given Period.
- * @param {number} periodStart - The time in seconds at which this corresponding
- * Period starts.
- * @returns {Array.<Object>} - The parsed objects.
- */
-function generateStreamEvents(baseIr, periodStart, xmlNamespaces) {
-    var _a, _b;
-    const res = [];
-    for (const eventStreamIr of baseIr) {
-        const { schemeIdUri = "", timescale = 1 } = eventStreamIr.attributes;
-        const allNamespaces = xmlNamespaces.concat((_a = eventStreamIr.attributes.namespaces) !== null && _a !== void 0 ? _a : []);
-        for (const eventIr of eventStreamIr.children.events) {
-            if (eventIr.eventStreamData !== undefined) {
-                const start = ((_b = eventIr.presentationTime) !== null && _b !== void 0 ? _b : 0) / timescale + periodStart;
-                const end = eventIr.duration === undefined
-                    ? undefined
-                    : start + eventIr.duration / timescale;
-                let element;
-                let xmlData;
-                try {
-                    xmlData = {
-                        namespaces: allNamespaces,
-                        data: typeof eventIr.eventStreamData === "string"
-                            ? eventIr.eventStreamData
-                            : utf8ToStr(new Uint8Array(eventIr.eventStreamData)),
-                    };
-                }
-                catch (err) {
-                    log.error("dash", "Error while parsing event-stream:", err instanceof Error ? err.message : "Unknown error");
-                }
-                res.push({
-                    start,
-                    end,
-                    id: eventIr.id,
-                    data: {
-                        type: "dash-event-stream",
-                        value: { schemeIdUri, timescale, element, xmlData },
-                    },
-                });
-            }
-        }
-    }
-    return res;
-}