rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,35 +14,36 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../../log";
-import getFirstPositionFromAdaptation from "./get_first_time_from_adaptation";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../../log");
+const get_first_time_from_adaptation_1 = require("./get_first_time_from_adaptation");
 /**
  * @param {Object} manifest
  * @returns {number | undefined}
  */
-export default function getMinimumPosition(periods) {
-    for (var i = 0; i <= periods.length - 1; i++) {
-        var periodAdaptations = periods[i].adaptations;
-        var firstAudioAdaptationFromPeriod = periodAdaptations.audio === undefined ?
+function getMinimumPosition(periods) {
+    for (let i = 0; i <= periods.length - 1; i++) {
+        const periodAdaptations = periods[i].adaptations;
+        const firstAudioAdaptationFromPeriod = periodAdaptations.audio === undefined ?
             undefined :
             periodAdaptations.audio[0];
-        var firstVideoAdaptationFromPeriod = periodAdaptations.video === undefined ?
+        const firstVideoAdaptationFromPeriod = periodAdaptations.video === undefined ?
             undefined :
             periodAdaptations.video[0];
         if (firstAudioAdaptationFromPeriod !== undefined ||
             firstVideoAdaptationFromPeriod !== undefined) {
             // null == no segment
-            var minimumAudioPosition = null;
-            var minimumVideoPosition = null;
+            let minimumAudioPosition = null;
+            let minimumVideoPosition = null;
             if (firstAudioAdaptationFromPeriod !== undefined) {
-                var firstPosition = getFirstPositionFromAdaptation(firstAudioAdaptationFromPeriod);
+                const firstPosition = (0, get_first_time_from_adaptation_1.default)(firstAudioAdaptationFromPeriod);
                 if (firstPosition === undefined) {
                     return undefined;
                 }
                 minimumAudioPosition = firstPosition;
             }
             if (firstVideoAdaptationFromPeriod !== undefined) {
-                var firstPosition = getFirstPositionFromAdaptation(firstVideoAdaptationFromPeriod);
+                const firstPosition = (0, get_first_time_from_adaptation_1.default)(firstVideoAdaptationFromPeriod);
                 if (firstPosition === undefined) {
                     return undefined;
                 }
@@ -51,7 +53,7 @@ export default function getMinimumPosition(periods) {
                 minimumAudioPosition === null) ||
                 (firstVideoAdaptationFromPeriod !== undefined &&
                     minimumVideoPosition === null)) {
-                log.info("Parser utils: found Period with no segment. ", "Going to next one to calculate first position");
+                log_1.default.info("Parser utils: found Period with no segment. ", "Going to next one to calculate first position");
                 return undefined;
             }
             if (minimumVideoPosition !== null) {
@@ -66,3 +68,4 @@ export default function getMinimumPosition(periods) {
         }
     }
 }
+exports.default = getMinimumPosition;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDiscontinuity = exports.getTimescaledRange = exports.fromIndexTime = exports.toIndexTime = exports.getIndexSegmentEnd = exports.calculateRepeat = void 0;
+const is_null_or_undefined_1 = require("../../../utils/is_null_or_undefined");
 /**
  * Calculate the number of times a timeline element repeats based on the next
  * element.
@@ -22,8 +25,8 @@ import isNullOrUndefined from "../../../utils/is_null_or_undefined";
  * @param {number|undefined} maxPosition
  * @returns {Number}
  */
-export function calculateRepeat(element, nextElement, maxPosition) {
-    var repeatCount = element.repeatCount;
+function calculateRepeat(element, nextElement, maxPosition) {
+    const { repeatCount } = element;
     if (repeatCount >= 0) {
         return repeatCount;
     }
@@ -31,8 +34,8 @@ export function calculateRepeat(element, nextElement, maxPosition) {
     // that the duration indicated in @d attribute repeats until the
     // start of the next S element, the end of the Period or until the
     // next MPD update.
-    var segmentEnd;
-    if (!isNullOrUndefined(nextElement)) {
+    let segmentEnd;
+    if (!(0, is_null_or_undefined_1.default)(nextElement)) {
         segmentEnd = nextElement.start;
     }
     else if (maxPosition !== undefined) {
@@ -43,6 +46,7 @@ export function calculateRepeat(element, nextElement, maxPosition) {
     }
     return Math.ceil((segmentEnd - element.start) / element.duration) - 1;
 }
+exports.calculateRepeat = calculateRepeat;
 /**
  * Returns end of the segment given, in index time.
  * @param {Object} segment
@@ -50,14 +54,15 @@ export function calculateRepeat(element, nextElement, maxPosition) {
  * @param {number} maxPosition
  * @returns {Number}
  */
-export function getIndexSegmentEnd(segment, nextSegment, maxPosition) {
-    var start = segment.start, duration = segment.duration;
+function getIndexSegmentEnd(segment, nextSegment, maxPosition) {
+    const { start, duration } = segment;
     if (duration <= 0) {
         return start;
     }
-    var repeat = calculateRepeat(segment, nextSegment, maxPosition);
+    const repeat = calculateRepeat(segment, nextSegment, maxPosition);
     return start + (repeat + 1) * duration;
 }
+exports.getIndexSegmentEnd = getIndexSegmentEnd;
 /**
  * Convert from `presentationTime`, the time of the segment at the moment it
  * is decoded to `mediaTime`, the original time the segments point at.
@@ -65,10 +70,11 @@ export function getIndexSegmentEnd(segment, nextSegment, maxPosition) {
  * @param {Object} indexOptions
  * @returns {number}
  */
-export function toIndexTime(time, indexOptions) {
+function toIndexTime(time, indexOptions) {
     var _a;
     return time * indexOptions.timescale + ((_a = indexOptions.indexTimeOffset) !== null && _a !== void 0 ? _a : 0);
 }
+exports.toIndexTime = toIndexTime;
 /**
  * Convert from `mediaTime`, the original time the segments point at to
  * `presentationTime`, the time of the segment at the moment it is decoded.
@@ -76,10 +82,11 @@ export function toIndexTime(time, indexOptions) {
  * @param {Object} indexOptions
  * @returns {number}
  */
-export function fromIndexTime(time, indexOptions) {
+function fromIndexTime(time, indexOptions) {
     var _a;
     return (time - ((_a = indexOptions.indexTimeOffset) !== null && _a !== void 0 ? _a : 0)) / indexOptions.timescale;
 }
+exports.fromIndexTime = fromIndexTime;
 /**
  * @param {Number} start
  * @param {Number} duration
@@ -88,10 +95,11 @@ export function fromIndexTime(time, indexOptions) {
  *   - up {Number}: timescaled timestamp of the beginning time
  *   - to {Number}: timescaled timestamp of the end time (start time + duration)
  */
-export function getTimescaledRange(start, duration, timescale) {
+function getTimescaledRange(start, duration, timescale) {
     return [start * timescale,
         (start + duration) * timescale];
 }
+exports.getTimescaledRange = getTimescaledRange;
 /**
  * Get index of the last segment in the timeline starting before/at the given
  * timescaled time.
@@ -102,10 +110,10 @@ export function getTimescaledRange(start, duration, timescale) {
  * @returns {Number}
  */
 function getIndexOfLastObjectBefore(timeline, timeTScaled) {
-    var low = 0;
-    var high = timeline.length;
+    let low = 0;
+    let high = timeline.length;
     while (low < high) {
-        var mid = (low + high) >>> 1; // Divide by two + floor
+        const mid = (low + high) >>> 1; // Divide by two + floor
         if (timeline[mid].start <= timeTScaled) {
             low = mid + 1;
         }
@@ -121,27 +129,28 @@ function getIndexOfLastObjectBefore(timeline, timeTScaled) {
  * @param {number} [maxPosition]
  * @returns {number|null}
  */
-export function checkDiscontinuity(index, timeSec, maxPosition) {
-    var timeline = index.timeline;
-    var scaledTime = toIndexTime(timeSec, index);
+function checkDiscontinuity(index, timeSec, maxPosition) {
+    const { timeline } = index;
+    const scaledTime = toIndexTime(timeSec, index);
     if (scaledTime < 0) {
         return null;
     }
-    var segmentIndex = getIndexOfLastObjectBefore(timeline, scaledTime);
+    const segmentIndex = getIndexOfLastObjectBefore(timeline, scaledTime);
     if (segmentIndex < 0 || segmentIndex >= timeline.length - 1) {
         return null;
     }
-    var timelineItem = timeline[segmentIndex];
+    const timelineItem = timeline[segmentIndex];
     if (timelineItem.duration <= 0) {
         return null;
     }
-    var nextTimelineItem = timeline[segmentIndex + 1];
+    const nextTimelineItem = timeline[segmentIndex + 1];
     if (nextTimelineItem === undefined) {
         return null;
     }
-    var nextStart = nextTimelineItem.start;
-    var segmentEnd = getIndexSegmentEnd(timelineItem, nextTimelineItem, maxPosition);
+    const nextStart = nextTimelineItem.start;
+    const segmentEnd = getIndexSegmentEnd(timelineItem, nextTimelineItem, maxPosition);
     return scaledTime >= segmentEnd &&
         scaledTime < nextStart ? fromIndexTime(nextStart, index) :
         null;
 }
+exports.checkDiscontinuity = checkDiscontinuity;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Returns true if a Segment returned by the corresponding index is still
  * considered available.
@@ -24,10 +26,10 @@
  * @param {number} timeline
  * @returns {Boolean|undefined}
  */
-export default function isSegmentStillAvailable(segment, timeline, timescale, indexTimeOffset) {
-    for (var i = 0; i < timeline.length; i++) {
-        var tSegment = timeline[i];
-        var tSegmentTime = (tSegment.start - indexTimeOffset) / timescale;
+function isSegmentStillAvailable(segment, timeline, timescale, indexTimeOffset) {
+    for (let i = 0; i < timeline.length; i++) {
+        const tSegment = timeline[i];
+        const tSegmentTime = (tSegment.start - indexTimeOffset) / timescale;
         if (tSegmentTime > segment.time) {
             return false;
         }
@@ -41,11 +43,12 @@ export default function isSegmentStillAvailable(segment, timeline, timescale, in
         }
         else { // tSegment.start < segment.time
             if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
-                var timeDiff = tSegmentTime - tSegment.start;
-                var repeat = (timeDiff / tSegment.duration) - 1;
+                const timeDiff = tSegmentTime - tSegment.start;
+                const repeat = (timeDiff / tSegment.duration) - 1;
                 return repeat % 1 === 0 && repeat <= tSegment.repeatCount;
             }
         }
     }
     return false;
 }
+exports.default = isSegmentStillAvailable;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,18 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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";
-import { getIndexSegmentEnd, } from "./index_helpers";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../../errors");
+const log_1 = require("../../../log");
+const index_helpers_1 = require("./index_helpers");
 /**
  * Update a complete array of segments in a given timeline with a [generally]
  * smaller but [generally] newer set of segments.
@@ -41,36 +34,36 @@ import { getIndexSegmentEnd, } from "./index_helpers";
  * @param {Array.<Object>} newTimeline
  * @returns {boolean}
  */
-export default function updateSegmentTimeline(oldTimeline, newTimeline) {
+function updateSegmentTimeline(oldTimeline, newTimeline) {
     if (oldTimeline.length === 0) {
-        oldTimeline.push.apply(oldTimeline, newTimeline);
+        oldTimeline.push(...newTimeline);
         return true;
     }
     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]);
+    const prevTimelineLength = oldTimeline.length;
+    const newIndexStart = newTimeline[0].start;
+    const oldLastElt = oldTimeline[prevTimelineLength - 1];
+    const oldIndexEnd = (0, index_helpers_1.getIndexSegmentEnd)(oldLastElt, newTimeline[0]);
     if (oldIndexEnd < newIndexStart) {
-        throw new MediaError("MANIFEST_UPDATE_ERROR", "Cannot perform partial update: not enough data");
+        throw new errors_1.MediaError("MANIFEST_UPDATE_ERROR", "Cannot perform partial update: not enough data");
     }
-    for (var i = prevTimelineLength - 1; i >= 0; i--) {
-        var currStart = oldTimeline[i].start;
+    for (let i = prevTimelineLength - 1; i >= 0; i--) {
+        const currStart = oldTimeline[i].start;
         if (currStart === newIndexStart) {
             // replace that one and those after it
-            var nbEltsToRemove = prevTimelineLength - i;
-            oldTimeline.splice.apply(oldTimeline, __spreadArray([i, nbEltsToRemove], newTimeline, false));
+            const nbEltsToRemove = prevTimelineLength - i;
+            oldTimeline.splice(i, nbEltsToRemove, ...newTimeline);
             return false;
         }
         else if (currStart < newIndexStart) { // first to be before
-            var currElt = oldTimeline[i];
+            const currElt = oldTimeline[i];
             if (currElt.start + currElt.duration > newIndexStart) {
                 // 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));
+                log_1.default.warn("RepresentationIndex: Manifest update removed all previous segments");
+                oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
                 return true;
             }
             else if (currElt.repeatCount === undefined || currElt.repeatCount <= 0) {
@@ -78,61 +71,61 @@ export default function updateSegmentTimeline(oldTimeline, newTimeline) {
                     currElt.repeatCount = Math.floor((newIndexStart - currElt.start) /
                         currElt.duration) - 1;
                 }
-                oldTimeline.splice.apply(oldTimeline, __spreadArray([i + 1, prevTimelineLength - (i + 1)], newTimeline, false));
+                oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
                 return false;
             }
             // else, there is a positive repeat we might want to update
-            var eltLastTime = currElt.start + currElt.duration * (currElt.repeatCount + 1);
+            const 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, false));
+                oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
                 return false;
             }
-            var newCurrRepeat = ((newIndexStart - currElt.start) / currElt.duration) - 1;
+            const newCurrRepeat = ((newIndexStart - currElt.start) / currElt.duration) - 1;
             if (newCurrRepeat % 1 === 0 && currElt.duration === newTimeline[0].duration) {
-                var newRepeatCount = newTimeline[0].repeatCount < 0 ?
+                const newRepeatCount = newTimeline[0].repeatCount < 0 ?
                     -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, false));
+                oldTimeline.splice(i, prevTimelineLength - i, ...newTimeline);
                 oldTimeline[i].start = currElt.start;
                 oldTimeline[i].repeatCount = newRepeatCount;
                 return false;
             }
-            log.warn("RepresentationIndex: Manifest update removed previous segments");
+            log_1.default.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, false));
+            oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
             return false;
         }
     }
     // if we got here, it means that every segments in the previous manifest are
     // after the new one. This is unusual.
     // Either the new one has more depth or it's an older one.
-    var prevLastElt = oldTimeline[oldTimeline.length - 1];
-    var newLastElt = newTimeline[newTimeline.length - 1];
+    const prevLastElt = oldTimeline[oldTimeline.length - 1];
+    const newLastElt = newTimeline[newTimeline.length - 1];
     if (prevLastElt.repeatCount !== undefined && prevLastElt.repeatCount < 0) {
         if (prevLastElt.start > newLastElt.start) {
-            log.warn("RepresentationIndex: The new index is older than the previous one");
+            log_1.default.warn("RepresentationIndex: The new index is older than the previous one");
             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, false));
+            log_1.default.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
+            oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
             return true;
         }
     }
-    var prevLastTime = prevLastElt.start + prevLastElt.duration *
+    const prevLastTime = prevLastElt.start + prevLastElt.duration *
         (prevLastElt.repeatCount + 1);
-    var newLastTime = newLastElt.start + newLastElt.duration *
+    const newLastTime = newLastElt.start + newLastElt.duration *
         (newLastElt.repeatCount + 1);
     if (prevLastTime >= newLastTime) {
-        log.warn("RepresentationIndex: The new index is older than the previous one");
+        log_1.default.warn("RepresentationIndex: The new index is older than the previous one");
         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, false));
+    log_1.default.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
+    oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
     return true;
 }
+exports.default = updateSegmentTimeline;

package/dist/_esm5.processed/parsers/texttracks/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,4 +14,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 // __VERY__ simple SAMI parser, based on ugly-but-working REGEXP:
 //   - the text, start and end times are correctly parsed.
 //   - only text for the given language is parsed.
@@ -25,26 +27,26 @@
  * /!\ This file is feature-switchable.
  * It always should be imported through the `features` object.
  */
-import isNonEmptyString from "../../../utils/is_non_empty_string";
-var HTML_ENTITIES = /&#([0-9]+);/g;
-var BR = /<br>/gi;
-var STYLE = /<style[^>]*>([\s\S]*?)<\/style[^>]*>/i;
-var PARAG = /\s*<p (?:class=([^>]+))?>(.*)/i;
-var START = /<sync[^>]+?start="?([0-9]*)"?[^0-9]/i;
+const is_non_empty_string_1 = require("../../../utils/is_non_empty_string");
+const HTML_ENTITIES = /&#([0-9]+);/g;
+const BR = /<br>/gi;
+const STYLE = /<style[^>]*>([\s\S]*?)<\/style[^>]*>/i;
+const PARAG = /\s*<p (?:class=([^>]+))?>(.*)/i;
+const START = /<sync[^>]+?start="?([0-9]*)"?[^0-9]/i;
 /**
  * Returns classnames for every languages.
  * @param {string} str
  * @returns {Object}
  */
 function getClassNameByLang(str) {
-    var ruleRe = /\.(\S+)\s*{([^}]*)}/gi;
-    var langs = {};
-    var m = ruleRe.exec(str);
+    const ruleRe = /\.(\S+)\s*{([^}]*)}/gi;
+    const langs = {};
+    let m = ruleRe.exec(str);
     while (m !== null) {
-        var name_1 = m[1];
-        var lang = getCSSProperty(m[2], "lang");
-        if (name_1 != null && lang != null) {
-            langs[lang] = name_1;
+        const name = m[1];
+        const lang = getCSSProperty(m[2], "lang");
+        if (name != null && lang != null) {
+            langs[lang] = name;
         }
         m = ruleRe.exec(str);
     }
@@ -57,8 +59,8 @@ function getClassNameByLang(str) {
  * @returns {string}
  */
 function getPCSSRules(str) {
-    var pRuleRegex = /p\s*{([^}]*)}/gi;
-    var rule = pRuleRegex.exec(str);
+    const pRuleRegex = /p\s*{([^}]*)}/gi;
+    const rule = pRuleRegex.exec(str);
     if (rule === null) {
         return "";
     }
@@ -70,7 +72,7 @@ function getPCSSRules(str) {
  * @returns {string|null} - value of the property. Null if not found.
  */
 function getCSSProperty(str, name) {
-    var matches = (new RegExp("\\s*" + name + ":\\s*(\\S+);", "i")).exec(str);
+    const matches = (new RegExp("\\s*" + name + ":\\s*(\\S+);", "i")).exec(str);
     return Array.isArray(matches) ? matches[1] :
         null;
 }
@@ -80,7 +82,7 @@ function getCSSProperty(str, name) {
  */
 function decodeEntities(text) {
     return text
-        .replace(HTML_ENTITIES, function (_, $1) { return String.fromCharCode(Number($1)); });
+        .replace(HTML_ENTITIES, (_, $1) => String.fromCharCode(Number($1)));
 }
 /**
  * Because sami is not really html... we have to use
@@ -94,24 +96,24 @@ function decodeEntities(text) {
  * @param {string} lang
  */
 function parseSami(smi, timeOffset, lang) {
-    var syncOpen = /<sync[ >]/ig;
-    var syncClose = /<sync[ >]|<\/body>/ig;
-    var subs = [];
-    var styleMatches = STYLE.exec(smi);
-    var css = Array.isArray(styleMatches) ? styleMatches[1] :
+    const syncOpen = /<sync[ >]/ig;
+    const syncClose = /<sync[ >]|<\/body>/ig;
+    const subs = [];
+    const styleMatches = STYLE.exec(smi);
+    const css = Array.isArray(styleMatches) ? styleMatches[1] :
         "";
-    var up;
-    var to;
+    let up;
+    let to;
     // FIXME Is that wanted?
     // previously written as let to = SyncClose.exec(smi); but never used
     syncClose.exec(smi);
-    var langs = getClassNameByLang(css);
-    var pCSS = getPCSSRules(css);
-    var klass;
-    if (isNonEmptyString(lang)) {
+    const langs = getClassNameByLang(css);
+    const pCSS = getPCSSRules(css);
+    let klass;
+    if ((0, is_non_empty_string_1.default)(lang)) {
         klass = langs[lang];
         if (klass === undefined) {
-            throw new Error("sami: could not find lang ".concat(lang, " in CSS"));
+            throw new Error(`sami: could not find lang ${lang} in CSS`);
         }
     }
     while (true) {
@@ -123,12 +125,12 @@ function parseSami(smi, timeOffset, lang) {
         if (up === null || to === null || up.index >= to.index) {
             throw new Error("parse error");
         }
-        var str = smi.slice(up.index, to.index);
-        var tim = START.exec(str);
+        const str = smi.slice(up.index, to.index);
+        const tim = START.exec(str);
         if (!Array.isArray(tim)) {
             throw new Error("parse error (sync time attribute)");
         }
-        var start = +tim[1];
+        const start = +tim[1];
         if (isNaN(start)) {
             throw new Error("parse error (sync time attribute NaN)");
         }
@@ -136,13 +138,13 @@ function parseSami(smi, timeOffset, lang) {
     }
     return subs;
     function appendToSubs(lines, start) {
-        var i = lines.length;
+        let i = lines.length;
         while (--i >= 0) {
-            var paragraphInfos = PARAG.exec(lines[i]);
+            const paragraphInfos = PARAG.exec(lines[i]);
             if (!Array.isArray(paragraphInfos)) {
                 continue;
             }
-            var className = paragraphInfos[1], txt = paragraphInfos[2];
+            const [, className, txt] = paragraphInfos;
             if (klass !== className) {
                 continue;
             }
@@ -150,9 +152,9 @@ function parseSami(smi, timeOffset, lang) {
                 subs[subs.length - 1].end = start;
             }
             else {
-                var wrapperEl = document.createElement("DIV");
+                const wrapperEl = document.createElement("DIV");
                 wrapperEl.className = "rxp-texttrack-region";
-                var divEl = document.createElement("DIV");
+                const divEl = document.createElement("DIV");
                 divEl.className = "rxp-texttrack-div";
                 divEl.style.position = "absolute";
                 divEl.style.bottom = "0";
@@ -162,17 +164,17 @@ function parseSami(smi, timeOffset, lang) {
                     "1px -1px 0 #000," +
                     "-1px 1px 0 #000," +
                     "1px 1px 0 #000";
-                var pEl = document.createElement("div");
+                const pEl = document.createElement("div");
                 pEl.className = "rxp-texttrack-p";
-                if (isNonEmptyString(pCSS)) {
+                if ((0, is_non_empty_string_1.default)(pCSS)) {
                     pEl.style.cssText = pCSS;
                 }
-                var textEls = txt.split(BR);
-                for (var j = 0; j < textEls.length; j++) {
+                const textEls = txt.split(BR);
+                for (let j = 0; j < textEls.length; j++) {
                     if (j !== 0) {
                         pEl.appendChild(document.createElement("BR"));
                     }
-                    var spanEl = document.createElement("SPAN");
+                    const spanEl = document.createElement("SPAN");
                     spanEl.className = "rxp-texttrack-span";
                     spanEl.textContent = decodeEntities(textEls[j]);
                     pEl.appendChild(spanEl);
@@ -186,4 +188,4 @@ function parseSami(smi, timeOffset, lang) {
         }
     }
 }
-export default parseSami;
+exports.default = parseSami;