rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/es2017/parsers/manifest/dash/common/indexes/timeline/parse_s_element.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { ITNode } from "../../../../../../utils/xml-parser";
 /** SegmentTimeline `S` element once parsed. */
 export interface IParsedS {
     /** Start time in a previously-given timescaled unit. */
@@ -27,8 +28,16 @@ export interface IParsedS {
     duration?: number;
 }
 /**
- * Parse a given <S> element in the MPD into a JS Object.
+ * Parse a given <S> element in the MPD under a parsed Node form into a JS
+ * Object.
+ * @param {Object} root
+ * @returns {Object}
+ */
+export declare function parseSElementNode(root: ITNode): IParsedS;
+/**
+ * Parse a given <S> element in the MPD under an `Element` form into a JS
+ * Object.
  * @param {Element} root
  * @returns {Object}
  */
-export default function parseSElement(root: Element): IParsedS;
+export declare function parseSHTMLElement(root: Element): IParsedS;

package/dist/es2017/parsers/manifest/dash/common/indexes/timeline/parse_s_element.js

@@ -14,12 +14,59 @@
  * limitations under the License.
  */
 import log from "../../../../../../log";
+import isNullOrUndefined from "../../../../../../utils/is_null_or_undefined";
 /**
- * Parse a given <S> element in the MPD into a JS Object.
+ * Parse a given <S> element in the MPD under a parsed Node form into a JS
+ * Object.
+ * @param {Object} root
+ * @returns {Object}
+ */
+export function parseSElementNode(root) {
+    const parsedS = {};
+    for (const attributeName of Object.keys(root.attributes)) {
+        const attributeVal = root.attributes[attributeName];
+        if (isNullOrUndefined(attributeVal)) {
+            continue;
+        }
+        switch (attributeName) {
+            case "t":
+                const start = parseInt(attributeVal, 10);
+                if (isNaN(start)) {
+                    log.warn(`DASH: invalid t ("${attributeVal}")`);
+                }
+                else {
+                    parsedS.start = start;
+                }
+                break;
+            case "d":
+                const duration = parseInt(attributeVal, 10);
+                if (isNaN(duration)) {
+                    log.warn(`DASH: invalid d ("${attributeVal}")`);
+                }
+                else {
+                    parsedS.duration = duration;
+                }
+                break;
+            case "r":
+                const repeatCount = parseInt(attributeVal, 10);
+                if (isNaN(repeatCount)) {
+                    log.warn(`DASH: invalid r ("${attributeVal}")`);
+                }
+                else {
+                    parsedS.repeatCount = repeatCount;
+                }
+                break;
+        }
+    }
+    return parsedS;
+}
+/**
+ * Parse a given <S> element in the MPD under an `Element` form into a JS
+ * Object.
  * @param {Element} root
  * @returns {Object}
  */
-export default function parseSElement(root) {
+export function parseSHTMLElement(root) {
     const parsedS = {};
     for (let j = 0; j < root.attributes.length; j++) {
         const attribute = root.attributes[j];

package/dist/es2017/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.d.ts

@@ -13,12 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IRepresentationIndex, ISegment, Representation } from "../../../../../../manifest";
-import { IPlayerError } from "../../../../../../public_types";
-import { IEMSG } from "../../../../../containers/isobmff";
-import { IIndexSegment } from "../../../../utils/index_helpers";
-import { ISegmentTimelineElement } from "../../../node_parser_types";
-import ManifestBoundsCalculator from "../../manifest_bounds_calculator";
+import type { IRepresentationIndex, ISegment, IRepresentation } from "../../../../../../manifest";
+import type { IPlayerError } from "../../../../../../public_types";
+import type { ITNode } from "../../../../../../utils/xml-parser";
+import type { IEMSG } from "../../../../../containers/isobmff";
+import type { IIndexSegment } from "../../../../utils/index_helpers";
+import type { ISegmentTimelineElement } from "../../../node_parser_types";
+import type ManifestBoundsCalculator from "../../manifest_bounds_calculator";
 /**
  * Index property defined for a SegmentTimeline RepresentationIndex
  * This object contains every property needed to generate an ISegment for a
@@ -120,7 +121,7 @@ export interface ITimelineIndexIndexArgument {
      * timescale (see timescale)
      */
     presentationTimeOffset?: number | undefined;
-    timelineParser?: (() => HTMLCollection) | undefined;
+    timelineParser?: (() => ITNode[] | HTMLCollection) | undefined;
     timeline?: ISegmentTimelineElement[] | undefined;
 }
 /** Aditional context needed by a SegmentTimeline RepresentationIndex. */
@@ -168,7 +169,7 @@ export interface ITimelineIndexContextArgument {
      * de-synchronization with what is actually on the server,
      * Use with moderation.
      */
-    unsafelyBaseOnPreviousRepresentation: Representation | null;
+    unsafelyBaseOnPreviousRepresentation: IRepresentation | null;
     /** Function that tells if an EMSG is whitelisted by the manifest */
     isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean;
     /**

package/dist/es2017/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.js

@@ -17,6 +17,7 @@ import config from "../../../../../../config";
 import { NetworkError } from "../../../../../../errors";
 import log from "../../../../../../log";
 import assert from "../../../../../../utils/assert";
+import isNullOrUndefined from "../../../../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../../../../utils/monotonic_timestamp";
 import clearTimelineFromPosition from "../../../../utils/clear_timeline_from_position";
 import { checkDiscontinuity, fromIndexTime, getIndexSegmentEnd, toIndexTime, } from "../../../../utils/index_helpers";
@@ -26,7 +27,6 @@ import getSegmentsFromTimeline from "../get_segments_from_timeline";
 import { constructRepresentationUrl } from "../tokens";
 import { getSegmentTimeRoundingError } from "../utils";
 import constructTimelineFromElements from "./construct_timeline_from_elements";
-// eslint-disable-next-line max-len
 import constructTimelineFromPreviousTimeline from "./construct_timeline_from_previous_timeline";
 /**
  * `IRepresentationIndex` implementation for a DASH `SegmentTimeline` segment
@@ -39,42 +39,37 @@ export default class TimelineRepresentationIndex {
      * @param {Object} context
      */
     constructor(index, context) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         if (!TimelineRepresentationIndex.isTimelineIndexArgument(index)) {
-            throw new Error("The given index is not compatible with a " +
-                "TimelineRepresentationIndex.");
+            throw new Error("The given index is not compatible with a " + "TimelineRepresentationIndex.");
         }
-        const { availabilityTimeComplete, availabilityTimeOffset, manifestBoundsCalculator, isDynamic, isLastPeriod, representationId, representationBitrate, periodStart, periodEnd, isEMSGWhitelisted } = context;
+        const { availabilityTimeComplete, availabilityTimeOffset, manifestBoundsCalculator, isDynamic, isLastPeriod, representationId, representationBitrate, periodStart, periodEnd, isEMSGWhitelisted, } = context;
         const timescale = (_a = index.timescale) !== null && _a !== void 0 ? _a : 1;
-        const presentationTimeOffset = index.presentationTimeOffset != null ?
-            index.presentationTimeOffset :
-            0;
+        const presentationTimeOffset = (_b = index.presentationTimeOffset) !== null && _b !== void 0 ? _b : 0;
         const scaledStart = periodStart * timescale;
         const indexTimeOffset = presentationTimeOffset - scaledStart;
         this._manifestBoundsCalculator = manifestBoundsCalculator;
         this._isEMSGWhitelisted = isEMSGWhitelisted;
         this._isLastPeriod = isLastPeriod;
-        this._lastUpdate = context.receivedTime == null ?
-            getMonotonicTimeStamp() :
-            context.receivedTime;
+        this._lastUpdate = (_c = context.receivedTime) !== null && _c !== void 0 ? _c : getMonotonicTimeStamp();
         this._unsafelyBaseOnPreviousIndex = null;
         if (context.unsafelyBaseOnPreviousRepresentation !== null &&
-            context.unsafelyBaseOnPreviousRepresentation.index
-                instanceof TimelineRepresentationIndex) {
+            context.unsafelyBaseOnPreviousRepresentation.index instanceof
+                TimelineRepresentationIndex) {
             // avoid too much nested references, to keep memory down
-            context.unsafelyBaseOnPreviousRepresentation
-                .index._unsafelyBaseOnPreviousIndex = null;
-            this._unsafelyBaseOnPreviousIndex = context
-                .unsafelyBaseOnPreviousRepresentation.index;
+            context.unsafelyBaseOnPreviousRepresentation.index._unsafelyBaseOnPreviousIndex =
+                null;
+            this._unsafelyBaseOnPreviousIndex =
+                context.unsafelyBaseOnPreviousRepresentation.index;
         }
         this._isDynamic = isDynamic;
-        this._parseTimeline = (_b = index.timelineParser) !== null && _b !== void 0 ? _b : null;
-        const initializationUrl = ((_c = index.initialization) === null || _c === void 0 ? void 0 : _c.media) === undefined ?
-            null :
-            constructRepresentationUrl(index.initialization.media, representationId, representationBitrate);
-        const segmentUrlTemplate = index.media === undefined ?
-            null :
-            constructRepresentationUrl(index.media, representationId, representationBitrate);
+        this._parseTimeline = (_d = index.timelineParser) !== null && _d !== void 0 ? _d : null;
+        const initializationUrl = ((_e = index.initialization) === null || _e === void 0 ? void 0 : _e.media) === undefined
+            ? null
+            : constructRepresentationUrl(index.initialization.media, representationId, representationBitrate);
+        const segmentUrlTemplate = index.media === undefined
+            ? null
+            : constructRepresentationUrl(index.media, representationId, representationBitrate);
         let actualAvailabilityTimeOffset;
         // Technically, it seems (although it is not clear) that an MPD may contain
         // future segments and it's the job of a player to not request segments later
@@ -85,34 +80,35 @@ export default class TimelineRepresentationIndex {
         // So as a compromise, if nothing in the MPD indicates that future segments
         // may be announced (see code below), we will act as if ALL segments in this
         // TimelineRepresentationIndex are requestable
-        if (availabilityTimeOffset === undefined &&
-            availabilityTimeComplete === undefined) {
+        if (availabilityTimeOffset === undefined && availabilityTimeComplete === undefined) {
             actualAvailabilityTimeOffset = Infinity; // Meaning: we can request
             // everything in the index
         }
         else {
             actualAvailabilityTimeOffset = availabilityTimeOffset !== null && availabilityTimeOffset !== void 0 ? availabilityTimeOffset : 0;
         }
-        this._index = { availabilityTimeComplete: availabilityTimeComplete !== null && availabilityTimeComplete !== void 0 ? availabilityTimeComplete : true,
+        this._index = {
+            availabilityTimeComplete: availabilityTimeComplete !== null && availabilityTimeComplete !== void 0 ? availabilityTimeComplete : true,
             availabilityTimeOffset: actualAvailabilityTimeOffset,
             indexRange: index.indexRange,
             indexTimeOffset,
-            initialization: index.initialization == null ?
-                undefined :
-                {
+            initialization: isNullOrUndefined(index.initialization)
+                ? undefined
+                : {
                     url: initializationUrl,
                     range: index.initialization.range,
                 },
             segmentUrlTemplate,
             startNumber: index.startNumber,
             endNumber: index.endNumber,
-            timeline: index.timeline === undefined ?
-                null :
-                updateTimelineFromEndNumber(index.timeline, index.startNumber, index.endNumber),
-            timescale };
+            timeline: index.timeline === undefined
+                ? null
+                : updateTimelineFromEndNumber(index.timeline, index.startNumber, index.endNumber),
+            timescale,
+        };
         this._scaledPeriodStart = toIndexTime(periodStart, this._index);
-        this._scaledPeriodEnd = periodEnd === undefined ? undefined :
-            toIndexTime(periodEnd, this._index);
+        this._scaledPeriodEnd =
+            periodEnd === undefined ? undefined : toIndexTime(periodEnd, this._index);
     }
     /**
      * Construct init Segment.
@@ -133,13 +129,15 @@ export default class TimelineRepresentationIndex {
             this._index.timeline = this._getTimeline();
         }
         // destructuring to please TypeScript
-        const { segmentUrlTemplate, startNumber, endNumber, timeline, timescale, indexTimeOffset } = this._index;
-        return getSegmentsFromTimeline({ segmentUrlTemplate,
+        const { segmentUrlTemplate, startNumber, endNumber, timeline, timescale, indexTimeOffset, } = this._index;
+        return getSegmentsFromTimeline({
+            segmentUrlTemplate,
             startNumber,
             endNumber,
             timeline,
             timescale,
-            indexTimeOffset }, from, duration, this._manifestBoundsCalculator, this._scaledPeriodEnd, this._isEMSGWhitelisted);
+            indexTimeOffset,
+        }, from, duration, this._manifestBoundsCalculator, this._scaledPeriodEnd, this._isEMSGWhitelisted);
     }
     /**
      * Returns true if the index should be refreshed.
@@ -162,8 +160,9 @@ export default class TimelineRepresentationIndex {
             this._index.timeline = this._getTimeline();
         }
         const timeline = this._index.timeline;
-        return timeline.length === 0 ? null :
-            fromIndexTime(Math.max(this._scaledPeriodStart, timeline[0].start), this._index);
+        return timeline.length === 0
+            ? null
+            : fromIndexTime(Math.max(this._scaledPeriodStart, timeline[0].start), this._index);
     }
     /**
      * Returns the ending time, in seconds, of the last segment currently
@@ -237,7 +236,8 @@ export default class TimelineRepresentationIndex {
         if (lastReqSegInfo !== null) {
             const lastReqSegmentEnd = Math.min(lastReqSegInfo.end, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
             const roundedReqSegmentEnd = lastReqSegmentEnd + segmentTimeRounding;
-            if (roundedReqSegmentEnd >= Math.min(scaledWantedEnd, (_b = this._scaledPeriodEnd) !== null && _b !== void 0 ? _b : Infinity)) {
+            if (roundedReqSegmentEnd >=
+                Math.min(scaledWantedEnd, (_b = this._scaledPeriodEnd) !== null && _b !== void 0 ? _b : Infinity)) {
                 return false; // everything up to that point is already requestable
             }
         }
@@ -260,13 +260,13 @@ export default class TimelineRepresentationIndex {
             return false;
         }
         if (this._scaledPeriodEnd === undefined) {
-            return (scaledWantedEnd + segmentTimeRounding) > this._scaledPeriodStart ?
-                undefined : // There may be future segments at this point
-                false; // Before the current Period
+            return scaledWantedEnd + segmentTimeRounding > this._scaledPeriodStart
+                ? undefined // There may be future segments at this point
+                : false; // Before the current Period
         }
         // `true` if within the boundaries of this Period. `false` otherwise.
-        return (scaledWantedStart - segmentTimeRounding) < this._scaledPeriodEnd &&
-            (scaledWantedEnd + segmentTimeRounding) > this._scaledPeriodStart;
+        return (scaledWantedStart - segmentTimeRounding < this._scaledPeriodEnd &&
+            scaledWantedEnd + segmentTimeRounding > this._scaledPeriodStart);
     }
     /**
      * Returns true if a Segment returned by this index is still considered
@@ -303,9 +303,11 @@ export default class TimelineRepresentationIndex {
             timeline = this._getTimeline();
             this._index.timeline = timeline;
         }
-        return checkDiscontinuity({ timeline,
+        return checkDiscontinuity({
+            timeline,
             timescale: this._index.timescale,
-            indexTimeOffset: this._index.indexTimeOffset }, time, this._scaledPeriodEnd);
+            indexTimeOffset: this._index.indexTimeOffset,
+        }, time, this._scaledPeriodEnd);
     }
     /**
      * @param {Error} error
@@ -315,8 +317,7 @@ export default class TimelineRepresentationIndex {
         if (!this._isDynamic) {
             return false;
         }
-        return error instanceof NetworkError &&
-            error.isHttpError(404);
+        return error instanceof NetworkError && error.isHttpError(404);
     }
     /**
      * Replace this RepresentationIndex with one from a new version of the
@@ -419,7 +420,7 @@ export default class TimelineRepresentationIndex {
         const lastSegmentEnd = getIndexSegmentEnd(lastSegment, null, this._scaledPeriodEnd);
         // We're awaiting future segments only if the current end is before the end
         // of the Period
-        return (lastSegmentEnd + segmentTimeRounding) < this._scaledPeriodEnd;
+        return lastSegmentEnd + segmentTimeRounding < this._scaledPeriodEnd;
     }
     /**
      * @returns {Boolean}
@@ -440,8 +441,7 @@ export default class TimelineRepresentationIndex {
      * @returns {boolean}
      */
     static isTimelineIndexArgument(index) {
-        return typeof index.timelineParser === "function" ||
-            Array.isArray(index.timeline);
+        return typeof index.timelineParser === "function" || Array.isArray(index.timeline);
     }
     /**
      * Clean-up timeline to remove segment information which should not be
@@ -454,9 +454,8 @@ export default class TimelineRepresentationIndex {
         if (!this._isDynamic) {
             return;
         }
-        const firstPosition = this._manifestBoundsCalculator
-            .getEstimatedMinimumSegmentTime();
-        if (firstPosition == null) {
+        const firstPosition = this._manifestBoundsCalculator.getEstimatedMinimumSegmentTime();
+        if (isNullOrUndefined(firstPosition)) {
             return; // we don't know yet
         }
         const scaledFirstPosition = toIndexTime(firstPosition, this._index);
@@ -585,14 +584,15 @@ export function isSegmentStillAvailable(segment, index, manifestBoundsCalculator
             if (tSegment.range === undefined) {
                 return segment.range === undefined;
             }
-            return segment.range != null &&
+            return (!isNullOrUndefined(segment.range) &&
                 tSegment.range[0] === segment.range[0] &&
-                tSegment.range[1] === segment.range[1];
+                tSegment.range[1] === segment.range[1]);
         }
-        else { // tSegment.start < segment.time
+        else {
+            // tSegment.start < segment.time
             if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
                 const timeDiff = tSegmentTime - tSegment.start;
-                const repeat = (timeDiff / tSegment.duration) - 1;
+                const repeat = timeDiff / tSegment.duration - 1;
                 return repeat % 1 === 0 && repeat <= lastReqSegInfo.newRepeatCount;
             }
         }
@@ -617,19 +617,23 @@ export function getLastRequestableSegmentInfo(index, manifestBoundsCalculator, s
         // availabilityTimeOffset to Infinity == Everything is requestable in the timeline.
         const lastIndex = index.timeline.length - 1;
         const lastElem = index.timeline[lastIndex];
-        return { isLastOfTimeline: true,
+        return {
+            isLastOfTimeline: true,
             timelineIdx: lastIndex,
             newRepeatCount: lastElem.repeatCount,
-            end: getIndexSegmentEnd(lastElem, null, scaledPeriodEnd) };
+            end: getIndexSegmentEnd(lastElem, null, scaledPeriodEnd),
+        };
     }
     const adjustedMaxSeconds = manifestBoundsCalculator.getEstimatedMaximumPosition(index.availabilityTimeOffset);
     if (adjustedMaxSeconds === undefined) {
         const lastIndex = index.timeline.length - 1;
         const lastElem = index.timeline[lastIndex];
-        return { isLastOfTimeline: true,
+        return {
+            isLastOfTimeline: true,
             timelineIdx: lastIndex,
             newRepeatCount: lastElem.repeatCount,
-            end: getIndexSegmentEnd(lastElem, null, scaledPeriodEnd) };
+            end: getIndexSegmentEnd(lastElem, null, scaledPeriodEnd),
+        };
     }
     for (let i = index.timeline.length - 1; i >= index.timeline.length; i--) {
         const element = index.timeline[i];
@@ -637,10 +641,12 @@ export function getLastRequestableSegmentInfo(index, manifestBoundsCalculator, s
         if (fromIndexTime(endOfFirstOccurence, index) <= adjustedMaxSeconds) {
             const endTime = getIndexSegmentEnd(element, index.timeline[i + 1], scaledPeriodEnd);
             if (fromIndexTime(endTime, index) <= adjustedMaxSeconds) {
-                return { isLastOfTimeline: i === index.timeline.length - 1,
+                return {
+                    isLastOfTimeline: i === index.timeline.length - 1,
                     timelineIdx: i,
                     newRepeatCount: element.repeatCount,
-                    end: endOfFirstOccurence };
+                    end: endOfFirstOccurence,
+                };
             }
             else {
                 // We have to find the right repeatCount
@@ -648,10 +654,12 @@ export function getLastRequestableSegmentInfo(index, manifestBoundsCalculator, s
                 const diffToSegStart = maxIndexTime - element.start;
                 const nbOfSegs = Math.floor(diffToSegStart / element.duration);
                 assert(nbOfSegs >= 1);
-                return { isLastOfTimeline: false,
+                return {
+                    isLastOfTimeline: false,
                     timelineIdx: i,
                     newRepeatCount: nbOfSegs - 1,
-                    end: element.start + nbOfSegs * element.duration };
+                    end: element.start + nbOfSegs * element.duration,
+                };
             }
         }
     }

package/dist/es2017/parsers/manifest/dash/common/indexes/tokens.js

@@ -34,8 +34,7 @@ function padLeftWithZeros(n, l) {
  */
 function processFormatedToken(replacer) {
     return (_match, _format, widthStr) => {
-        const width = isNonEmptyString(widthStr) ? parseInt(widthStr, 10) :
-            1;
+        const width = isNonEmptyString(widthStr) ? parseInt(widthStr, 10) : 1;
         return padLeftWithZeros(String(replacer), width);
     };
 }
@@ -64,8 +63,7 @@ export function replaceRepresentationDASHTokens(path, id, bitrate) {
         return path
             .replace(/\$\$/g, "$")
             .replace(/\$RepresentationID\$/g, String(id))
-            .replace(/\$Bandwidth(\%0(\d+)d)?\$/g, processFormatedToken(bitrate === undefined ? 0 :
-            bitrate));
+            .replace(/\$Bandwidth(\%0(\d+)d)?\$/g, processFormatedToken(bitrate === undefined ? 0 : bitrate));
     }
 }
 /**

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IRepresentationIntermediateRepresentation } from "../node_parser_types";
+import type { IRepresentationIntermediateRepresentation } from "../node_parser_types";
 /** Different "type" a parsed Adaptation can be. */
 type IAdaptationType = "audio" | "video" | "text";
 /** Structure of a parsed "scheme-like" element in the MPD. */

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

@@ -46,9 +46,9 @@ export default function inferAdaptationType(representations, adaptationMimeType,
         }
         // manage DASH-IF mp4-embedded subtitles and metadata
         if (mimeType === "application/mp4") {
-            if (roles != null) {
+            if (roles !== null) {
                 if (arrayFind(roles, (role) => role.schemeIdUri === "urn:mpeg:dash:role:2011" &&
-                    arrayIncludes(SUPPORTED_TEXT_TYPES, role.value)) != null) {
+                    arrayIncludes(SUPPORTED_TEXT_TYPES, role.value)) !== undefined) {
                     return "text";
                 }
             }

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

@@ -30,10 +30,10 @@ export default class ManifestBoundsCalculator {
      */
     constructor(args) {
         this._isDynamic = args.isDynamic;
-        this._timeShiftBufferDepth = !args.isDynamic ||
-            args.timeShiftBufferDepth === undefined ?
-            null :
-            args.timeShiftBufferDepth;
+        this._timeShiftBufferDepth =
+            !args.isDynamic || args.timeShiftBufferDepth === undefined
+                ? null
+                : args.timeShiftBufferDepth;
         this._serverTimestampOffset = args.serverTimestampOffset;
         this._availabilityStartTime = args.availabilityStartTime;
     }
@@ -65,9 +65,9 @@ export default class ManifestBoundsCalculator {
      */
     lastPositionIsKnown() {
         if (this._isDynamic) {
-            return this._positionTime != null && this._lastPosition != null;
+            return this._positionTime !== undefined && this._lastPosition !== undefined;
         }
-        return this._lastPosition != null;
+        return this._lastPosition !== undefined;
     }
     /**
      * Estimate a minimum bound for the content from the last set segment time
@@ -100,8 +100,8 @@ export default class ManifestBoundsCalculator {
         if (!this._isDynamic || this._serverTimestampOffset === undefined) {
             return undefined;
         }
-        return (getMonotonicTimeStamp() + this._serverTimestampOffset) / 1000 -
-            this._availabilityStartTime;
+        return ((getMonotonicTimeStamp() + this._serverTimestampOffset) / 1000 -
+            this._availabilityStartTime);
     }
     /**
      * Produce a rough estimate of the ending time of the last requestable segment
@@ -123,8 +123,7 @@ export default class ManifestBoundsCalculator {
             return liveEdge + availabilityTimeOffset;
         }
         else if (this._positionTime !== undefined && this._lastPosition !== undefined) {
-            return Math.max((this._lastPosition - this._positionTime) +
-                (getMonotonicTimeStamp() / 1000), 0);
+            return Math.max(this._lastPosition - this._positionTime + getMonotonicTimeStamp() / 1000, 0);
         }
         return this._lastPosition;
     }

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

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Period } from "../../../../manifest";
-import { IParsedAdaptations } from "../../types";
-import { IAdaptationSetIntermediateRepresentation, ISegmentTemplateIntermediateRepresentation } from "../node_parser_types";
-import { IRepresentationContext } from "./parse_representations";
+import type { IPeriod } from "../../../../manifest";
+import type { IParsedAdaptations } from "../../types";
+import type { IAdaptationSetIntermediateRepresentation, ISegmentTemplateIntermediateRepresentation } from "../node_parser_types";
+import type { IRepresentationContext } from "./parse_representations";
 /**
  * Process AdaptationSets intermediate representations to return under its final
  * form.
@@ -39,7 +39,7 @@ export interface IAdaptationSetContext extends IInheritedRepresentationContext {
      * de-synchronization with what is actually on the server,
      * Use with moderation.
      */
-    unsafelyBaseOnPreviousPeriod: Period | null;
+    unsafelyBaseOnPreviousPeriod: IPeriod | null;
 }
 /**
  * Supplementary context needed to parse a Representation common with