rx-player 4.0.0-dev.2023111400 → 4.0.0-dev.2023121900

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

@@ -22,6 +22,7 @@ import { getFilenameIndexInUrl } from "../../../../utils/resolve_url";
 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";
@@ -129,11 +130,19 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
     const availabilityStartTime = parseAvailabilityStartTime(rootAttributes, args.referenceDateTime);
     const timeShiftBufferDepth = rootAttributes.timeShiftBufferDepth;
     const { externalClockOffset: clockOffset, unsafelyBaseOnPreviousManifest } = args;
+    const { externalClockOffset } = args;
+    const manifestBoundsCalculator = new ManifestBoundsCalculator({
+        availabilityStartTime,
+        isDynamic,
+        timeShiftBufferDepth,
+        serverTimestampOffset: externalClockOffset,
+    });
     const manifestInfos = { availabilityStartTime,
         baseURLs: mpdBaseUrls,
         clockOffset,
         duration: rootAttributes.duration,
         isDynamic,
+        manifestBoundsCalculator,
         manifestProfiles: mpdIR.attributes.profiles,
         receivedTime: args.manifestReceivedTime,
         timeShiftBufferDepth,
@@ -178,30 +187,33 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
             time: now };
     }
     else {
-        minimumTime = minimumSafePosition;
-        timeshiftDepth = timeShiftBufferDepth !== null && timeShiftBufferDepth !== void 0 ? timeShiftBufferDepth : null;
+        // Determine the maximum seekable position
         let finalMaximumSafePosition;
-        let livePosition;
-        if (maximumUnsafePosition !== undefined) {
-            livePosition = maximumUnsafePosition;
-        }
         if (maximumSafePosition !== undefined) {
             finalMaximumSafePosition = maximumSafePosition;
         }
         else {
-            const ast = availabilityStartTime !== null && availabilityStartTime !== void 0 ? availabilityStartTime : 0;
-            const { externalClockOffset } = args;
             if (externalClockOffset === undefined) {
                 log.warn("DASH Parser: use system clock to define maximum position");
-                finalMaximumSafePosition = (Date.now() / 1000) - ast;
+                finalMaximumSafePosition = (Date.now() / 1000) - availabilityStartTime;
             }
             else {
                 const serverTime = getMonotonicTimeStamp() + externalClockOffset;
-                finalMaximumSafePosition = (serverTime / 1000) - ast;
+                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) {
-            livePosition = finalMaximumSafePosition;
+            if (maximumUnsafePosition !== undefined) {
+                livePosition = maximumUnsafePosition;
+            }
+            else {
+                livePosition = finalMaximumSafePosition;
+            }
+            // manifestBoundsCalculator.forceLiveEdge(livePosition);
         }
         maximumTimeData = { isLinear: true,
             maximumSafePosition: finalMaximumSafePosition,
@@ -209,9 +221,11 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
             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 && minimumTime !== undefined &&
-            finalMaximumSafePosition - minimumTime > timeshiftDepth) {
-            timeshiftDepth = finalMaximumSafePosition - minimumTime;
+            livePosition - minimumTime > timeshiftDepth) {
+            timeshiftDepth = livePosition - minimumTime;
         }
     }
     // `isLastPeriodKnown` should be `true` in two cases for DASH contents:

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

@@ -63,5 +63,5 @@ export interface IPeriodContext extends IInheritedAdaptationContext {
         value: string;
     }> | undefined;
 }
-type IInheritedAdaptationContext = Omit<IAdaptationSetContext, "availabilityTimeComplete" | "availabilityTimeOffset" | "duration" | "isLastPeriod" | "manifestBoundsCalculator" | "start" | "unsafelyBaseOnPreviousPeriod">;
+type IInheritedAdaptationContext = Omit<IAdaptationSetContext, "availabilityTimeComplete" | "availabilityTimeOffset" | "duration" | "isLastPeriod" | "start" | "unsafelyBaseOnPreviousPeriod">;
 export {};

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

@@ -16,13 +16,13 @@
 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";
 // eslint-disable-next-line max-len
 import flattenOverlappingPeriods from "./flatten_overlapping_periods";
 import getPeriodsTimeInformation from "./get_periods_time_infos";
-import ManifestBoundsCalculator from "./manifest_bounds_calculator";
 import parseAdaptationSets from "./parse_adaptation_sets";
 import resolveBaseURLs from "./resolve_base_urls";
 const generatePeriodID = idGenerator();
@@ -33,16 +33,14 @@ const generatePeriodID = idGenerator();
  * @returns {Array.<Object>}
  */
 export default function parsePeriods(periodsIR, context) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d;
     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, timeShiftBufferDepth } = context;
-    const manifestBoundsCalculator = new ManifestBoundsCalculator({ isDynamic,
-        timeShiftBufferDepth });
-    if (!isDynamic && context.duration != null) {
+    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
@@ -54,7 +52,7 @@ export default function parsePeriods(periodsIR, context) {
         const periodBaseURLs = resolveBaseURLs(context.baseURLs, periodIR.children.baseURLs);
         const { periodStart, periodDuration, periodEnd } = periodsTimeInformation[i];
         let periodID;
-        if (periodIR.attributes.id == null) {
+        if (isNullOrUndefined(periodIR.attributes.id)) {
             log.warn("DASH: No usable id found in the Period. Generating one.");
             periodID = "gen-dash-period-" + generatePeriodID();
         }
@@ -69,8 +67,8 @@ export default function parsePeriods(periodsIR, context) {
             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 = (_c = periodIR.attributes.availabilityTimeComplete) !== null && _c !== void 0 ? _c : true;
-        const availabilityTimeOffset = (_d = periodIR.attributes.availabilityTimeOffset) !== null && _d !== void 0 ? _d : 0;
+        const availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete;
+        const availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset;
         const { manifestProfiles } = context;
         const { segmentTemplate } = periodIR.children;
         const adapCtxt = { availabilityTimeComplete,
@@ -84,11 +82,10 @@ export default function parsePeriods(periodsIR, context) {
             receivedTime,
             segmentTemplate,
             start: periodStart,
-            timeShiftBufferDepth,
             unsafelyBaseOnPreviousPeriod };
         const adaptations = parseAdaptationSets(periodIR.children.adaptations, adapCtxt);
-        const namespaces = ((_e = context.xmlNamespaces) !== null && _e !== void 0 ? _e : [])
-            .concat((_f = periodIR.attributes.namespaces) !== null && _f !== void 0 ? _f : []);
+        const namespaces = ((_c = context.xmlNamespaces) !== null && _c !== void 0 ? _c : [])
+            .concat((_d = periodIR.attributes.namespaces) !== null && _d !== void 0 ? _d : []);
         const streamEvents = generateStreamEvents(periodIR.children.eventStreams, periodStart, namespaces);
         const parsedPeriod = { id: periodID,
             start: periodStart,
@@ -158,7 +155,7 @@ export default function parsePeriods(periodsIR, context) {
  * @returns {Array.<number|undefined>}
  */
 function guessLastPositionFromClock(context, minimumTime) {
-    if (context.clockOffset != null) {
+    if (!isNullOrUndefined(context.clockOffset)) {
         const lastPosition = context.clockOffset / 1000 -
             context.availabilityStartTime;
         const positionTime = getMonotonicTimeStamp() / 1000;
@@ -193,7 +190,7 @@ function getMaximumLastPosition(adaptationsPerType) {
     let maxEncounteredPosition = null;
     let allIndexAreEmpty = true;
     const adaptationsVal = objectValues(adaptationsPerType)
-        .filter((ada) => ada != null);
+        .filter((ada) => !isNullOrUndefined(ada));
     const allAdaptations = flatMap(adaptationsVal, (adaptationsForType) => adaptationsForType);
     for (const adaptation of allAdaptations) {
         const representations = adaptation.representations;
@@ -203,13 +200,13 @@ function getMaximumLastPosition(adaptationsPerType) {
                 allIndexAreEmpty = false;
                 if (typeof position === "number") {
                     maxEncounteredPosition =
-                        maxEncounteredPosition == null ? position :
+                        isNullOrUndefined(maxEncounteredPosition) ? position :
                             Math.max(maxEncounteredPosition, position);
                 }
             }
         }
     }
-    if (maxEncounteredPosition != null) {
+    if (!isNullOrUndefined(maxEncounteredPosition)) {
         return maxEncounteredPosition;
     }
     else if (allIndexAreEmpty) {

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

@@ -29,10 +29,25 @@ export default function parseRepresentationIndex(representation: IRepresentation
 export interface IRepresentationIndexContext {
     /** Parsed AdaptationSet which contains the Representation. */
     adaptation: IAdaptationSetIntermediateRepresentation;
-    /** If false, declared segments in the MPD might still be not completely generated. */
-    availabilityTimeComplete: boolean;
-    /** availability time offset of the concerned Adaptation. */
-    availabilityTimeOffset: number;
+    /**
+     * If `false`, declared segments in the MPD might still be not completely generated.
+     * If `true`, they are completely generated.
+     *
+     * If `undefined`, the corresponding property was not set in the MPD and it is
+     * thus assumed that they are all generated.
+     * It might however be semantically different than `true` in the RxPlayer as it
+     * means that the packager didn't include that information in the MPD.
+     */
+    availabilityTimeComplete: boolean | undefined;
+    /**
+     * availability time offset of the concerned Adaptation.
+     *
+     * If `undefined`, the corresponding property was not set in the MPD and it is
+     * thus assumed to be equal to `0`.
+     * It might however be semantically different than `0` in the RxPlayer as it
+     * means that the packager didn't include that information in the MPD.
+     */
+    availabilityTimeOffset: number | undefined;
     /** Eventual URLs from which every relative URL will be based on. */
     baseURLs: IResolvedBaseUrl[];
     /** End time of the current Period, in seconds. */
@@ -61,8 +76,6 @@ export interface IRepresentationIndexContext {
     receivedTime?: number | undefined;
     /** Start time of the current period, in seconds. */
     start: number;
-    /** Depth of the buffer for the whole content, in seconds. */
-    timeShiftBufferDepth?: number | undefined;
     /**
      * The parser should take this Representation - which is the same as this one
      * parsed at an earlier time - as a base to speed-up the parsing process.

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

@@ -24,7 +24,7 @@ import { BaseRepresentationIndex, ListRepresentationIndex, TemplateRepresentatio
  */
 export default function parseRepresentationIndex(representation, context) {
     var _a, _b;
-    const { availabilityTimeOffset, manifestBoundsCalculator, isDynamic, end: periodEnd, start: periodStart, receivedTime, timeShiftBufferDepth, unsafelyBaseOnPreviousRepresentation, inbandEventStreams, isLastPeriod } = context;
+    const { availabilityTimeOffset, manifestBoundsCalculator, isDynamic, end: periodEnd, start: periodStart, receivedTime, unsafelyBaseOnPreviousRepresentation, inbandEventStreams, isLastPeriod } = context;
     const isEMSGWhitelisted = (inbandEvent) => {
         if (inbandEventStreams === undefined) {
             return false;
@@ -32,7 +32,8 @@ export default function parseRepresentationIndex(representation, context) {
         return inbandEventStreams
             .some(({ schemeIdUri }) => schemeIdUri === inbandEvent.schemeIdUri);
     };
-    const reprIndexCtxt = { availabilityTimeComplete: true,
+    const reprIndexCtxt = {
+        availabilityTimeComplete: undefined,
         availabilityTimeOffset,
         unsafelyBaseOnPreviousRepresentation,
         isEMSGWhitelisted,
@@ -44,7 +45,7 @@ export default function parseRepresentationIndex(representation, context) {
         receivedTime,
         representationBitrate: representation.attributes.bitrate,
         representationId: representation.attributes.id,
-        timeShiftBufferDepth };
+    };
     let representationIndex;
     if (representation.children.segmentBase !== undefined) {
         const { segmentBase } = representation.children;
@@ -62,11 +63,12 @@ export default function parseRepresentationIndex(representation, context) {
             segmentTemplates.push(childSegmentTemplate);
         }
         const segmentTemplate = objectAssign({}, ...segmentTemplates /* Ugly TS Hack */);
-        reprIndexCtxt.availabilityTimeComplete =
-            (_a = segmentTemplate.availabilityTimeComplete) !== null && _a !== void 0 ? _a : context.availabilityTimeComplete;
-        reprIndexCtxt.availabilityTimeOffset =
-            ((_b = segmentTemplate.availabilityTimeOffset) !== null && _b !== void 0 ? _b : 0) +
-                context.availabilityTimeOffset;
+        if (segmentTemplate.availabilityTimeOffset !== undefined ||
+            context.availabilityTimeOffset !== undefined) {
+            reprIndexCtxt.availabilityTimeOffset =
+                ((_a = segmentTemplate.availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0) +
+                    ((_b = context.availabilityTimeOffset) !== null && _b !== void 0 ? _b : 0);
+        }
         representationIndex = TimelineRepresentationIndex
             .isTimelineIndexArgument(segmentTemplate) ?
             new TimelineRepresentationIndex(segmentTemplate, reprIndexCtxt) :

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

@@ -77,7 +77,7 @@ function getHDRInformation({ adaptationProfiles, essentialProperties, supplement
  * @returns {Array.<Object>}
  */
 export default function parseRepresentations(representationsIR, adaptation, context) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const parsedRepresentations = [];
     for (const representation of representationsIR) {
         // Compute Representation ID
@@ -105,8 +105,12 @@ export default function parseRepresentations(representationsIR, adaptation, cont
             .unsafelyBaseOnPreviousAdaptation) === null || _a === void 0 ? void 0 : _a.getRepresentation(representationID)) !== null && _b !== void 0 ? _b : null;
         const inbandEventStreams = combineInbandEventStreams(representation, adaptation);
         const availabilityTimeComplete = (_c = representation.attributes.availabilityTimeComplete) !== null && _c !== void 0 ? _c : context.availabilityTimeComplete;
-        const availabilityTimeOffset = ((_d = representation.attributes.availabilityTimeOffset) !== null && _d !== void 0 ? _d : 0) +
-            context.availabilityTimeOffset;
+        let availabilityTimeOffset;
+        if (representation.attributes.availabilityTimeOffset !== undefined ||
+            context.availabilityTimeOffset !== undefined) {
+            availabilityTimeOffset = ((_d = representation.attributes.availabilityTimeOffset) !== null && _d !== void 0 ? _d : 0) +
+                ((_e = context.availabilityTimeOffset) !== null && _e !== void 0 ? _e : 0);
+        }
         const reprIndexCtxt = objectAssign({}, context, { availabilityTimeOffset,
             availabilityTimeComplete,
             unsafelyBaseOnPreviousRepresentation,

package/dist/es2017/parsers/manifest/local/representation_index.d.ts

@@ -63,7 +63,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
      * @returns {Boolean}
      */
     isSegmentStillAvailable(): true;
-    isFinished(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * @returns {Boolean}
      */

package/dist/es2017/parsers/manifest/local/representation_index.js

@@ -130,7 +130,7 @@ export default class LocalRepresentationIndex {
      * @returns {boolean|undefined}
      */
     awaitSegmentBetween(start, end) {
-        if (this.isFinished()) {
+        if (this.isStillAwaitingFutureSegments()) {
             return false;
         }
         if (this._index.incomingRanges === undefined) {
@@ -150,8 +150,8 @@ export default class LocalRepresentationIndex {
     isSegmentStillAvailable() {
         return true;
     }
-    isFinished() {
-        return this._index.isFinished;
+    isStillAwaitingFutureSegments() {
+        return !this._index.isFinished;
     }
     /**
      * @returns {Boolean}

package/dist/es2017/parsers/manifest/metaplaylist/representation_index.d.ts

@@ -128,7 +128,7 @@ export default class MetaRepresentationIndex implements IRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * @returns {Boolean}
      */

package/dist/es2017/parsers/manifest/metaplaylist/representation_index.js

@@ -162,8 +162,8 @@ export default class MetaRepresentationIndex {
     /**
      * @returns {Boolean}
      */
-    isFinished() {
-        return this._wrappedIndex.isFinished();
+    isStillAwaitingFutureSegments() {
+        return this._wrappedIndex.isStillAwaitingFutureSegments();
     }
     /**
      * @returns {Boolean}

package/dist/es2017/parsers/manifest/smooth/representation_index.d.ts

@@ -189,9 +189,9 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      */
     _update(newIndex: SmoothRepresentationIndex): void;
     /**
-     * Returns `true` if the last segments in this index have already been
+     * Returns `false` if the last segments in this index have already been
      * generated.
-     * Returns `false` if the index is still waiting on future segments to be
+     * Returns `true` if the index is still waiting on future segments to be
      * generated.
      *
      * For Smooth, it should only depend on whether the content is a live content
@@ -199,7 +199,7 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * TODO What about Smooth live content that finishes at some point?
      * @returns {boolean}
      */
-    isFinished(): boolean;
+    isStillAwaitingFutureSegments(): boolean;
     /**
      * @returns {Boolean}
      */
@@ -209,8 +209,8 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
      * after `currentSegment`.
      * @param {Array.<Object>} nextSegments - The segment information parsed.
-     * @param {Object} segment - Information on the segment which contained that
-     * new segment information.
+     * @param {Object} currentSegment - Information on the segment which contained
+     * that new segment information.
      */
     addPredictedSegments(nextSegments: Array<{
         duration: number;

package/dist/es2017/parsers/manifest/smooth/representation_index.js

@@ -18,7 +18,6 @@ import log from "../../../log";
 import assert from "../../../utils/assert";
 import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import { checkDiscontinuity, getIndexSegmentEnd, } from "../utils/index_helpers";
-import isSegmentStillAvailable from "../utils/is_segment_still_available";
 import { replaceSegmentSmoothTokens } from "./utils/tokens";
 /**
  * @param {Number} start
@@ -271,7 +270,7 @@ export default class SmoothRepresentationIndex {
     awaitSegmentBetween(start, end) {
         var _a;
         assert(start <= end);
-        if (this.isFinished()) {
+        if (this.isStillAwaitingFutureSegments()) {
             return false;
         }
         const lastAvailablePosition = this.getLastAvailablePosition();
@@ -308,7 +307,24 @@ export default class SmoothRepresentationIndex {
         }
         this._refreshTimeline();
         const { timeline, timescale } = this._sharedSmoothTimeline;
-        return isSegmentStillAvailable(segment, timeline, timescale, 0);
+        for (let i = 0; i < timeline.length; i++) {
+            const tSegment = timeline[i];
+            const tSegmentTime = tSegment.start / timescale;
+            if (tSegmentTime > segment.time) {
+                return false; // We went over it without finding it
+            }
+            else if (tSegmentTime === segment.time) {
+                return true;
+            }
+            else { // tSegment.start < segment.time
+                if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
+                    const timeDiff = tSegmentTime - tSegment.start;
+                    const repeat = (timeDiff / tSegment.duration) - 1;
+                    return repeat % 1 === 0 && repeat <= tSegment.repeatCount;
+                }
+            }
+        }
+        return false;
     }
     /**
      * @param {Error} error
@@ -342,9 +358,9 @@ export default class SmoothRepresentationIndex {
         this._sharedSmoothTimeline.update(newIndex._sharedSmoothTimeline);
     }
     /**
-     * Returns `true` if the last segments in this index have already been
+     * Returns `false` if the last segments in this index have already been
      * generated.
-     * Returns `false` if the index is still waiting on future segments to be
+     * Returns `true` if the index is still waiting on future segments to be
      * generated.
      *
      * For Smooth, it should only depend on whether the content is a live content
@@ -352,8 +368,8 @@ export default class SmoothRepresentationIndex {
      * TODO What about Smooth live content that finishes at some point?
      * @returns {boolean}
      */
-    isFinished() {
-        return !this._isLive;
+    isStillAwaitingFutureSegments() {
+        return this._isLive;
     }
     /**
      * @returns {Boolean}
@@ -368,8 +384,8 @@ export default class SmoothRepresentationIndex {
      * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
      * after `currentSegment`.
      * @param {Array.<Object>} nextSegments - The segment information parsed.
-     * @param {Object} segment - Information on the segment which contained that
-     * new segment information.
+     * @param {Object} currentSegment - Information on the segment which contained
+     * that new segment information.
      */
     addPredictedSegments(nextSegments, currentSegment) {
         this._sharedSmoothTimeline.addPredictedSegments(nextSegments, currentSegment);

package/dist/es2017/parsers/manifest/utils/index_helpers.js

@@ -97,7 +97,7 @@ export function getTimescaledRange(start, duration, timescale) {
  * timescaled time.
  * Returns -1 if the given time is lower than the start of the first available
  * segment.
- * @param {Object} index
+ * @param {Object} timeline
  * @param {Number} timeTScaled
  * @returns {Number}
  */

package/dist/es2017/parsers/texttracks/ttml/html/apply_line_height.js

@@ -22,10 +22,11 @@ import { REGXP_LENGTH } from "../regexps";
  */
 export default function applyLineHeight(element, lineHeight) {
     const trimmedLineHeight = lineHeight.trim();
+    const splittedLineHeight = trimmedLineHeight.split(" ");
     if (trimmedLineHeight === "auto") {
         return;
     }
-    const firstLineHeight = REGXP_LENGTH.exec(trimmedLineHeight[0]);
+    const firstLineHeight = REGXP_LENGTH.exec(splittedLineHeight[0]);
     if (firstLineHeight === null) {
         return;
     }