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

package/dist/_esm5.processed/core/stream/period/utils/get_adaptation_switch_strategy.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,11 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const config_1 = require("../../../../config");
-const are_codecs_compatible_1 = require("../../../../utils/are_codecs_compatible");
-const ranges_1 = require("../../../../utils/ranges");
-const segment_buffers_1 = require("../../../segment_buffers");
+import config from "../../../../config";
+import areCodecsCompatible from "../../../../utils/are_codecs_compatible";
+import { convertToRanges, excludeFromRanges, isTimeInRange, isTimeInRanges, keepRangeIntersection, } from "../../../../utils/ranges";
 /**
  * Find out what to do when switching Adaptation, based on the current
  * situation.
@@ -28,60 +25,64 @@ const segment_buffers_1 = require("../../../segment_buffers");
  * @param {Object} playbackInfo
  * @returns {Object}
  */
-function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackInfo, options) {
+export default function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, playbackInfo, options) {
     if (segmentBuffer.codec !== undefined &&
         options.onCodecSwitch === "reload" &&
         !hasCompatibleCodec(adaptation, segmentBuffer.codec)) {
         return { type: "needs-reload", value: undefined };
     }
-    const buffered = segmentBuffer.getBufferedRanges();
+    var buffered = segmentBuffer.getBufferedRanges();
     if (buffered.length === 0) {
         return { type: "continue", value: undefined };
     }
-    const bufferedRanges = (0, ranges_1.convertToRanges)(buffered);
-    const start = period.start;
-    const end = period.end == null ? Infinity :
+    var bufferedRanges = convertToRanges(buffered);
+    var start = period.start;
+    var end = period.end == null ? Infinity :
         period.end;
-    const intersection = (0, ranges_1.keepRangeIntersection)(bufferedRanges, [{ start, end }]);
+    var intersection = keepRangeIntersection(bufferedRanges, [{ start: start, end: end }]);
     if (intersection.length === 0) {
         return { type: "continue", value: undefined };
     }
     segmentBuffer.synchronizeInventory();
-    const inventory = segmentBuffer.getInventory();
+    var inventory = segmentBuffer.getInventory();
     // Continue if we have no other Adaptation buffered in the current Period
-    if (!inventory.some(buf => buf.infos.period.id === period.id &&
-        buf.infos.adaptation.id !== adaptation.id)) {
+    if (!inventory.some(function (buf) { return buf.infos.period.id === period.id &&
+        buf.infos.adaptation.id !== adaptation.id; })) {
         return { type: "continue", value: undefined };
     }
     /** Data already in the right Adaptation */
-    const adaptationInBuffer = getBufferedRangesFromAdaptation(inventory, period, adaptation);
+    var adaptationInBuffer = getBufferedRangesFromAdaptation(inventory, period, adaptation);
     /**
      * Data different from the wanted Adaptation in the Period's range.
      * /!\ Could contain some data at the end of the previous Period or at the
      * beginning of the next one.
      */
-    const unwantedRange = (0, ranges_1.excludeFromRanges)(intersection, adaptationInBuffer);
+    var unwantedRange = excludeFromRanges(intersection, adaptationInBuffer);
     if (unwantedRange.length === 0) {
         return { type: "continue", value: undefined };
     }
-    const { currentTime } = playbackInfo;
-    if (switchingMode === "reload" &&
+    var currentTime = playbackInfo.currentTime;
+    var audioTrackSwitchingMode = options.audioTrackSwitchingMode;
+    var hasReloadSwitchingMode = adaptation.type === "video" ||
+        (adaptation.type === "audio" && audioTrackSwitchingMode === "reload");
+    if (hasReloadSwitchingMode &&
         // We're playing the current Period
-        (0, ranges_1.isTimeInRange)({ start, end }, currentTime) &&
+        isTimeInRange({ start: start, end: end }, currentTime) &&
         // There is data for the current position or the codecs are differents
         (playbackInfo.readyState > 1 || !adaptation.getPlayableRepresentations()
-            .some(rep => { var _a; return (0, are_codecs_compatible_1.default)(rep.getMimeTypeString(), (_a = segmentBuffer.codec) !== null && _a !== void 0 ? _a : ""); })) &&
+            .some(function (rep) { var _a; return areCodecsCompatible(rep.getMimeTypeString(), (_a = segmentBuffer.codec) !== null && _a !== void 0 ? _a : ""); })) &&
         // We're not playing the current wanted video Adaptation
-        !(0, ranges_1.isTimeInRanges)(adaptationInBuffer, currentTime)) {
+        !isTimeInRanges(adaptationInBuffer, currentTime)) {
         return { type: "needs-reload", value: undefined };
     }
     // From here, clean-up data from the previous Adaptation, if one
-    const shouldCleanAll = switchingMode === "direct";
-    const rangesToExclude = [];
+    var shouldFlush = adaptation.type === "audio" &&
+        audioTrackSwitchingMode === "direct";
+    var rangesToExclude = [];
     // First, we don't want to accidentally remove some segments from the previous
     // Period (which overlap a little with this one)
     /** Last segment before one for the current period. */
-    const lastSegmentBefore = (0, segment_buffers_1.getLastSegmentBeforePeriod)(inventory, period);
+    var lastSegmentBefore = getLastSegmentBeforePeriod(inventory, period);
     if (lastSegmentBefore !== null &&
         (lastSegmentBefore.bufferedEnd === undefined ||
             period.start - lastSegmentBefore.bufferedEnd < 1)) // Close to Period's start
@@ -92,18 +93,18 @@ function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchin
             end: period.start + 1 });
     }
     // Next, exclude data around current position to avoid decoding issues
-    const bufferType = adaptation.type;
-    const { ADAP_REP_SWITCH_BUFFER_PADDINGS } = config_1.default.getCurrent();
+    var bufferType = adaptation.type;
+    var ADAPTATION_SWITCH_BUFFER_PADDINGS = config.getCurrent().ADAPTATION_SWITCH_BUFFER_PADDINGS;
     /** Ranges that won't be cleaned from the current buffer. */
-    let paddingBefore = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].before;
+    var paddingBefore = ADAPTATION_SWITCH_BUFFER_PADDINGS[bufferType].before;
     if (paddingBefore == null) {
         paddingBefore = 0;
     }
-    let paddingAfter = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].after;
+    var paddingAfter = ADAPTATION_SWITCH_BUFFER_PADDINGS[bufferType].after;
     if (paddingAfter == null) {
         paddingAfter = 0;
     }
-    if (!shouldCleanAll) {
+    if (!shouldFlush) {
         rangesToExclude.push({ start: currentTime - paddingBefore,
             end: currentTime + paddingAfter });
     }
@@ -111,7 +112,7 @@ function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchin
     // next Period
     if (period.end !== undefined) {
         /** first segment after for the current period. */
-        const firstSegmentAfter = (0, segment_buffers_1.getFirstSegmentAfterPeriod)(inventory, period);
+        var firstSegmentAfter = getFirstSegmentAfterPeriod(inventory, period);
         if (firstSegmentAfter !== null &&
             (firstSegmentAfter.bufferedStart === undefined ||
                 (firstSegmentAfter.bufferedStart - period.end) < 1)) // Close to Period's end
@@ -120,15 +121,13 @@ function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchin
                 end: Number.MAX_VALUE });
         }
     }
-    const toRemove = (0, ranges_1.excludeFromRanges)(unwantedRange, rangesToExclude);
+    var toRemove = excludeFromRanges(unwantedRange, rangesToExclude);
     if (toRemove.length === 0) {
         return { type: "continue", value: undefined };
     }
-    return shouldCleanAll && adaptation.type !== "text" ?
-        { type: "flush-buffer", value: toRemove } :
+    return shouldFlush ? { type: "flush-buffer", value: toRemove } :
         { type: "clean-buffer", value: toRemove };
 }
-exports.default = getAdaptationSwitchStrategy;
 /**
  * Returns `true` if at least one codec of the Representations in the given
  * Adaptation has a codec compatible with the given SegmentBuffer's codec.
@@ -137,7 +136,9 @@ exports.default = getAdaptationSwitchStrategy;
  * @returns {boolean}
  */
 function hasCompatibleCodec(adaptation, segmentBufferCodec) {
-    return adaptation.getPlayableRepresentations().some(rep => (0, are_codecs_compatible_1.default)(rep.getMimeTypeString(), segmentBufferCodec));
+    return adaptation.getPlayableRepresentations().some(function (rep) {
+        return areCodecsCompatible(rep.getMimeTypeString(), segmentBufferCodec);
+    });
 }
 /**
  * Returns buffered ranges of what we know correspond to the given `adaptation`
@@ -148,12 +149,12 @@ function hasCompatibleCodec(adaptation, segmentBufferCodec) {
  * @returns {Array.<Object>}
  */
 function getBufferedRangesFromAdaptation(inventory, period, adaptation) {
-    return inventory.reduce((acc, chunk) => {
+    return inventory.reduce(function (acc, chunk) {
         if (chunk.infos.period.id !== period.id ||
             chunk.infos.adaptation.id !== adaptation.id) {
             return acc;
         }
-        const { bufferedStart, bufferedEnd } = chunk;
+        var bufferedStart = chunk.bufferedStart, bufferedEnd = chunk.bufferedEnd;
         if (bufferedStart === undefined || bufferedEnd === undefined) {
             return acc;
         }
@@ -161,3 +162,37 @@ function getBufferedRangesFromAdaptation(inventory, period, adaptation) {
         return acc;
     }, []);
 }
+/**
+ * Returns the last segment in the `inventory` which is linked to a Period
+ * before `period`.
+ * @param {Array.<Object>} inventory
+ * @param {Object} period
+ * @returns {Object|null}
+ */
+function getLastSegmentBeforePeriod(inventory, period) {
+    for (var i = 0; i < inventory.length; i++) {
+        if (inventory[i].infos.period.start >= period.start) {
+            if (i > 0) {
+                return inventory[i - 1];
+            }
+            return null;
+        }
+    }
+    return inventory.length > 0 ? inventory[inventory.length - 1] :
+        null;
+}
+/**
+ * Returns the first segment in the `inventory` which is linked to a Period
+ * after `period`.
+ * @param {Array.<Object>} inventory
+ * @param {Object} period
+ * @returns {Object|null}
+ */
+function getFirstSegmentAfterPeriod(inventory, period) {
+    for (var i = 0; i < inventory.length; i++) {
+        if (inventory[i].infos.period.start > period.start) {
+            return inventory[i];
+        }
+    }
+    return null;
+}

package/dist/_esm5.processed/core/stream/representation/index.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,21 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const representation_stream_1 = require("./representation_stream");
-__exportStar(require("./types"), exports);
-exports.default = representation_stream_1.default;
+import RepresentationStream from "./representation_stream";
+export * from "./types";
+export default RepresentationStream;

package/dist/_esm5.processed/core/stream/representation/representation_stream.d.ts

@@ -50,4 +50,4 @@ import { IRepresentationStreamArguments, IRepresentationStreamCallbacks } from "
  * triggered, to immediately stop all operations the `RepresentationStream` is
  * doing.
  */
-export default function RepresentationStream<TSegmentDataType>({ content, options, playbackObserver, segmentBuffer, segmentFetcher, terminate }: IRepresentationStreamArguments<TSegmentDataType>, callbacks: IRepresentationStreamCallbacks, parentCancelSignal: CancellationSignal): void;
+export default function RepresentationStream<TSegmentDataType>({ content, options, playbackObserver, segmentBuffer, segmentFetcher, terminate }: IRepresentationStreamArguments<TSegmentDataType>, callbacks: IRepresentationStreamCallbacks<TSegmentDataType>, parentCancelSignal: CancellationSignal): void;

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * This file allows to create RepresentationStreams.
  *
@@ -23,16 +21,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * It chooses which segments should be downloaded according to the current
  * position and what is currently buffered.
  */
-const config_1 = require("../../../config");
-const log_1 = require("../../../log");
-const object_assign_1 = require("../../../utils/object_assign");
-const reference_1 = require("../../../utils/reference");
-const task_canceller_1 = require("../../../utils/task_canceller");
-const downloading_queue_1 = require("./utils/downloading_queue");
-const get_buffer_status_1 = require("./utils/get_buffer_status");
-const get_segment_priority_1 = require("./utils/get_segment_priority");
-const push_init_segment_1 = require("./utils/push_init_segment");
-const push_media_segment_1 = require("./utils/push_media_segment");
+import config from "../../../config";
+import log from "../../../log";
+import objectAssign from "../../../utils/object_assign";
+import SharedReference from "../../../utils/reference";
+import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
+import DownloadingQueue from "./utils/downloading_queue";
+import getBufferStatus from "./utils/get_buffer_status";
+import getSegmentPriority from "./utils/get_segment_priority";
+import pushInitSegment from "./utils/push_init_segment";
+import pushMediaSegment from "./utils/push_media_segment";
 /**
  * Perform the logic to load the right segments for the given Representation and
  * push them to the given `SegmentBuffer`.
@@ -68,39 +66,40 @@ const push_media_segment_1 = require("./utils/push_media_segment");
  * triggered, to immediately stop all operations the `RepresentationStream` is
  * doing.
  */
-function RepresentationStream({ content, options, playbackObserver, segmentBuffer, segmentFetcher, terminate }, callbacks, parentCancelSignal) {
-    const { period, adaptation, representation } = content;
-    const { bufferGoal, maxBufferSize, drmSystemId, fastSwitchThreshold } = options;
-    const bufferType = adaptation.type;
+export default function RepresentationStream(_a, callbacks, parentCancelSignal) {
+    var content = _a.content, options = _a.options, playbackObserver = _a.playbackObserver, segmentBuffer = _a.segmentBuffer, segmentFetcher = _a.segmentFetcher, terminate = _a.terminate;
+    var period = content.period, adaptation = content.adaptation, representation = content.representation;
+    var bufferGoal = options.bufferGoal, maxBufferSize = options.maxBufferSize, drmSystemId = options.drmSystemId, fastSwitchThreshold = options.fastSwitchThreshold;
+    var bufferType = adaptation.type;
     /** `TaskCanceller` stopping ALL operations performed by the `RepresentationStream` */
-    const globalCanceller = new task_canceller_1.default();
+    var globalCanceller = new TaskCanceller();
     globalCanceller.linkToSignal(parentCancelSignal);
     /**
      * `TaskCanceller` allowing to only stop segment loading and checking operations.
      * This allows to stop only tasks linked to network resource usage, which is
      * often a limited resource, while still letting buffer operations to finish.
      */
-    const segmentsLoadingCanceller = new task_canceller_1.default();
+    var segmentsLoadingCanceller = new TaskCanceller();
     segmentsLoadingCanceller.linkToSignal(globalCanceller.signal);
     /** Saved initialization segment state for this representation. */
-    const initSegmentState = {
+    var initSegmentState = {
         segment: representation.index.getInitSegment(),
         uniqueId: null,
         isLoaded: false,
     };
-    globalCanceller.signal.register(() => {
+    globalCanceller.signal.register(function () {
         // Free initialization segment if one has been declared
         if (initSegmentState.uniqueId !== null) {
             segmentBuffer.freeInitSegment(initSegmentState.uniqueId);
         }
     });
     /** Emit the last scheduled downloading queue for segments. */
-    const lastSegmentQueue = new reference_1.default({
+    var lastSegmentQueue = new SharedReference({
         initSegment: null,
         segmentQueue: [],
     }, segmentsLoadingCanceller.signal);
     /** If `true`, the current Representation has a linked initialization segment. */
-    const hasInitSegment = initSegmentState.segment !== null;
+    var hasInitSegment = initSegmentState.segment !== null;
     if (!hasInitSegment) {
         initSegmentState.isLoaded = true;
     }
@@ -109,25 +108,25 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
      * constructed.
      * Allows to avoid sending multiple times protection events.
      */
-    let hasSentEncryptionData = false;
+    var hasSentEncryptionData = false;
     // If the DRM system id is already known, and if we already have encryption data
     // for it, we may not need to wait until the initialization segment is loaded to
     // signal required protection data, thus performing License negotiations sooner
     if (drmSystemId !== undefined) {
-        const encryptionData = representation.getEncryptionData(drmSystemId);
+        var encryptionData = representation.getEncryptionData(drmSystemId);
         // If some key ids are not known yet, it may be safer to wait for this initialization
         // segment to be loaded first
-        if (encryptionData.length > 0 && encryptionData.every(e => e.keyIds !== undefined)) {
+        if (encryptionData.length > 0 && encryptionData.every(function (e) { return e.keyIds !== undefined; })) {
             hasSentEncryptionData = true;
-            callbacks.encryptionDataEncountered(encryptionData.map(d => (0, object_assign_1.default)({ content }, d)));
+            callbacks.encryptionDataEncountered(encryptionData.map(function (d) { return objectAssign({ content: content }, d); }));
             if (globalCanceller.isUsed()) {
                 return; // previous callback has stopped everything by side-effect
             }
         }
     }
     /** Will load every segments in `lastSegmentQueue` */
-    const downloadingQueue = new downloading_queue_1.default(content, lastSegmentQueue, segmentFetcher, hasInitSegment);
-    downloadingQueue.addEventListener("error", (err) => {
+    var downloadingQueue = new DownloadingQueue(content, lastSegmentQueue, segmentFetcher, hasInitSegment);
+    downloadingQueue.addEventListener("error", function (err) {
         if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // ignore post requests-cancellation loading-related errors,
         }
@@ -137,13 +136,13 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
     downloadingQueue.addEventListener("parsedInitSegment", onParsedChunk);
     downloadingQueue.addEventListener("parsedMediaSegment", onParsedChunk);
     downloadingQueue.addEventListener("emptyQueue", checkStatus);
-    downloadingQueue.addEventListener("requestRetry", (payload) => {
+    downloadingQueue.addEventListener("requestRetry", function (payload) {
         callbacks.warning(payload.error);
         if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // If the previous callback led to loading operations being stopped, skip
         }
-        const retriedSegment = payload.segment;
-        const { index } = representation;
+        var retriedSegment = payload.segment;
+        var index = representation.index;
         if (index.isSegmentStillAvailable(retriedSegment) === false) {
             checkStatus();
         }
@@ -151,12 +150,12 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
             callbacks.manifestMightBeOufOfSync();
         }
     });
-    downloadingQueue.addEventListener("fullyLoadedSegment", (segment) => {
-        segmentBuffer.endOfSegment((0, object_assign_1.default)({ segment }, content), globalCanceller.signal)
+    downloadingQueue.addEventListener("fullyLoadedSegment", function (segment) {
+        segmentBuffer.endOfSegment(objectAssign({ segment: segment }, content), globalCanceller.signal)
             .catch(onFatalBufferError);
     });
     downloadingQueue.start();
-    segmentsLoadingCanceller.signal.register(() => {
+    segmentsLoadingCanceller.signal.register(function () {
         downloadingQueue.removeEventListener();
         downloadingQueue.stop();
     });
@@ -189,40 +188,40 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
         if (segmentsLoadingCanceller.isUsed()) {
             return; // Stop all buffer status checking if load operations are stopped
         }
-        const observation = playbackObserver.getReference().getValue();
-        const initialWantedTime = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
-        const status = (0, get_buffer_status_1.default)(content, initialWantedTime, playbackObserver, fastSwitchThreshold.getValue(), bufferGoal.getValue(), maxBufferSize.getValue(), segmentBuffer);
-        const { neededSegments } = status;
-        let neededInitSegment = null;
+        var observation = playbackObserver.getReference().getValue();
+        var initialWantedTime = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
+        var status = getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold.getValue(), bufferGoal.getValue(), maxBufferSize.getValue(), segmentBuffer);
+        var neededSegments = status.neededSegments;
+        var neededInitSegment = null;
         // Add initialization segment if required
         if (!representation.index.isInitialized()) {
             if (initSegmentState.segment === null) {
-                log_1.default.warn("Stream: Uninitialized index without an initialization segment");
+                log.warn("Stream: Uninitialized index without an initialization segment");
             }
             else if (initSegmentState.isLoaded) {
-                log_1.default.warn("Stream: Uninitialized index with an already loaded " +
+                log.warn("Stream: Uninitialized index with an already loaded " +
                     "initialization segment");
             }
             else {
-                const wantedStart = (_b = observation.position.pending) !== null && _b !== void 0 ? _b : observation.position.last;
+                var wantedStart = (_b = observation.position.pending) !== null && _b !== void 0 ? _b : observation.position.last;
                 neededInitSegment = { segment: initSegmentState.segment,
-                    priority: (0, get_segment_priority_1.default)(period.start, wantedStart) };
+                    priority: getSegmentPriority(period.start, wantedStart) };
             }
         }
         else if (neededSegments.length > 0 &&
             !initSegmentState.isLoaded &&
             initSegmentState.segment !== null) {
-            const initSegmentPriority = neededSegments[0].priority;
+            var initSegmentPriority = neededSegments[0].priority;
             neededInitSegment = { segment: initSegmentState.segment,
                 priority: initSegmentPriority };
         }
-        const terminateVal = terminate.getValue();
+        var terminateVal = terminate.getValue();
         if (terminateVal === null) {
             lastSegmentQueue.setValue({ initSegment: neededInitSegment,
                 segmentQueue: neededSegments });
         }
         else if (terminateVal.urgent) {
-            log_1.default.debug("Stream: Urgent switch, terminate now.", bufferType);
+            log.debug("Stream: Urgent switch, terminate now.", bufferType);
             lastSegmentQueue.setValue({ initSegment: null, segmentQueue: [] });
             lastSegmentQueue.finish();
             segmentsLoadingCanceller.cancel();
@@ -234,39 +233,36 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
             // End the download of the current media segment if pending and
             // terminate once either that request is finished or another segment
             // is wanted instead, whichever comes first.
-            const mostNeededSegment = neededSegments[0];
-            const initSegmentRequest = downloadingQueue.getRequestedInitSegment();
-            const currentSegmentRequest = downloadingQueue.getRequestedMediaSegment();
-            const nextQueue = currentSegmentRequest === null ||
+            var mostNeededSegment = neededSegments[0];
+            var initSegmentRequest = downloadingQueue.getRequestedInitSegment();
+            var currentSegmentRequest = downloadingQueue.getRequestedMediaSegment();
+            var nextQueue = currentSegmentRequest === null ||
                 mostNeededSegment === undefined ||
                 currentSegmentRequest.id !== mostNeededSegment.segment.id ?
                 [] :
                 [mostNeededSegment];
-            const nextInit = initSegmentRequest === null ? null :
+            var nextInit = initSegmentRequest === null ? null :
                 neededInitSegment;
             lastSegmentQueue.setValue({ initSegment: nextInit,
                 segmentQueue: nextQueue });
             if (nextQueue.length === 0 && nextInit === null) {
-                log_1.default.debug("Stream: No request left, terminate", bufferType);
+                log.debug("Stream: No request left, terminate", bufferType);
                 lastSegmentQueue.finish();
                 segmentsLoadingCanceller.cancel();
                 callbacks.terminating();
                 return;
             }
         }
-        callbacks.streamStatusUpdate({ period,
-            position: observation.position.last,
-            bufferType,
-            imminentDiscontinuity: status.imminentDiscontinuity,
+        callbacks.streamStatusUpdate({ period: period, position: observation.position.last, bufferType: bufferType, imminentDiscontinuity: status.imminentDiscontinuity,
             isEmptyStream: false,
             hasFinishedLoading: status.hasFinishedLoading,
             neededSegments: status.neededSegments });
         if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // previous callback has stopped loading operations by side-effect
         }
-        const { UPTO_CURRENT_POSITION_CLEANUP } = config_1.default.getCurrent();
+        var UPTO_CURRENT_POSITION_CLEANUP = config.getCurrent().UPTO_CURRENT_POSITION_CLEANUP;
         if (status.isBufferFull) {
-            const gcedPosition = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
+            var gcedPosition = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
             if (gcedPosition > 0) {
                 segmentBuffer.removeBuffer(0, gcedPosition, globalCanceller.signal)
                     .catch(onFatalBufferError);
@@ -287,43 +283,27 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
             // is not running anymore.
             return;
         }
-        // Supplementary encryption information might have been parsed.
-        for (const protInfo of evt.protectionData) {
-            // TODO better handle use cases like key rotation by not always grouping
-            // every protection data together? To check.
-            representation.addProtectionData(protInfo.initDataType, protInfo.keyId, protInfo.initData);
-        }
-        // Now that the initialization segment has been parsed - which may have
-        // included encryption information - take care of the encryption event
-        // if not already done.
-        if (!hasSentEncryptionData) {
-            const allEncryptionData = representation.getAllEncryptionData();
-            if (allEncryptionData.length > 0) {
-                callbacks.encryptionDataEncountered(allEncryptionData.map(p => (0, object_assign_1.default)({ content }, p)));
-                hasSentEncryptionData = true;
-                // previous callback could have lead to cancellation
-                if (globalCanceller.isUsed()) {
-                    return;
-                }
-            }
-        }
         if (evt.segmentType === "init") {
-            if (!representation.index.isInitialized() &&
-                evt.segmentList !== undefined) {
-                representation.index.initialize(evt.segmentList);
-            }
             initSegmentState.isLoaded = true;
+            // Now that the initialization segment has been parsed - which may have
+            // included encryption information - take care of the encryption event
+            // if not already done.
+            if (!hasSentEncryptionData) {
+                var allEncryptionData = representation.getAllEncryptionData();
+                if (allEncryptionData.length > 0) {
+                    callbacks.encryptionDataEncountered(allEncryptionData.map(function (p) { return objectAssign({ content: content }, p); }));
+                    if (globalCanceller.isUsed()) {
+                        return; // previous callback has stopped everything by side-effect
+                    }
+                }
+            }
             if (evt.initializationData !== null) {
-                const initSegmentUniqueId = representation.uniqueId;
+                var initSegmentUniqueId = representation.uniqueId;
                 initSegmentState.uniqueId = initSegmentUniqueId;
                 segmentBuffer.declareInitSegment(initSegmentUniqueId, evt.initializationData);
-                (0, push_init_segment_1.default)({ playbackObserver,
-                    content,
-                    initSegmentUniqueId,
-                    segment: evt.segment,
-                    segmentData: evt.initializationData,
-                    segmentBuffer }, globalCanceller.signal)
-                    .then((result) => {
+                pushInitSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, segment: evt.segment,
+                    segmentData: evt.initializationData, segmentBuffer: segmentBuffer }, globalCanceller.signal)
+                    .then(function (result) {
                     if (result !== null) {
                         callbacks.addedSegment(result);
                     }
@@ -333,12 +313,19 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
             // Sometimes the segment list is only known once the initialization segment
             // is parsed. Thus we immediately re-check if there's new segments to load.
             checkStatus();
-            return;
         }
         else {
-            const { inbandEvents, predictedSegments, needsManifestRefresh } = evt;
-            if (predictedSegments !== undefined) {
-                representation.index.addPredictedSegments(predictedSegments, evt.segment);
+            var inbandEvents = evt.inbandEvents, needsManifestRefresh = evt.needsManifestRefresh, protectionDataUpdate = evt.protectionDataUpdate;
+            // TODO better handle use cases like key rotation by not always grouping
+            // every protection data together? To check.
+            if (!hasSentEncryptionData && protectionDataUpdate) {
+                var allEncryptionData = representation.getAllEncryptionData();
+                if (allEncryptionData.length > 0) {
+                    callbacks.encryptionDataEncountered(allEncryptionData.map(function (p) { return objectAssign({ content: content }, p); }));
+                    if (globalCanceller.isUsed()) {
+                        return; // previous callback has stopped everything by side-effect
+                    }
+                }
             }
             if (needsManifestRefresh === true) {
                 callbacks.needsManifestRefresh();
@@ -352,14 +339,10 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
                     return; // previous callback has stopped everything by side-effect
                 }
             }
-            const initSegmentUniqueId = initSegmentState.uniqueId;
-            (0, push_media_segment_1.default)({ playbackObserver,
-                content,
-                initSegmentUniqueId,
-                parsedSegment: evt,
-                segment: evt.segment,
-                segmentBuffer }, globalCanceller.signal)
-                .then((result) => {
+            var initSegmentUniqueId = initSegmentState.uniqueId;
+            pushMediaSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, parsedSegment: evt,
+                segment: evt.segment, segmentBuffer: segmentBuffer }, globalCanceller.signal)
+                .then(function (result) {
                 if (result !== null) {
                     callbacks.addedSegment(result);
                 }
@@ -374,7 +357,7 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
      * @param {*} err
      */
     function onFatalBufferError(err) {
-        if (globalCanceller.isUsed() && err instanceof task_canceller_1.CancellationError) {
+        if (globalCanceller.isUsed() && err instanceof CancellationError) {
             // The error is linked to cancellation AND we explicitely cancelled buffer
             // operations.
             // We can thus ignore it, it is very unlikely to lead to true buffer issues.
@@ -384,4 +367,3 @@ function RepresentationStream({ content, options, playbackObserver, segmentBuffe
         callbacks.error(err);
     }
 }
-exports.default = RepresentationStream;