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

package/dist/_esm5.processed/manifest/manifest.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,30 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import log from "../log";
-import arrayFind from "../utils/array_find";
-import EventEmitter from "../utils/event_emitter";
-import idGenerator from "../utils/id_generator";
-import warnOnce from "../utils/warn_once";
-import Period from "./period";
-import { MANIFEST_UPDATE_TYPE } from "./types";
-import { replacePeriods, updatePeriods, } from "./update_periods";
-var generateNewManifestId = idGenerator();
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+const log_1 = require("../log");
+const array_find_1 = require("../utils/array_find");
+const event_emitter_1 = require("../utils/event_emitter");
+const id_generator_1 = require("../utils/id_generator");
+const monotonic_timestamp_1 = require("../utils/monotonic_timestamp");
+const warn_once_1 = require("../utils/warn_once");
+const period_1 = require("./period");
+const types_1 = require("./types");
+const update_periods_1 = require("./update_periods");
+const generateNewManifestId = (0, id_generator_1.default)();
 /**
  * Normalized Manifest structure.
  *
@@ -56,8 +45,7 @@ var generateNewManifestId = idGenerator();
  *
  * @class Manifest
  */
-var Manifest = /** @class */ (function (_super) {
-    __extends(Manifest, _super);
+class Manifest extends event_emitter_1.default {
     /**
      * Construct a Manifest instance from a parsed Manifest object (as returned by
      * Manifest parsers) and options.
@@ -66,43 +54,45 @@ var Manifest = /** @class */ (function (_super) {
      * will contain all such errors, in the order they have been encountered.
      * @param {Object} parsedManifest
      * @param {Object} options
+     * @param {Array.<Object>} warnings - After construction, will be optionally
+     * filled by errors expressing minor issues seen while parsing the Manifest.
      */
-    function Manifest(parsedManifest, options) {
-        var _this = this;
+    constructor(parsedManifest, options, warnings) {
         var _a;
-        _this = _super.call(this) || this;
-        var representationFilter = options.representationFilter, manifestUpdateUrl = options.manifestUpdateUrl;
-        _this.contentWarnings = [];
-        _this.id = generateNewManifestId();
-        _this.expired = (_a = parsedManifest.expired) !== null && _a !== void 0 ? _a : null;
-        _this.transport = parsedManifest.transportType;
-        _this.clockOffset = parsedManifest.clockOffset;
-        _this.periods = parsedManifest.periods.map(function (parsedPeriod) {
-            var _a;
-            var period = new Period(parsedPeriod, representationFilter);
-            (_a = _this.contentWarnings).push.apply(_a, period.contentWarnings);
+        super();
+        const { representationFilter, manifestUpdateUrl } = options;
+        this.id = generateNewManifestId();
+        this.expired = (_a = parsedManifest.expired) !== null && _a !== void 0 ? _a : null;
+        this.transport = parsedManifest.transportType;
+        this.clockOffset = parsedManifest.clockOffset;
+        const unsupportedAdaptations = [];
+        this.periods = parsedManifest.periods.map((parsedPeriod) => {
+            const period = new period_1.default(parsedPeriod, unsupportedAdaptations, representationFilter);
             return period;
-        }).sort(function (a, b) { return a.start - b.start; });
+        }).sort((a, b) => a.start - b.start);
+        if (unsupportedAdaptations.length > 0) {
+            const error = new errors_1.MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "An Adaptation contains only incompatible codecs.", { adaptations: unsupportedAdaptations });
+            warnings.push(error);
+        }
         /**
          * @deprecated It is here to ensure compatibility with the way the
          * v3.x.x manages adaptations at the Manifest level
          */
         /* eslint-disable import/no-deprecated */
-        _this.adaptations = _this.periods[0] === undefined ? {} :
-            _this.periods[0].adaptations;
+        this.adaptations = this.periods[0] === undefined ? {} :
+            this.periods[0].adaptations;
         /* eslint-enable import/no-deprecated */
-        _this._timeBounds = parsedManifest.timeBounds;
-        _this.isDynamic = parsedManifest.isDynamic;
-        _this.isLive = parsedManifest.isLive;
-        _this.isLastPeriodKnown = parsedManifest.isLastPeriodKnown;
-        _this.uris = parsedManifest.uris === undefined ? [] :
+        this._timeBounds = parsedManifest.timeBounds;
+        this.isDynamic = parsedManifest.isDynamic;
+        this.isLive = parsedManifest.isLive;
+        this.isLastPeriodKnown = parsedManifest.isLastPeriodKnown;
+        this.uris = parsedManifest.uris === undefined ? [] :
             parsedManifest.uris;
-        _this.updateUrl = manifestUpdateUrl;
-        _this.lifetime = parsedManifest.lifetime;
-        _this.suggestedPresentationDelay = parsedManifest.suggestedPresentationDelay;
-        _this.availabilityStartTime = parsedManifest.availabilityStartTime;
-        _this.publishTime = parsedManifest.publishTime;
-        return _this;
+        this.updateUrl = manifestUpdateUrl;
+        this.lifetime = parsedManifest.lifetime;
+        this.suggestedPresentationDelay = parsedManifest.suggestedPresentationDelay;
+        this.availabilityStartTime = parsedManifest.availabilityStartTime;
+        this.publishTime = parsedManifest.publishTime;
     }
     /**
      * Returns the Period corresponding to the given `id`.
@@ -110,67 +100,67 @@ var Manifest = /** @class */ (function (_super) {
      * @param {string} id
      * @returns {Object|undefined}
      */
-    Manifest.prototype.getPeriod = function (id) {
-        return arrayFind(this.periods, function (period) {
+    getPeriod(id) {
+        return (0, array_find_1.default)(this.periods, (period) => {
             return id === period.id;
         });
-    };
+    }
     /**
      * Returns the Period encountered at the given time.
      * Returns `undefined` if there is no Period exactly at the given time.
      * @param {number} time
      * @returns {Object|undefined}
      */
-    Manifest.prototype.getPeriodForTime = function (time) {
-        return arrayFind(this.periods, function (period) {
+    getPeriodForTime(time) {
+        return (0, array_find_1.default)(this.periods, (period) => {
             return time >= period.start &&
                 (period.end === undefined || period.end > time);
         });
-    };
+    }
     /**
      * Returns the first Period starting strictly after the given time.
      * Returns `undefined` if there is no Period starting after that time.
      * @param {number} time
      * @returns {Object|undefined}
      */
-    Manifest.prototype.getNextPeriod = function (time) {
-        return arrayFind(this.periods, function (period) {
+    getNextPeriod(time) {
+        return (0, array_find_1.default)(this.periods, (period) => {
             return period.start > time;
         });
-    };
+    }
     /**
      * Returns the Period coming chronologically just after another given Period.
      * Returns `undefined` if not found.
      * @param {Object} period
      * @returns {Object|null}
      */
-    Manifest.prototype.getPeriodAfter = function (period) {
-        var endOfPeriod = period.end;
+    getPeriodAfter(period) {
+        const endOfPeriod = period.end;
         if (endOfPeriod === undefined) {
             return null;
         }
-        var nextPeriod = arrayFind(this.periods, function (_period) {
+        const nextPeriod = (0, array_find_1.default)(this.periods, (_period) => {
             return _period.end === undefined || endOfPeriod < _period.end;
         });
         return nextPeriod === undefined ? null :
             nextPeriod;
-    };
+    }
     /**
      * Returns the most important URL from which the Manifest can be refreshed.
      * `undefined` if no URL is found.
      * @returns {Array.<string>}
      */
-    Manifest.prototype.getUrls = function () {
+    getUrls() {
         return this.uris;
-    };
+    }
     /**
      * Update the current Manifest properties by giving a new updated version.
      * This instance will be updated with the new information coming from it.
      * @param {Object} newManifest
      */
-    Manifest.prototype.replace = function (newManifest) {
-        this._performUpdate(newManifest, MANIFEST_UPDATE_TYPE.Full);
-    };
+    replace(newManifest) {
+        this._performUpdate(newManifest, types_1.MANIFEST_UPDATE_TYPE.Full);
+    }
     /**
      * Update the current Manifest properties by giving a new but shorter version
      * of it.
@@ -181,62 +171,62 @@ var Manifest = /** @class */ (function (_super) {
      * update the Manifest.
      * @param {Object} newManifest
      */
-    Manifest.prototype.update = function (newManifest) {
-        this._performUpdate(newManifest, MANIFEST_UPDATE_TYPE.Partial);
-    };
+    update(newManifest) {
+        this._performUpdate(newManifest, types_1.MANIFEST_UPDATE_TYPE.Partial);
+    }
     /**
      * Returns the theoretical minimum playable position on the content
      * regardless of the current Adaptation chosen, as estimated at parsing
      * time.
      * @returns {number}
      */
-    Manifest.prototype.getMinimumSafePosition = function () {
+    getMinimumSafePosition() {
         var _a, _b;
-        var windowData = this._timeBounds;
+        const windowData = this._timeBounds;
         if (windowData.timeshiftDepth === null) {
             return (_a = windowData.minimumSafePosition) !== null && _a !== void 0 ? _a : 0;
         }
-        var maximumTimeData = windowData.maximumTimeData;
-        var maximumTime;
+        const { maximumTimeData } = windowData;
+        let maximumTime;
         if (!windowData.maximumTimeData.isLinear) {
             maximumTime = maximumTimeData.maximumSafePosition;
         }
         else {
-            var timeDiff = performance.now() - maximumTimeData.time;
+            const timeDiff = (0, monotonic_timestamp_1.default)() - maximumTimeData.time;
             maximumTime = maximumTimeData.maximumSafePosition + timeDiff / 1000;
         }
-        var theoricalMinimum = maximumTime - windowData.timeshiftDepth;
+        const theoricalMinimum = maximumTime - windowData.timeshiftDepth;
         return Math.max((_b = windowData.minimumSafePosition) !== null && _b !== void 0 ? _b : 0, theoricalMinimum);
-    };
+    }
     /**
      * Get the position of the live edge - that is, the position of what is
      * currently being broadcasted, in seconds.
      * @returns {number|undefined}
      */
-    Manifest.prototype.getLivePosition = function () {
-        var maximumTimeData = this._timeBounds.maximumTimeData;
+    getLivePosition() {
+        const { maximumTimeData } = this._timeBounds;
         if (!this.isLive || maximumTimeData.livePosition === undefined) {
             return undefined;
         }
         if (!maximumTimeData.isLinear) {
             return maximumTimeData.livePosition;
         }
-        var timeDiff = performance.now() - maximumTimeData.time;
+        const timeDiff = (0, monotonic_timestamp_1.default)() - maximumTimeData.time;
         return maximumTimeData.livePosition + timeDiff / 1000;
-    };
+    }
     /**
      * Returns the theoretical maximum playable position on the content
      * regardless of the current Adaptation chosen, as estimated at parsing
      * time.
      */
-    Manifest.prototype.getMaximumSafePosition = function () {
-        var maximumTimeData = this._timeBounds.maximumTimeData;
+    getMaximumSafePosition() {
+        const { maximumTimeData } = this._timeBounds;
         if (!maximumTimeData.isLinear) {
             return maximumTimeData.maximumSafePosition;
         }
-        var timeDiff = performance.now() - maximumTimeData.time;
+        const timeDiff = (0, monotonic_timestamp_1.default)() - maximumTimeData.time;
         return maximumTimeData.maximumSafePosition + timeDiff / 1000;
-    };
+    }
     /**
      * Look in the Manifest for Representations linked to the given key ID,
      * and mark them as being impossible to decrypt.
@@ -244,93 +234,89 @@ var Manifest = /** @class */ (function (_super) {
      * changes performed.
      * @param {Function} isDecipherableCb
      */
-    Manifest.prototype.updateRepresentationsDeciperability = function (isDecipherableCb) {
-        var updates = updateDeciperability(this, isDecipherableCb);
+    updateRepresentationsDeciperability(isDecipherableCb) {
+        const updates = updateDeciperability(this, isDecipherableCb);
         if (updates.length > 0) {
             this.trigger("decipherabilityUpdate", updates);
         }
-    };
+    }
     /**
      * @deprecated only returns adaptations for the first period
      * @returns {Array.<Object>}
      */
-    Manifest.prototype.getAdaptations = function () {
-        warnOnce("manifest.getAdaptations() is deprecated." +
+    getAdaptations() {
+        (0, warn_once_1.default)("manifest.getAdaptations() is deprecated." +
             " Please use manifest.period[].getAdaptations() instead");
-        var firstPeriod = this.periods[0];
+        const firstPeriod = this.periods[0];
         if (firstPeriod === undefined) {
             return [];
         }
-        var adaptationsByType = firstPeriod.adaptations;
-        var adaptationsList = [];
-        for (var adaptationType in adaptationsByType) {
+        const adaptationsByType = firstPeriod.adaptations;
+        const adaptationsList = [];
+        for (const adaptationType in adaptationsByType) {
             if (adaptationsByType.hasOwnProperty(adaptationType)) {
-                var adaptations = adaptationsByType[adaptationType];
-                adaptationsList.push.apply(adaptationsList, adaptations);
+                const adaptations = adaptationsByType[adaptationType];
+                adaptationsList.push(...adaptations);
             }
         }
         return adaptationsList;
-    };
+    }
     /**
      * @deprecated only returns adaptations for the first period
      * @returns {Array.<Object>}
      */
-    Manifest.prototype.getAdaptationsForType = function (adaptationType) {
-        warnOnce("manifest.getAdaptationsForType(type) is deprecated." +
+    getAdaptationsForType(adaptationType) {
+        (0, warn_once_1.default)("manifest.getAdaptationsForType(type) is deprecated." +
             " Please use manifest.period[].getAdaptationsForType(type) instead");
-        var firstPeriod = this.periods[0];
+        const firstPeriod = this.periods[0];
         if (firstPeriod === undefined) {
             return [];
         }
-        var adaptationsForType = firstPeriod.adaptations[adaptationType];
+        const adaptationsForType = firstPeriod.adaptations[adaptationType];
         return adaptationsForType === undefined ? [] :
             adaptationsForType;
-    };
+    }
     /**
      * @deprecated only returns adaptations for the first period
      * @returns {Array.<Object>}
      */
-    Manifest.prototype.getAdaptation = function (wantedId) {
-        warnOnce("manifest.getAdaptation(id) is deprecated." +
+    getAdaptation(wantedId) {
+        (0, warn_once_1.default)("manifest.getAdaptation(id) is deprecated." +
             " Please use manifest.period[].getAdaptation(id) instead");
         /* eslint-disable import/no-deprecated */
-        return arrayFind(this.getAdaptations(), function (_a) {
-            var id = _a.id;
-            return wantedId === id;
-        });
+        return (0, array_find_1.default)(this.getAdaptations(), ({ id }) => wantedId === id);
         /* eslint-enable import/no-deprecated */
-    };
+    }
     /**
      * @param {Object} newManifest
      * @param {number} updateType
      */
-    Manifest.prototype._performUpdate = function (newManifest, updateType) {
+    _performUpdate(newManifest, updateType) {
         this.availabilityStartTime = newManifest.availabilityStartTime;
         this.expired = newManifest.expired;
         this.isDynamic = newManifest.isDynamic;
         this.isLive = newManifest.isLive;
         this.isLastPeriodKnown = newManifest.isLastPeriodKnown;
         this.lifetime = newManifest.lifetime;
-        this.contentWarnings = newManifest.contentWarnings;
         this.suggestedPresentationDelay = newManifest.suggestedPresentationDelay;
         this.transport = newManifest.transport;
         this.publishTime = newManifest.publishTime;
-        var updatedPeriodsResult;
-        if (updateType === MANIFEST_UPDATE_TYPE.Full) {
+        let updatedPeriodsResult;
+        if (updateType === types_1.MANIFEST_UPDATE_TYPE.Full) {
             this._timeBounds = newManifest._timeBounds;
             this.uris = newManifest.uris;
-            updatedPeriodsResult = replacePeriods(this.periods, newManifest.periods);
+            updatedPeriodsResult = (0, update_periods_1.replacePeriods)(this.periods, newManifest.periods);
         }
         else {
             this._timeBounds.maximumTimeData = newManifest._timeBounds.maximumTimeData;
             this.updateUrl = newManifest.uris[0];
-            updatedPeriodsResult = updatePeriods(this.periods, newManifest.periods);
+            updatedPeriodsResult = (0, update_periods_1.updatePeriods)(this.periods, newManifest.periods);
             // Partial updates do not remove old Periods.
             // This can become a memory problem when playing a content long enough.
             // Let's clean manually Periods behind the minimum possible position.
-            var min = this.getMinimumSafePosition();
+            const min = this.getMinimumSafePosition();
             while (this.periods.length > 0) {
-                var period = this.periods[0];
+                const period = this.periods[0];
                 if (period.end === undefined || period.end > min) {
                     break;
                 }
@@ -347,10 +333,9 @@ var Manifest = /** @class */ (function (_super) {
         // We do not want the current Manifest object to be incomplete when those
         // happen.
         this.trigger("manifestUpdate", updatedPeriodsResult);
-    };
-    return Manifest;
-}(EventEmitter));
-export default Manifest;
+    }
+}
+exports.default = Manifest;
 /**
  * Update `decipherable` property of every `Representation` found in the
  * Manifest based on the result of a `isDecipherable` callback:
@@ -363,18 +348,15 @@ export default Manifest;
  * @returns {Array.<Object>}
  */
 function updateDeciperability(manifest, isDecipherable) {
-    var updates = [];
-    for (var _i = 0, _a = manifest.periods; _i < _a.length; _i++) {
-        var period = _a[_i];
-        for (var _b = 0, _c = period.getAdaptations(); _b < _c.length; _b++) {
-            var adaptation = _c[_b];
-            for (var _d = 0, _e = adaptation.representations; _d < _e.length; _d++) {
-                var representation = _e[_d];
-                var result = isDecipherable(representation);
+    const updates = [];
+    for (const period of manifest.periods) {
+        for (const adaptation of period.getAdaptations()) {
+            for (const representation of adaptation.representations) {
+                const result = isDecipherable(representation);
                 if (result !== representation.decipherable) {
-                    updates.push({ manifest: manifest, period: period, adaptation: adaptation, representation: representation });
+                    updates.push({ manifest, period, adaptation, representation });
                     representation.decipherable = result;
-                    log.debug("Decipherability changed for \"".concat(representation.id, "\""), "(".concat(representation.bitrate, ")"), String(representation.decipherable));
+                    log_1.default.debug(`Decipherability changed for "${representation.id}"`, `(${representation.bitrate})`, String(representation.decipherable));
                 }
             }
         }

package/dist/_esm5.processed/manifest/period.d.ts

@@ -1,5 +1,5 @@
 import { IManifestStreamEvent, IParsedPeriod } from "../parsers/manifest";
-import { ITrackType, IPlayerError, IRepresentationFilter } from "../public_types";
+import { ITrackType, IRepresentationFilter } from "../public_types";
 import Adaptation from "./adaptation";
 /** Structure listing every `Adaptation` in a Period. */
 export type IManifestAdaptations = Partial<Record<ITrackType, Adaptation[]>>;
@@ -25,11 +25,6 @@ export default class Period {
      * `undefined` for still-running Periods.
      */
     end: number | undefined;
-    /**
-     * Array containing every errors that happened when the Period has been
-     * created, in the order they have happened.
-     */
-    readonly contentWarnings: IPlayerError[];
     /** Array containing every stream event happening on the period */
     streamEvents: IManifestStreamEvent[];
     /**
@@ -37,7 +32,7 @@ export default class Period {
      * @param {Object} args
      * @param {function|undefined} [representationFilter]
      */
-    constructor(args: IParsedPeriod, representationFilter?: IRepresentationFilter | undefined);
+    constructor(args: IParsedPeriod, unsupportedAdaptations: Adaptation[], representationFilter?: IRepresentationFilter | undefined);
     /**
      * Returns every `Adaptations` (or `tracks`) linked to that Period, in an
      * Array.

package/dist/_esm5.processed/manifest/period.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,47 +15,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MediaError } from "../errors";
-import arrayFind from "../utils/array_find";
-import objectValues from "../utils/object_values";
-import Adaptation from "./adaptation";
+const errors_1 = require("../errors");
+const array_find_1 = require("../utils/array_find");
+const object_values_1 = require("../utils/object_values");
+const adaptation_1 = require("./adaptation");
 /**
  * Class representing the tracks and qualities available from a given time
  * period in the the Manifest.
  * @class Period
  */
-var Period = /** @class */ (function () {
+class Period {
     /**
      * @constructor
      * @param {Object} args
      * @param {function|undefined} [representationFilter]
      */
-    function Period(args, representationFilter) {
-        var _this = this;
-        this.contentWarnings = [];
+    constructor(args, unsupportedAdaptations, representationFilter) {
         this.id = args.id;
         this.adaptations = Object.keys(args.adaptations)
-            .reduce(function (acc, type) {
-            var adaptationsForType = args.adaptations[type];
+            .reduce((acc, type) => {
+            const adaptationsForType = args.adaptations[type];
             if (adaptationsForType == null) {
                 return acc;
             }
-            var filteredAdaptations = adaptationsForType
-                .map(function (adaptation) {
-                var newAdaptation = new Adaptation(adaptation, { representationFilter: representationFilter });
+            const filteredAdaptations = adaptationsForType
+                .map((adaptation) => {
+                const newAdaptation = new adaptation_1.default(adaptation, { representationFilter });
                 if (newAdaptation.representations.length > 0 && !newAdaptation.isSupported) {
-                    var error = new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "An Adaptation contains only incompatible codecs.", { adaptation: newAdaptation });
-                    _this.contentWarnings.push(error);
+                    unsupportedAdaptations.push(newAdaptation);
                 }
                 return newAdaptation;
             })
-                .filter(function (adaptation) {
-                return adaptation.representations.length > 0;
-            });
-            if (filteredAdaptations.every(function (adaptation) { return !adaptation.isSupported; }) &&
+                .filter((adaptation) => adaptation.representations.length > 0);
+            if (filteredAdaptations.every(adaptation => !adaptation.isSupported) &&
                 adaptationsForType.length > 0 &&
                 (type === "video" || type === "audio")) {
-                throw new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "No supported " + type + " adaptations", { adaptation: undefined });
+                throw new errors_1.MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "No supported " + type + " adaptations", { adaptations: undefined });
             }
             if (filteredAdaptations.length > 0) {
                 acc[type] = filteredAdaptations;
@@ -62,7 +59,7 @@ var Period = /** @class */ (function () {
         }, {});
         if (!Array.isArray(this.adaptations.video) &&
             !Array.isArray(this.adaptations.audio)) {
-            throw new MediaError("MANIFEST_PARSE_ERROR", "No supported audio and video tracks.");
+            throw new errors_1.MediaError("MANIFEST_PARSE_ERROR", "No supported audio and video tracks.");
         }
         this.duration = args.duration;
         this.start = args.start;
@@ -78,64 +75,60 @@ var Period = /** @class */ (function () {
      * Array.
      * @returns {Array.<Object>}
      */
-    Period.prototype.getAdaptations = function () {
-        var adaptationsByType = this.adaptations;
-        return objectValues(adaptationsByType).reduce(
+    getAdaptations() {
+        const adaptationsByType = this.adaptations;
+        return (0, object_values_1.default)(adaptationsByType).reduce(
         // Note: the second case cannot happen. TS is just being dumb here
-        function (acc, adaptations) { return adaptations != null ? acc.concat(adaptations) :
-            acc; }, []);
-    };
+        (acc, adaptations) => adaptations != null ? acc.concat(adaptations) :
+            acc, []);
+    }
     /**
      * Returns every `Adaptations` (or `tracks`) linked to that Period for a
      * given type.
      * @param {string} adaptationType
      * @returns {Array.<Object>}
      */
-    Period.prototype.getAdaptationsForType = function (adaptationType) {
-        var adaptationsForType = this.adaptations[adaptationType];
+    getAdaptationsForType(adaptationType) {
+        const adaptationsForType = this.adaptations[adaptationType];
         return adaptationsForType == null ? [] :
             adaptationsForType;
-    };
+    }
     /**
      * Returns the Adaptation linked to the given ID.
      * @param {number|string} wantedId
      * @returns {Object|undefined}
      */
-    Period.prototype.getAdaptation = function (wantedId) {
-        return arrayFind(this.getAdaptations(), function (_a) {
-            var id = _a.id;
-            return wantedId === id;
-        });
-    };
+    getAdaptation(wantedId) {
+        return (0, array_find_1.default)(this.getAdaptations(), ({ id }) => wantedId === id);
+    }
     /**
      * Returns Adaptations that contain Representations in supported codecs.
      * @param {string|undefined} type - If set filter on a specific Adaptation's
      * type. Will return for all types if `undefined`.
      * @returns {Array.<Adaptation>}
      */
-    Period.prototype.getSupportedAdaptations = function (type) {
+    getSupportedAdaptations(type) {
         if (type === undefined) {
-            return this.getAdaptations().filter(function (ada) {
+            return this.getAdaptations().filter(ada => {
                 return ada.isSupported;
             });
         }
-        var adaptationsForType = this.adaptations[type];
+        const adaptationsForType = this.adaptations[type];
         if (adaptationsForType === undefined) {
             return [];
         }
-        return adaptationsForType.filter(function (ada) {
+        return adaptationsForType.filter(ada => {
             return ada.isSupported;
         });
-    };
+    }
     /**
      * Returns true if the give time is in the time boundaries of this `Period`.
      * @param {number} time
      * @returns {boolean}
      */
-    Period.prototype.containsTime = function (time) {
+    containsTime(time) {
         return time >= this.start && (this.end === undefined ||
             time < this.end);
-    };
-    return Period;
-}());
-export default Period;
+    }
+}
+exports.default = Period;