rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/_esm5.processed/parsers/manifest/smooth/get_codecs.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,19 +14,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNonEmptyString from "../../../utils/is_non_empty_string";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoCodecs = exports.getAudioCodecs = void 0;
+const is_non_empty_string_1 = require("../../../utils/is_non_empty_string");
 /**
  * @param {string} codecPrivateData
  * @param {string|undefined} fourCC
  * @returns {string}
  */
-export function getAudioCodecs(codecPrivateData, fourCC) {
-    var mpProfile;
+function getAudioCodecs(codecPrivateData, fourCC) {
+    let mpProfile;
     if (fourCC === "AACH") {
         mpProfile = 5; // High Efficiency AAC Profile
     }
     else {
-        mpProfile = isNonEmptyString(codecPrivateData) ?
+        mpProfile = (0, is_non_empty_string_1.default)(codecPrivateData) ?
             (parseInt(codecPrivateData.substring(0, 2), 16) & 0xF8) >> 3 :
             2;
     }
@@ -33,18 +36,20 @@ export function getAudioCodecs(codecPrivateData, fourCC) {
         // Return default audio codec
         return "mp4a.40.2";
     }
-    return "mp4a.40.".concat(mpProfile);
+    return `mp4a.40.${mpProfile}`;
 }
+exports.getAudioCodecs = getAudioCodecs;
 /**
  * @param {string} codecPrivateData
  * @returns {string}
  */
-export function getVideoCodecs(codecPrivateData) {
+function getVideoCodecs(codecPrivateData) {
     // we can extract codes only if fourCC is on of "H264", "X264", "DAVC", "AVC1"
-    var arr = /00000001\d7([0-9a-fA-F]{6})/.exec(codecPrivateData);
-    if (arr === null || !isNonEmptyString(arr[1])) {
+    const arr = /00000001\d7([0-9a-fA-F]{6})/.exec(codecPrivateData);
+    if (arr === null || !(0, is_non_empty_string_1.default)(arr[1])) {
         // Return default video codec
         return "avc1.4D401E";
     }
     return "avc1." + arr[1];
 }
+exports.getVideoCodecs = getVideoCodecs;

package/dist/_esm5.processed/parsers/manifest/smooth/index.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 createSmoothStreamingParser from "./create_parser";
-import SmoothRepresentationIndex from "./representation_index";
-export default createSmoothStreamingParser;
-export { SmoothRepresentationIndex, };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmoothRepresentationIndex = void 0;
+const create_parser_1 = require("./create_parser");
+const representation_index_1 = require("./representation_index");
+exports.SmoothRepresentationIndex = representation_index_1.default;
+exports.default = create_parser_1.default;

package/dist/_esm5.processed/parsers/manifest/smooth/parse_C_nodes.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,25 +14,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNonEmptyString from "../../../utils/is_non_empty_string";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_non_empty_string_1 = require("../../../utils/is_non_empty_string");
 /**
  * Parse C nodes to build index timeline.
  * @param {Element} nodes
  */
-export default function parseCNodes(nodes) {
-    return nodes.reduce(function (timeline, node, i) {
-        var dAttr = node.getAttribute("d");
-        var tAttr = node.getAttribute("t");
-        var rAttr = node.getAttribute("r");
-        var repeatCount = rAttr !== null ? +rAttr - 1 : 0;
-        var start = tAttr !== null ? +tAttr : undefined;
-        var duration = dAttr !== null ? +dAttr : undefined;
+function parseCNodes(nodes) {
+    return nodes.reduce((timeline, node, i) => {
+        const dAttr = node.getAttribute("d");
+        const tAttr = node.getAttribute("t");
+        const rAttr = node.getAttribute("r");
+        const repeatCount = rAttr !== null ? +rAttr - 1 : 0;
+        let start = tAttr !== null ? +tAttr : undefined;
+        let duration = dAttr !== null ? +dAttr : undefined;
         if (i === 0) { // first node
             start = start === undefined || isNaN(start) ? 0 :
                 start;
         }
         else { // from second node to the end
-            var prev = timeline[i - 1];
+            const prev = timeline[i - 1];
             if (start == null || isNaN(start)) {
                 if (prev.duration == null || isNaN(prev.duration)) {
                     throw new Error("Smooth: Invalid CNodes. Missing timestamp.");
@@ -40,10 +42,10 @@ export default function parseCNodes(nodes) {
             }
         }
         if (duration == null || isNaN(duration)) {
-            var nextNode = nodes[i + 1];
+            const nextNode = nodes[i + 1];
             if (nextNode !== undefined) {
-                var nextTAttr = nextNode.getAttribute("t");
-                var nextStart = isNonEmptyString(nextTAttr) ? +nextTAttr :
+                const nextTAttr = nextNode.getAttribute("t");
+                const nextStart = (0, is_non_empty_string_1.default)(nextTAttr) ? +nextTAttr :
                     null;
                 if (nextStart === null) {
                     throw new Error("Can't build index timeline from Smooth Manifest.");
@@ -54,7 +56,8 @@ export default function parseCNodes(nodes) {
                 return timeline;
             }
         }
-        timeline.push({ duration: duration, start: start, repeatCount: repeatCount });
+        timeline.push({ duration, start, repeatCount });
         return timeline;
     }, []);
 }
+exports.default = parseCNodes;

package/dist/_esm5.processed/parsers/manifest/smooth/parse_protection_node.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,46 +14,47 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { base64ToBytes } from "../../../utils/base64";
-import { concat } from "../../../utils/byte_parsing";
-import { hexToBytes } from "../../../utils/string_parsing";
-import { getPlayReadyKIDFromPrivateData } from "../../containers/isobmff";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base64_1 = require("../../../utils/base64");
+const byte_parsing_1 = require("../../../utils/byte_parsing");
+const string_parsing_1 = require("../../../utils/string_parsing");
+const isobmff_1 = require("../../containers/isobmff");
 /**
  * @param {Uint8Array} keyIdBytes
  * @returns {Array.<Object>}
  */
 function createWidevineKeySystem(keyIdBytes) {
     return [{ systemId: "edef8ba9-79d6-4ace-a3c8-27dcd51d21ed",
-            privateData: concat([0x08, 0x01, 0x12, 0x10], keyIdBytes) }];
+            privateData: (0, byte_parsing_1.concat)([0x08, 0x01, 0x12, 0x10], keyIdBytes) }];
 }
 /**
  * Parse "Protection" Node, which contains DRM information
  * @param {Element} protectionNode
  * @returns {Object}
  */
-export default function parseProtectionNode(protectionNode, keySystemCreator) {
-    if (keySystemCreator === void 0) { keySystemCreator = createWidevineKeySystem; }
+function parseProtectionNode(protectionNode, keySystemCreator = createWidevineKeySystem) {
     if (protectionNode.firstElementChild === null ||
         protectionNode.firstElementChild.nodeName !== "ProtectionHeader") {
         throw new Error("Protection should have ProtectionHeader child");
     }
-    var header = protectionNode.firstElementChild;
-    var privateData = base64ToBytes(header.textContent === null ? "" :
+    const header = protectionNode.firstElementChild;
+    const privateData = (0, base64_1.base64ToBytes)(header.textContent === null ? "" :
         header.textContent);
-    var keyIdHex = getPlayReadyKIDFromPrivateData(privateData);
-    var keyIdBytes = hexToBytes(keyIdHex);
+    const keyIdHex = (0, isobmff_1.getPlayReadyKIDFromPrivateData)(privateData);
+    const keyIdBytes = (0, string_parsing_1.hexToBytes)(keyIdHex);
     // remove possible braces
-    var systemIdAttr = header.getAttribute("SystemID");
-    var systemId = (systemIdAttr !== null ? systemIdAttr :
+    const systemIdAttr = header.getAttribute("SystemID");
+    const systemId = (systemIdAttr !== null ? systemIdAttr :
         "")
         .toLowerCase()
         .replace(/\{|\}/g, "");
     return {
         keyId: keyIdBytes,
         keySystems: [{
-                systemId: systemId,
-                privateData: privateData,
+                systemId,
+                privateData,
                 /* keyIds: [keyIdBytes], */
             }].concat(keySystemCreator(keyIdBytes)),
     };
 }
+exports.default = parseProtectionNode;

package/dist/_esm5.processed/parsers/manifest/smooth/representation_index.d.ts

@@ -68,9 +68,9 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
     /**
      * Value only calculated for live contents.
      *
-     * Calculates the difference, in timescale, between the current time (as
-     * calculated via performance.now()) and the time of the last segment known
-     * to have been generated on the server-side.
+     * Calculates the difference, in timescale, between the monotonically-raising
+     * timestamp used by the RxPlayer and the time of the last segment known to
+     * have been generated on the server-side.
      * Useful to know if a segment present in the timeline has actually been
      * generated on the server-side
      */

package/dist/_esm5.processed/parsers/manifest/smooth/representation_index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,12 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { NetworkError } from "../../../errors";
-import log from "../../../log";
-import assert from "../../../utils/assert";
-import { checkDiscontinuity, getIndexSegmentEnd, } from "../utils/index_helpers";
-import isSegmentStillAvailable from "../utils/is_segment_still_available";
-import { replaceSegmentSmoothTokens } from "./utils/tokens";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../../errors");
+const log_1 = require("../../../log");
+const assert_1 = require("../../../utils/assert");
+const monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
+const index_helpers_1 = require("../utils/index_helpers");
+const is_segment_still_available_1 = require("../utils/is_segment_still_available");
+const tokens_1 = require("./utils/tokens");
 /**
  * @param {Number} start
  * @param {Number} up
@@ -26,7 +29,7 @@ import { replaceSegmentSmoothTokens } from "./utils/tokens";
  * @returns {Number}
  */
 function getSegmentNumber(start, up, duration) {
-    var diff = up - start;
+    const diff = up - start;
     return diff > 0 ? Math.floor(diff / duration) :
         0;
 }
@@ -41,7 +44,7 @@ function getSegmentNumber(start, up, duration) {
  *   - to {Number}: timescaled timestamp of the end time (start time + duration)
  */
 function normalizeRange(timescale, start, duration) {
-    var ts = timescale === undefined ||
+    const ts = timescale === undefined ||
         timescale === 0 ? 1 :
         timescale;
     return { up: start * ts,
@@ -54,14 +57,14 @@ function normalizeRange(timescale, start, duration) {
  * @returns {Number}
  */
 function calculateRepeat(segment, nextSegment) {
-    var repeatCount = segment.repeatCount;
+    let repeatCount = segment.repeatCount;
     // A negative value of the @r attribute of the S element indicates
     // 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.
     // TODO Also for SMOOTH????
     if (segment.duration !== undefined && repeatCount < 0) {
-        var repeatEnd = nextSegment !== undefined ? nextSegment.start :
+        const repeatEnd = nextSegment !== undefined ? nextSegment.start :
             Infinity;
         repeatCount = Math.ceil((repeatEnd - segment.start) / segment.duration) - 1;
     }
@@ -74,14 +77,14 @@ function calculateRepeat(segment, nextSegment) {
  *
  * @class SmoothRepresentationIndex
  */
-var SmoothRepresentationIndex = /** @class */ (function () {
+class SmoothRepresentationIndex {
     /**
      * Creates a new `SmoothRepresentationIndex`.
      * @param {Object} index
      * @param {Object} options
      */
-    function SmoothRepresentationIndex(options) {
-        var isLive = options.isLive, segmentPrivateInfos = options.segmentPrivateInfos, media = options.media, sharedSmoothTimeline = options.sharedSmoothTimeline;
+    constructor(options) {
+        const { isLive, segmentPrivateInfos, media, sharedSmoothTimeline } = options;
         this._sharedSmoothTimeline = sharedSmoothTimeline;
         this._initSegmentInfos = { bitsPerSample: segmentPrivateInfos.bitsPerSample,
             channels: segmentPrivateInfos.channels,
@@ -95,10 +98,10 @@ var SmoothRepresentationIndex = /** @class */ (function () {
         this._isLive = isLive;
         this._media = media;
         if (sharedSmoothTimeline.timeline.length !== 0 && isLive) {
-            var timeline = sharedSmoothTimeline.timeline, validityTime = sharedSmoothTimeline.validityTime;
-            var lastItem = timeline[timeline.length - 1];
-            var scaledEnd = getIndexSegmentEnd(lastItem, null);
-            var scaledTimelineValidityTime = (validityTime / 1000) *
+            const { timeline, validityTime } = sharedSmoothTimeline;
+            const lastItem = timeline[timeline.length - 1];
+            const scaledEnd = (0, index_helpers_1.getIndexSegmentEnd)(lastItem, null);
+            const scaledTimelineValidityTime = (validityTime / 1000) *
                 sharedSmoothTimeline.timescale;
             this._scaledLiveGap = scaledTimelineValidityTime - scaledEnd;
         }
@@ -107,7 +110,7 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * Construct init Segment compatible with a Smooth Manifest.
      * @returns {Object}
      */
-    SmoothRepresentationIndex.prototype.getInitSegment = function () {
+    getInitSegment() {
         return { id: "init",
             isInit: true,
             privateInfos: { smoothInitSegment: this._initSegmentInfos },
@@ -117,7 +120,7 @@ var SmoothRepresentationIndex = /** @class */ (function () {
             duration: 0,
             timescale: 1,
             complete: true };
-    };
+    }
     /**
      * Generate a list of Segments for a particular period of time.
      *
@@ -125,40 +128,43 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * @param {Number} dur
      * @returns {Array.<Object>}
      */
-    SmoothRepresentationIndex.prototype.getSegments = function (from, dur) {
+    getSegments(from, dur) {
         this._refreshTimeline();
-        var _a = this._sharedSmoothTimeline, timescale = _a.timescale, timeline = _a.timeline;
-        var _b = normalizeRange(timescale, from, dur), up = _b.up, to = _b.to;
-        var media = this._media;
-        var currentNumber;
-        var segments = [];
-        var timelineLength = timeline.length;
-        var maxPosition = this._scaledLiveGap === undefined ?
+        const { timescale, timeline } = this._sharedSmoothTimeline;
+        const { up, to } = normalizeRange(timescale, from, dur);
+        const media = this._media;
+        let currentNumber;
+        const segments = [];
+        const timelineLength = timeline.length;
+        const maxPosition = this._scaledLiveGap === undefined ?
             undefined :
-            ((performance.now() / 1000) * timescale) - this._scaledLiveGap;
-        for (var i = 0; i < timelineLength; i++) {
-            var segmentRange = timeline[i];
-            var duration = segmentRange.duration, start = segmentRange.start;
-            var repeat = calculateRepeat(segmentRange, timeline[i + 1]);
-            var segmentNumberInCurrentRange = getSegmentNumber(start, up, duration);
-            var segmentTime = start + segmentNumberInCurrentRange * duration;
-            var timeToAddToCheckMaxPosition = duration;
+            (((0, monotonic_timestamp_1.default)() / 1000) * timescale) - this._scaledLiveGap;
+        for (let i = 0; i < timelineLength; i++) {
+            const segmentRange = timeline[i];
+            const { duration, start } = segmentRange;
+            const repeat = calculateRepeat(segmentRange, timeline[i + 1]);
+            let segmentNumberInCurrentRange = getSegmentNumber(start, up, duration);
+            let segmentTime = start + segmentNumberInCurrentRange * duration;
+            const timeToAddToCheckMaxPosition = duration;
             while (segmentTime < to &&
                 segmentNumberInCurrentRange <= repeat &&
                 (maxPosition === undefined ||
                     (segmentTime + timeToAddToCheckMaxPosition) <= maxPosition)) {
-                var time = segmentTime;
-                var number = currentNumber !== undefined ?
+                const time = segmentTime;
+                const number = currentNumber !== undefined ?
                     currentNumber + segmentNumberInCurrentRange :
                     undefined;
-                var segment = { id: String(segmentTime),
+                const segment = { id: String(segmentTime),
                     isInit: false,
                     time: time / timescale,
                     end: (time + duration) / timescale,
                     duration: duration / timescale,
-                    timescale: 1, number: number, url: replaceSegmentSmoothTokens(media, time),
+                    timescale: 1,
+                    number,
+                    url: (0, tokens_1.replaceSegmentSmoothTokens)(media, time),
                     complete: true,
-                    privateInfos: { smoothMediaSegment: { time: time, duration: duration } } };
+                    privateInfos: { smoothMediaSegment: { time,
+                            duration } } };
                 segments.push(segment);
                 // update segment number and segment time for the next segment
                 segmentNumberInCurrentRange++;
@@ -173,7 +179,7 @@ var SmoothRepresentationIndex = /** @class */ (function () {
             }
         }
         return segments;
-    };
+    }
     /**
      * Returns true if, based on the arguments, the index should be refreshed.
      * (If we should re-fetch the manifest)
@@ -181,18 +187,18 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * @param {Number} to
      * @returns {Boolean}
      */
-    SmoothRepresentationIndex.prototype.shouldRefresh = function (up, to) {
+    shouldRefresh(up, to) {
         this._refreshTimeline();
         if (!this._isLive) {
             return false;
         }
-        var _a = this._sharedSmoothTimeline, timeline = _a.timeline, timescale = _a.timescale;
-        var lastSegmentInCurrentTimeline = timeline[timeline.length - 1];
+        const { timeline, timescale } = this._sharedSmoothTimeline;
+        const lastSegmentInCurrentTimeline = timeline[timeline.length - 1];
         if (lastSegmentInCurrentTimeline === undefined) {
             return false;
         }
-        var repeat = lastSegmentInCurrentTimeline.repeatCount;
-        var endOfLastSegmentInCurrentTimeline = lastSegmentInCurrentTimeline.start + (repeat + 1) *
+        const repeat = lastSegmentInCurrentTimeline.repeatCount;
+        const endOfLastSegmentInCurrentTimeline = lastSegmentInCurrentTimeline.start + (repeat + 1) *
             lastSegmentInCurrentTimeline.duration;
         if (to * timescale < endOfLastSegmentInCurrentTimeline) {
             return false;
@@ -201,58 +207,58 @@ var SmoothRepresentationIndex = /** @class */ (function () {
             return true;
         }
         // ----
-        var startOfLastSegmentInCurrentTimeline = lastSegmentInCurrentTimeline.start + repeat *
+        const startOfLastSegmentInCurrentTimeline = lastSegmentInCurrentTimeline.start + repeat *
             lastSegmentInCurrentTimeline.duration;
         return (up * timescale) > startOfLastSegmentInCurrentTimeline;
-    };
+    }
     /**
      * Returns first position available in the index.
      * @returns {Number|null}
      */
-    SmoothRepresentationIndex.prototype.getFirstAvailablePosition = function () {
+    getFirstAvailablePosition() {
         this._refreshTimeline();
-        var _a = this._sharedSmoothTimeline, timeline = _a.timeline, timescale = _a.timescale;
+        const { timeline, timescale } = this._sharedSmoothTimeline;
         if (timeline.length === 0) {
             return null;
         }
         return timeline[0].start / timescale;
-    };
+    }
     /**
      * Returns last position available in the index.
      * @returns {Number}
      */
-    SmoothRepresentationIndex.prototype.getLastAvailablePosition = function () {
+    getLastAvailablePosition() {
         this._refreshTimeline();
-        var _a = this._sharedSmoothTimeline, timeline = _a.timeline, timescale = _a.timescale;
+        const { timeline, timescale } = this._sharedSmoothTimeline;
         if (this._scaledLiveGap === undefined) {
-            var lastTimelineElement = timeline[timeline.length - 1];
-            return getIndexSegmentEnd(lastTimelineElement, null) / timescale;
+            const lastTimelineElement = timeline[timeline.length - 1];
+            return (0, index_helpers_1.getIndexSegmentEnd)(lastTimelineElement, null) / timescale;
         }
-        for (var i = timeline.length - 1; i >= 0; i--) {
-            var timelineElt = timeline[i];
-            var timescaledNow = (performance.now() / 1000) * timescale;
-            var start = timelineElt.start, duration = timelineElt.duration, repeatCount = timelineElt.repeatCount;
-            for (var j = repeatCount; j >= 0; j--) {
-                var end = start + (duration * (j + 1));
-                var positionToReach = end;
+        for (let i = timeline.length - 1; i >= 0; i--) {
+            const timelineElt = timeline[i];
+            const timescaledNow = ((0, monotonic_timestamp_1.default)() / 1000) * timescale;
+            const { start, duration, repeatCount } = timelineElt;
+            for (let j = repeatCount; j >= 0; j--) {
+                const end = start + (duration * (j + 1));
+                const positionToReach = end;
                 if (positionToReach <= timescaledNow - this._scaledLiveGap) {
                     return end / timescale;
                 }
             }
         }
         return undefined;
-    };
+    }
     /**
      * Returns the absolute end in seconds this RepresentationIndex can reach once
      * all segments are available.
      * @returns {number|null|undefined}
      */
-    SmoothRepresentationIndex.prototype.getEnd = function () {
+    getEnd() {
         if (!this._isLive) {
             return this.getLastAvailablePosition();
         }
         return undefined;
-    };
+    }
     /**
      * Returns:
      *   - `true` if in the given time interval, at least one new segment is
@@ -264,19 +270,19 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * @param {number} end
      * @returns {boolean|undefined}
      */
-    SmoothRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
+    awaitSegmentBetween(start, end) {
         var _a;
-        assert(start <= end);
+        (0, assert_1.default)(start <= end);
         if (this.isFinished()) {
             return false;
         }
-        var lastAvailablePosition = this.getLastAvailablePosition();
+        const lastAvailablePosition = this.getLastAvailablePosition();
         if (lastAvailablePosition !== undefined && end < lastAvailablePosition) {
             return false;
         }
         return end > ((_a = this.getFirstAvailablePosition()) !== null && _a !== void 0 ? _a : 0) ? undefined :
             false;
-    };
+    }
     /**
      * Checks if `timeSec` is in a discontinuity.
      * That is, if there's no segment available for the `timeSec` position.
@@ -286,10 +292,10 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * `time`. If this is a number instead, there is one and that number is the
      * position for which a segment is available in seconds.
      */
-    SmoothRepresentationIndex.prototype.checkDiscontinuity = function (timeSec) {
+    checkDiscontinuity(timeSec) {
         this._refreshTimeline();
-        return checkDiscontinuity(this._sharedSmoothTimeline, timeSec, undefined);
-    };
+        return (0, index_helpers_1.checkDiscontinuity)(this._sharedSmoothTimeline, timeSec, undefined);
+    }
     /**
      * Returns `true` if a Segment returned by this index is still considered
      * available.
@@ -298,45 +304,45 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * @param {Object} segment
      * @returns {Boolean|undefined}
      */
-    SmoothRepresentationIndex.prototype.isSegmentStillAvailable = function (segment) {
+    isSegmentStillAvailable(segment) {
         if (segment.isInit) {
             return true;
         }
         this._refreshTimeline();
-        var _a = this._sharedSmoothTimeline, timeline = _a.timeline, timescale = _a.timescale;
-        return isSegmentStillAvailable(segment, timeline, timescale, 0);
-    };
+        const { timeline, timescale } = this._sharedSmoothTimeline;
+        return (0, is_segment_still_available_1.default)(segment, timeline, timescale, 0);
+    }
     /**
      * @param {Error} error
      * @returns {Boolean}
      */
-    SmoothRepresentationIndex.prototype.canBeOutOfSyncError = function (error) {
+    canBeOutOfSyncError(error) {
         if (!this._isLive) {
             return false;
         }
-        return error instanceof NetworkError &&
+        return error instanceof errors_1.NetworkError &&
             (error.isHttpError(404) || error.isHttpError(412));
-    };
+    }
     /**
      * Replace this RepresentationIndex by a newly downloaded one.
      * Check if the old index had more information about new segments and re-add
      * them if that's the case.
      * @param {Object} newIndex
      */
-    SmoothRepresentationIndex.prototype._replace = function (newIndex) {
+    _replace(newIndex) {
         this._initialScaledLastPosition = newIndex._initialScaledLastPosition;
         this._scaledLiveGap = newIndex._scaledLiveGap;
         this._sharedSmoothTimeline.replace(newIndex._sharedSmoothTimeline);
-    };
+    }
     /**
      * Update the current index with a new, partial, version.
      * This method might be use to only add information about new segments.
      * @param {Object} newIndex
      */
-    SmoothRepresentationIndex.prototype._update = function (newIndex) {
+    _update(newIndex) {
         this._scaledLiveGap = newIndex._scaledLiveGap;
         this._sharedSmoothTimeline.update(newIndex._sharedSmoothTimeline);
-    };
+    }
     /**
      * Returns `true` if the last segments in this index have already been
      * generated.
@@ -348,18 +354,18 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * TODO What about Smooth live content that finishes at some point?
      * @returns {boolean}
      */
-    SmoothRepresentationIndex.prototype.isFinished = function () {
+    isFinished() {
         return !this._isLive;
-    };
+    }
     /**
      * @returns {Boolean}
      */
-    SmoothRepresentationIndex.prototype.isInitialized = function () {
+    isInitialized() {
         return true;
-    };
-    SmoothRepresentationIndex.prototype.initialize = function () {
-        log.error("A `SmoothRepresentationIndex` does not need to be initialized");
-    };
+    }
+    initialize() {
+        log_1.default.error("A `SmoothRepresentationIndex` does not need to be initialized");
+    }
     /**
      * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
      * after `currentSegment`.
@@ -367,16 +373,15 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * @param {Object} segment - Information on the segment which contained that
      * new segment information.
      */
-    SmoothRepresentationIndex.prototype.addPredictedSegments = function (nextSegments, currentSegment) {
+    addPredictedSegments(nextSegments, currentSegment) {
         this._sharedSmoothTimeline.addPredictedSegments(nextSegments, currentSegment);
-    };
+    }
     /**
      * Clean-up timeline to remove segment information which should not be
      * available due to the timeshift window
      */
-    SmoothRepresentationIndex.prototype._refreshTimeline = function () {
+    _refreshTimeline() {
         this._sharedSmoothTimeline.refresh();
-    };
-    return SmoothRepresentationIndex;
-}());
-export default SmoothRepresentationIndex;
+    }
+}
+exports.default = SmoothRepresentationIndex;