rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/parsers/manifest/types.d.ts

@@ -17,8 +17,8 @@ import { IRepresentationIndex } from "../../manifest";
 import { IHDRInformation } from "../../manifest/types";
 export interface IManifestStreamEvent {
     start: number;
-    end?: number;
-    id?: string;
+    end?: number | undefined;
+    id?: string | undefined;
     data: IParsedStreamEventData;
 }
 export interface IParsedStreamEventData {
@@ -32,7 +32,7 @@ export interface IParsedStreamEventData {
 /** Describes information about an encryption Key ID of a given media. */
 export interface IContentProtectionKID {
     keyId: Uint8Array;
-    systemId?: string;
+    systemId?: string | undefined;
 }
 /**
  * Encryption initialization data.
@@ -88,37 +88,37 @@ export interface IParsedRepresentation {
      */
     id: string;
     /** Codec(s) associated with this Representation. */
-    codecs?: string;
+    codecs?: string | undefined;
     /**
      * Information about the encryption associated with this Representation.
      * Not set if unknown or if the content is not encrypted.
      */
-    contentProtections?: IContentProtections;
+    contentProtections?: IContentProtections | undefined;
     /**
      * Frame rate (images per seconds) associated with this Representation.
      * Not set if unknown or if it makes no sense (e.g. for subtitles).
      */
-    frameRate?: string;
+    frameRate?: string | undefined;
     /**
      * Height (top to bottom) in pixels this Representation has.
      * Not set if unknown or if it makes no sense (e.g. for audio).
      */
-    height?: number;
+    height?: number | undefined;
     /**
      * Defines the mime-type of the content.
      * This allows to deduce the media container but most of the time, the
      * `codecs` will also be needed to know how to decode that media.
      */
-    mimeType?: string;
+    mimeType?: string | undefined;
     /**
      * Width (left to right) in pixels this Representation has.
      * Not set if unknown or if it makes no sense (e.g. for audio).
      */
-    width?: number;
+    width?: number | undefined;
     /**
      * Information about the HDR characteristic of a content.
      */
-    hdrInfo?: IHDRInformation;
+    hdrInfo?: IHDRInformation | undefined;
 }
 /** Every possible types an Adaptation can have. */
 export declare type IParsedAdaptationType = "audio" | "video" | "text" | "image";
@@ -144,34 +144,34 @@ export interface IParsedAdaptation {
      * Not set if unknown or if it makes no sense for the current track (e.g. for
      * a video track).
      */
-    audioDescription?: boolean;
+    audioDescription?: boolean | undefined;
     /**
      * Whether this Adaptation are closed captions for the hard of hearing.
      * Not set if unknown or if it makes no sense for the current track (e.g. for
      * a video track).
      */
-    closedCaption?: boolean;
+    closedCaption?: boolean | undefined;
     /**
      * If true this Adaptation is in a dub: it was recorded in another language
      * than the original(s) one(s).
      */
-    isDub?: boolean;
+    isDub?: boolean | undefined;
     /**
      * If true this Adaptation is in a sign interpreted: which is a variant of the
      * video with sign language.
      */
-    isSignInterpreted?: boolean;
+    isSignInterpreted?: boolean | undefined;
     /** Tells if the track is a trick mode track. */
-    isTrickModeTrack?: boolean;
+    isTrickModeTrack?: boolean | undefined;
     /**
      * Language the `Adaptation` is in.
      * Not set if unknown or if it makes no sense for the current track.
      */
-    language?: string;
+    language?: string | undefined;
     /**
      * TrickMode tracks attached to the adaptation.
      */
-    trickModeTracks?: IParsedAdaptation[];
+    trickModeTracks?: IParsedAdaptation[] | undefined;
 }
 /** Information on a given period of time in the Manifest */
 export interface IParsedPeriod {
@@ -193,18 +193,18 @@ export interface IParsedPeriod {
      * Duration of the Period (from the start to the end), in seconds.
      * `undefined` if the Period is the last one and is still being updated.
      */
-    duration?: number;
+    duration?: number | undefined;
     /**
      * Time at which the Period ends, in seconds.
      * `undefined` if the Period is the last one and is still
      * being updated.
      */
-    end?: number;
+    end?: number | undefined;
     /**
      * Array containing every stream event from period in manifest.
      * `undefined` if no parsed stream event in manifest.
      */
-    streamEvents?: IManifestStreamEvent[];
+    streamEvents?: IManifestStreamEvent[] | undefined;
 }
 /** Information on the whole content */
 export interface IParsedManifest {
@@ -227,23 +227,23 @@ export interface IParsedManifest {
      * The wall-clock time when the manifest was generated and published at the
      * origin server
      */
-    publishTime?: number;
+    publishTime?: number | undefined;
     /** Underlying transport protocol: "smooth", "dash", "metaplaylist" etc. */
     transportType: string;
     /** Base time from which the segments are generated. */
-    availabilityStartTime?: number;
+    availabilityStartTime?: number | undefined;
     /**
      * Offset, in milliseconds, the client's clock (in terms of `performance.now`)
      * has relatively to the server's
      */
-    clockOffset?: number;
+    clockOffset?: number | undefined;
     /** If set, the Manifest needs to be updated when that Promise resolves. */
-    expired?: Promise<void>;
+    expired?: Promise<void> | undefined;
     /**
      * Duration of the validity of this Manifest from its download time.
      * After that time has elapsed, the Manifest should be refreshed.
      */
-    lifetime?: number;
+    lifetime?: number | undefined;
     /**
      * Data allowing to calculate the minimum and maximum seekable positions at
      * any given time.
@@ -253,7 +253,7 @@ export interface IParsedManifest {
          * The minimum time, in seconds, available in this Manifest.
          * `undefined` if that value is unknown.
          */
-        absoluteMinimumTime?: number;
+        absoluteMinimumTime?: number | undefined;
         /**
          * Some dynamic contents have the concept of a "window depth" (or "buffer
          * depth") which allows to set a minimum position for all reachable
@@ -298,7 +298,7 @@ export interface IParsedManifest {
      * Suggested delay from the last position the player should start from by
      * default.
      */
-    suggestedPresentationDelay?: number;
+    suggestedPresentationDelay?: number | undefined;
     /** URIs where the manifest can be refreshed by order of importance. */
-    uris?: string[];
+    uris?: string[] | undefined;
 }

package/dist/_esm5.processed/parsers/manifest/utils/check_manifest_ids.js

@@ -61,7 +61,7 @@ export default function checkManifestIDs(manifest) {
                     var representationID = representation.id;
                     if (arrayIncludes(representationIDs, representationID)) {
                         log.warn("Two representations with the same ID found. Updating.", representationID);
-                        var newID = representationID + "-dup";
+                        var newID = "".concat(representationID, "-dup");
                         representation.id = newID;
                         checkManifestIDs(manifest);
                         representationIDs.push(newID);

package/dist/_esm5.processed/parsers/manifest/utils/clear_timeline_from_position.d.ts

@@ -18,6 +18,7 @@ import { IIndexSegment } from "./index_helpers";
  * Remove segments which starts before the given `firstAvailablePosition` from
  * the timeline. `firstAvailablePosition` has to be time scaled.
  * @param {Array.<Object>}
- * @returns {number}
+ * @returns {number} - Returns the number of removed segments. This includes
+ * potential implicit segment from decremented `repeatCount` attributes.
  */
-export default function clearTimelineFromPosition(timeline: IIndexSegment[], firstAvailablePosition: number): void;
+export default function clearTimelineFromPosition(timeline: IIndexSegment[], firstAvailablePosition: number): number;

package/dist/_esm5.processed/parsers/manifest/utils/clear_timeline_from_position.js

@@ -17,25 +17,32 @@
  * Remove segments which starts before the given `firstAvailablePosition` from
  * the timeline. `firstAvailablePosition` has to be time scaled.
  * @param {Array.<Object>}
- * @returns {number}
+ * @returns {number} - Returns the number of removed segments. This includes
+ * potential implicit segment from decremented `repeatCount` attributes.
  */
 export default function clearTimelineFromPosition(timeline, firstAvailablePosition) {
+    var nbEltsRemoved = 0;
     while (timeline.length > 0) {
         var firstElt = timeline[0];
         if (firstElt.start >= firstAvailablePosition) {
-            return; // all clear
+            return nbEltsRemoved; // all clear
         }
-        if (firstElt.repeatCount <= 0) {
+        if (firstElt.repeatCount === -1) {
+            return nbEltsRemoved;
+        }
+        else if (firstElt.repeatCount === 0) {
             timeline.shift();
+            nbEltsRemoved += 1;
         }
         else { // we have a segment repetition
             var nextElt = timeline[1];
-            if (nextElt != null && nextElt.start <= firstAvailablePosition) {
+            if (nextElt !== undefined && nextElt.start <= firstAvailablePosition) {
                 timeline.shift();
+                nbEltsRemoved += 1;
             }
             else { // no next segment or next segment is available
                 if (firstElt.duration <= 0) {
-                    return;
+                    return nbEltsRemoved;
                 }
                 var nextStart = firstElt.start + firstElt.duration;
                 var nextRepeat = 1;
@@ -46,14 +53,17 @@ export default function clearTimelineFromPosition(timeline, firstAvailablePositi
                 }
                 if (nextRepeat > firstElt.repeatCount) { // every start is before
                     timeline.shift();
+                    nbEltsRemoved = firstElt.repeatCount + 1;
                 }
                 else { // some repetitions start after and some before
                     var newRepeat = firstElt.repeatCount - nextRepeat;
                     firstElt.start = nextStart;
                     firstElt.repeatCount = newRepeat;
-                    return;
+                    nbEltsRemoved += nextRepeat;
+                    return nbEltsRemoved;
                 }
             }
         }
     }
+    return nbEltsRemoved;
 }

package/dist/_esm5.processed/parsers/manifest/utils/index_helpers.d.ts

@@ -13,21 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/** Generic way to represent segments in an index of segments. */
 export interface IIndexSegment {
+    /** The segment starting presentation time. */
     start: number;
+    /** Difference between the last and first presentation time. */
     duration: number;
+    /**
+     * Repeat counter.
+     * 1 === Repeat 1 time == 2 consecutive segments of this same duration.
+     */
     repeatCount: number;
-    range?: [number, number];
+    /** Optional byte-range the segment is available at when requested. */
+    range?: [number, number] | undefined;
 }
 /**
  * Calculate the number of times a timeline element repeats based on the next
  * element.
  * @param {Object} element
- * @param {Object} nextElement
- * @param {number} maxPosition
+ * @param {Object|null|undefined} nextElement
+ * @param {number|undefined} maxPosition
  * @returns {Number}
  */
-export declare function calculateRepeat(element: IIndexSegment, nextElement?: IIndexSegment | null, maxPosition?: number): number;
+export declare function calculateRepeat(element: IIndexSegment, nextElement?: IIndexSegment | null | undefined, maxPosition?: number | undefined): number;
 /**
  * Returns end of the segment given, in index time.
  * @param {Object} segment

package/dist/_esm5.processed/parsers/manifest/utils/index_helpers.js

@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// byte-range
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 /**
  * Calculate the number of times a timeline element repeats based on the next
  * element.
  * @param {Object} element
- * @param {Object} nextElement
- * @param {number} maxPosition
+ * @param {Object|null|undefined} nextElement
+ * @param {number|undefined} maxPosition
  * @returns {Number}
  */
 export function calculateRepeat(element, nextElement, maxPosition) {
@@ -32,10 +32,10 @@ export function calculateRepeat(element, nextElement, maxPosition) {
     // start of the next S element, the end of the Period or until the
     // next MPD update.
     var segmentEnd;
-    if (nextElement != null) {
+    if (!isNullOrUndefined(nextElement)) {
         segmentEnd = nextElement.start;
     }
-    else if (maxPosition != null) {
+    else if (maxPosition !== undefined) {
         segmentEnd = maxPosition;
     }
     else {

package/dist/_esm5.processed/parsers/manifest/utils/is_segment_still_available.js

@@ -32,18 +32,15 @@ export default function isSegmentStillAvailable(segment, timeline, timescale, in
             return false;
         }
         else if (tSegmentTime === segment.time) {
-            if ((tSegment.duration / timescale) !== segment.duration) {
-                return false;
-            }
-            if (tSegment.range == null) {
-                return segment.range == null;
+            if (tSegment.range === undefined) {
+                return segment.range === undefined;
             }
             return segment.range != null &&
                 tSegment.range[0] === segment.range[0] &&
                 tSegment.range[1] === segment.range[1];
         }
         else { // tSegment.start < segment.time
-            if (tSegment.repeatCount >= 0 && tSegment.duration != null) {
+            if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
                 var timeDiff = tSegmentTime - tSegment.start;
                 var repeat = (timeDiff / tSegment.duration) - 1;
                 return repeat % 1 === 0 && repeat <= tSegment.repeatCount;

package/dist/_esm5.processed/parsers/manifest/utils/update_segment_timeline.d.ts

@@ -17,7 +17,17 @@ import { IIndexSegment } from "./index_helpers";
 /**
  * Update a complete array of segments in a given timeline with a [generally]
  * smaller but [generally] newer set of segments.
+ *
+ * Returns a boolean:
+ *   - If set to `true`, the old timeline was emptied and completely replaced by
+ *     the content of the newer timeline.
+ *     This could happen either if a problem happened while trying to update or
+ *     when the update is actually bigger than what it is updating.
+ *   - If set to `false`, the older timeline was either updated to add the newer
+ *     segments, or untouched.
+ *
  * @param {Array.<Object>} oldTimeline
  * @param {Array.<Object>} newTimeline
+ * @returns {boolean}
  */
-export default function updateSegmentTimeline(oldTimeline: IIndexSegment[], newTimeline: IIndexSegment[]): void;
+export default function updateSegmentTimeline(oldTimeline: IIndexSegment[], newTimeline: IIndexSegment[]): boolean;

package/dist/_esm5.processed/parsers/manifest/utils/update_segment_timeline.js

@@ -13,10 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { MediaError } from "../../../errors";
 import log from "../../../log";
@@ -24,18 +28,28 @@ import { getIndexSegmentEnd, } from "./index_helpers";
 /**
  * Update a complete array of segments in a given timeline with a [generally]
  * smaller but [generally] newer set of segments.
+ *
+ * Returns a boolean:
+ *   - If set to `true`, the old timeline was emptied and completely replaced by
+ *     the content of the newer timeline.
+ *     This could happen either if a problem happened while trying to update or
+ *     when the update is actually bigger than what it is updating.
+ *   - If set to `false`, the older timeline was either updated to add the newer
+ *     segments, or untouched.
+ *
  * @param {Array.<Object>} oldTimeline
  * @param {Array.<Object>} newTimeline
+ * @returns {boolean}
  */
 export default function updateSegmentTimeline(oldTimeline, newTimeline) {
-    var prevTimelineLength = oldTimeline.length;
     if (oldTimeline.length === 0) {
-        oldTimeline.splice.apply(oldTimeline, __spreadArray([0, prevTimelineLength], newTimeline));
-        return;
+        oldTimeline.push.apply(oldTimeline, newTimeline);
+        return true;
     }
-    if (newTimeline.length === 0) {
-        return;
+    else if (newTimeline.length === 0) {
+        return false;
     }
+    var prevTimelineLength = oldTimeline.length;
     var newIndexStart = newTimeline[0].start;
     var oldLastElt = oldTimeline[prevTimelineLength - 1];
     var oldIndexEnd = getIndexSegmentEnd(oldLastElt, newTimeline[0]);
@@ -46,32 +60,34 @@ export default function updateSegmentTimeline(oldTimeline, newTimeline) {
         var currStart = oldTimeline[i].start;
         if (currStart === newIndexStart) {
             // replace that one and those after it
-            oldTimeline.splice.apply(oldTimeline, __spreadArray([i, prevTimelineLength - i], newTimeline));
-            return;
+            var nbEltsToRemove = prevTimelineLength - i;
+            oldTimeline.splice.apply(oldTimeline, __spreadArray([i, nbEltsToRemove], newTimeline, false));
+            return false;
         }
         else if (currStart < newIndexStart) { // first to be before
             var currElt = oldTimeline[i];
             if (currElt.start + currElt.duration > newIndexStart) {
-                // the new Manifest overlaps a previous segment (weird). Remove the latter.
-                log.warn("RepresentationIndex: Manifest update removed previous segments");
-                oldTimeline.splice.apply(oldTimeline, __spreadArray([i, prevTimelineLength - i], newTimeline));
-                return;
+                // The new Manifest overlaps a previous segment (weird)
+                // In that improbable case, we'll just completely replace segments
+                log.warn("RepresentationIndex: Manifest update removed all previous segments");
+                oldTimeline.splice.apply(oldTimeline, __spreadArray([0, prevTimelineLength], newTimeline, false));
+                return true;
             }
             else if (currElt.repeatCount === undefined || currElt.repeatCount <= 0) {
                 if (currElt.repeatCount < 0) {
                     currElt.repeatCount = Math.floor((newIndexStart - currElt.start) /
                         currElt.duration) - 1;
                 }
-                oldTimeline.splice.apply(oldTimeline, __spreadArray([i + 1, prevTimelineLength - (i + 1)], newTimeline));
-                return;
+                oldTimeline.splice.apply(oldTimeline, __spreadArray([i + 1, prevTimelineLength - (i + 1)], newTimeline, false));
+                return false;
             }
             // else, there is a positive repeat we might want to update
             var eltLastTime = currElt.start + currElt.duration * (currElt.repeatCount + 1);
             if (eltLastTime <= newIndexStart) { // our new index comes directly after
                 // put it after this one
                 oldTimeline.splice.apply(// our new index comes directly after
-                oldTimeline, __spreadArray([i + 1, prevTimelineLength - (i + 1)], newTimeline));
-                return;
+                oldTimeline, __spreadArray([i + 1, prevTimelineLength - (i + 1)], newTimeline, false));
+                return false;
             }
             var newCurrRepeat = ((newIndexStart - currElt.start) / currElt.duration) - 1;
             if (newCurrRepeat % 1 === 0 && currElt.duration === newTimeline[0].duration) {
@@ -79,16 +95,16 @@ export default function updateSegmentTimeline(oldTimeline, newTimeline) {
                     -1 : // === maximum possible repeat
                     newTimeline[0].repeatCount + newCurrRepeat + 1;
                 // replace that one and those after it
-                oldTimeline.splice.apply(oldTimeline, __spreadArray([i, prevTimelineLength - i], newTimeline));
+                oldTimeline.splice.apply(oldTimeline, __spreadArray([i, prevTimelineLength - i], newTimeline, false));
                 oldTimeline[i].start = currElt.start;
                 oldTimeline[i].repeatCount = newRepeatCount;
-                return;
+                return false;
             }
             log.warn("RepresentationIndex: Manifest update removed previous segments");
             oldTimeline[i].repeatCount = Math.floor(newCurrRepeat);
             // put it after this one
-            oldTimeline.splice.apply(oldTimeline, __spreadArray([i + 1, prevTimelineLength - (i + 1)], newTimeline));
-            return;
+            oldTimeline.splice.apply(oldTimeline, __spreadArray([i + 1, prevTimelineLength - (i + 1)], newTimeline, false));
+            return false;
         }
     }
     // if we got here, it means that every segments in the previous manifest are
@@ -99,12 +115,12 @@ export default function updateSegmentTimeline(oldTimeline, newTimeline) {
     if (prevLastElt.repeatCount !== undefined && prevLastElt.repeatCount < 0) {
         if (prevLastElt.start > newLastElt.start) {
             log.warn("RepresentationIndex: The new index is older than the previous one");
-            return; // the old comes after
+            return false;
         }
         else { // the new has more depth
             log.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
-            oldTimeline.splice.apply(oldTimeline, __spreadArray([0, prevTimelineLength], newTimeline));
-            return;
+            oldTimeline.splice.apply(oldTimeline, __spreadArray([0, prevTimelineLength], newTimeline, false));
+            return true;
         }
     }
     var prevLastTime = prevLastElt.start + prevLastElt.duration *
@@ -113,10 +129,10 @@ export default function updateSegmentTimeline(oldTimeline, newTimeline) {
         (newLastElt.repeatCount + 1);
     if (prevLastTime >= newLastTime) {
         log.warn("RepresentationIndex: The new index is older than the previous one");
-        return; // the old comes after
+        return false;
     }
     // the new one has more depth. full update
     log.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
-    oldTimeline.splice.apply(oldTimeline, __spreadArray([0, prevTimelineLength], newTimeline));
-    return;
+    oldTimeline.splice.apply(oldTimeline, __spreadArray([0, prevTimelineLength], newTimeline, false));
+    return true;
 }

package/dist/_esm5.processed/parsers/texttracks/sami/html.js

@@ -80,7 +80,7 @@ function getCSSProperty(str, name) {
  */
 function decodeEntities(text) {
     return text
-        .replace(HTML_ENTITIES, function (_, $1) { return String.fromCharCode($1); });
+        .replace(HTML_ENTITIES, function (_, $1) { return String.fromCharCode(Number($1)); });
 }
 /**
  * Because sami is not really html... we have to use
@@ -111,7 +111,7 @@ function parseSami(smi, timeOffset, lang) {
     if (isNonEmptyString(lang)) {
         klass = langs[lang];
         if (klass === undefined) {
-            throw new Error("sami: could not find lang " + lang + " in CSS");
+            throw new Error("sami: could not find lang ".concat(lang, " in CSS"));
         }
     }
     while (true) {

package/dist/_esm5.processed/parsers/texttracks/sami/native.js

@@ -80,7 +80,7 @@ function getCSSProperty(str, name) {
 function decodeEntities(text) {
     return text
         .replace(BR, "\n")
-        .replace(HTML_ENTITIES, function (_, $1) { return String.fromCharCode($1); });
+        .replace(HTML_ENTITIES, function (_, $1) { return String.fromCharCode(Number($1)); });
 }
 /**
  * Because sami is not really html... we have to use
@@ -111,7 +111,7 @@ function parseSami(smi, timeOffset, lang) {
     if (isNonEmptyString(lang)) {
         klass = langs[lang];
         if (klass === undefined) {
-            throw new Error("sami: could not find lang " + lang + " in CSS");
+            throw new Error("sami: could not find lang ".concat(lang, " in CSS"));
         }
     }
     while (true) {

package/dist/_esm5.processed/parsers/texttracks/srt/html.js

@@ -126,16 +126,11 @@ function generateSpansFromSRTText(text) {
                 spanChild.style.textDecoration = "underline";
                 span.appendChild(spanChild);
             }
-            else if (currentNode.nodeName === "FONT" &&
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                currentNode.color != null) {
+            else if (isNodeFontWithColorProp(currentNode) &&
+                typeof currentNode.color === "string") {
                 // TODO loop through attributes to find color?
-                /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-                /* eslint-disable @typescript-eslint/no-unsafe-member-access */
                 var spanChild = _loop(currentNode);
                 spanChild.style.color = currentNode.color;
-                /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-                /* eslint-enable @typescript-eslint/no-unsafe-member-access */
                 span.appendChild(spanChild);
             }
             else {
@@ -147,3 +142,12 @@ function generateSpansFromSRTText(text) {
     };
     return _loop(secureDiv);
 }
+/**
+ * Returns `true` if the given node is a `<font>` element which contains a
+ * `color` attribute.
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function isNodeFontWithColorProp(node) {
+    return node.nodeName === "FONT" && "color" in node;
+}

package/dist/_esm5.processed/parsers/texttracks/srt/parse_cue.js

@@ -56,6 +56,5 @@ export default function parseCueBlock(cueLines, timeOffset) {
         return null;
     }
     return { start: start + timeOffset,
-        end: end + timeOffset,
-        payload: payload };
+        end: end + timeOffset, payload: payload };
 }

package/dist/_esm5.processed/parsers/texttracks/ttml/get_parameters.js

@@ -80,9 +80,5 @@ export default function getParameters(tt) {
             frameRate = nbFrameRate * multiplierNum;
         }
     }
-    return { cellResolution: cellResolution,
-        tickRate: tickRate,
-        frameRate: frameRate,
-        subFrameRate: subFrameRate,
-        spaceStyle: spaceStyle };
+    return { cellResolution: cellResolution, tickRate: tickRate, frameRate: frameRate, subFrameRate: subFrameRate, spaceStyle: spaceStyle };
 }

package/dist/_esm5.processed/parsers/texttracks/ttml/html/apply_font_size.js

@@ -32,7 +32,6 @@ export default function applyFontSize(element, fontSize) {
         return;
     }
     if (firstFontSize[2] === "px" ||
-        firstFontSize[2] === "%" ||
         firstFontSize[2] === "em") {
         element.style.fontSize = firstFontSize[1] + firstFontSize[2];
     }
@@ -41,6 +40,19 @@ export default function applyFontSize(element, fontSize) {
         addClassName(element, "proportional-style");
         element.setAttribute("data-proportional-font-size", firstFontSize[1]);
     }
+    else if (firstFontSize[2] === "%") {
+        var toNum = Number(firstFontSize[1]);
+        if (isNaN(toNum)) {
+            log.warn("TTML Parser: could not parse fontSize value \"" +
+                firstFontSize[1] +
+                "\" into a number");
+        }
+        else {
+            element.style.position = "relative";
+            addClassName(element, "proportional-style");
+            element.setAttribute("data-proportional-font-size", String(toNum / 100));
+        }
+    }
     else {
         log.warn("TTML Parser: unhandled fontSize unit:", firstFontSize[2]);
     }