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

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,31 +14,17 @@
  * 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 { tryToChangeSourceBufferType, } from "../../../../compat";
-import config from "../../../../config";
-import log from "../../../../log";
-import { getLoggableSegmentId } from "../../../../manifest";
-import assertUnreachable from "../../../../utils/assert_unreachable";
-import createCancellablePromise from "../../../../utils/create_cancellable_promise";
-import noop from "../../../../utils/noop";
-import objectAssign from "../../../../utils/object_assign";
-import TaskCanceller, { CancellationError, } from "../../../../utils/task_canceller";
-import { SegmentBuffer, SegmentBufferOperation, } from "../types";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compat_1 = require("../../../../compat");
+const config_1 = require("../../../../config");
+const log_1 = require("../../../../log");
+const manifest_1 = require("../../../../manifest");
+const assert_unreachable_1 = require("../../../../utils/assert_unreachable");
+const create_cancellable_promise_1 = require("../../../../utils/create_cancellable_promise");
+const noop_1 = require("../../../../utils/noop");
+const object_assign_1 = require("../../../../utils/object_assign");
+const task_canceller_1 = require("../../../../utils/task_canceller");
+const types_1 = require("../types");
 /**
  * Allows to push and remove new segments to a SourceBuffer in a FIFO queue (not
  * doing so can lead to browser Errors) while keeping an inventory of what has
@@ -48,53 +35,51 @@ import { SegmentBuffer, SegmentBufferOperation, } from "../types";
  *
  * @class AudioVideoSegmentBuffer
  */
-var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
-    __extends(AudioVideoSegmentBuffer, _super);
+class AudioVideoSegmentBuffer extends types_1.SegmentBuffer {
     /**
      * @constructor
      * @param {string} bufferType
      * @param {string} codec
      * @param {MediaSource} mediaSource
      */
-    function AudioVideoSegmentBuffer(bufferType, codec, mediaSource) {
-        var _this = _super.call(this) || this;
-        log.info("AVSB: calling `mediaSource.addSourceBuffer`", codec);
-        var sourceBuffer = mediaSource.addSourceBuffer(codec);
-        _this._canceller = new TaskCanceller();
-        _this.bufferType = bufferType;
-        _this._mediaSource = mediaSource;
-        _this._sourceBuffer = sourceBuffer;
-        _this._queue = [];
-        _this._pendingTask = null;
-        _this._lastInitSegmentUniqueId = null;
-        _this.codec = codec;
-        _this._initSegmentsMap = new Map();
-        var onError = _this._onPendingTaskError.bind(_this);
-        var reCheck = _this._flush.bind(_this);
+    constructor(bufferType, codec, mediaSource) {
+        super();
+        log_1.default.info("AVSB: calling `mediaSource.addSourceBuffer`", codec);
+        const sourceBuffer = mediaSource.addSourceBuffer(codec);
+        this._canceller = new task_canceller_1.default();
+        this.bufferType = bufferType;
+        this._mediaSource = mediaSource;
+        this._sourceBuffer = sourceBuffer;
+        this._queue = [];
+        this._pendingTask = null;
+        this._lastInitSegmentUniqueId = null;
+        this.codec = codec;
+        this._initSegmentsMap = new Map();
+        const onError = this._onPendingTaskError.bind(this);
+        const reCheck = this._flush.bind(this);
         // Some browsers (happened with firefox 66) sometimes "forget" to send us
         // `update` or `updateend` events.
         // In that case, we're completely unable to continue the queue here and
         // stay locked in a waiting state.
         // This interval is here to check at regular intervals if the underlying
         // SourceBuffer is currently updating.
-        var SOURCE_BUFFER_FLUSHING_INTERVAL = config.getCurrent().SOURCE_BUFFER_FLUSHING_INTERVAL;
-        var intervalId = setInterval(reCheck, SOURCE_BUFFER_FLUSHING_INTERVAL);
-        _this._sourceBuffer.addEventListener("error", onError);
-        _this._sourceBuffer.addEventListener("updateend", reCheck);
-        _this._canceller.signal.register(function () {
+        const { SOURCE_BUFFER_FLUSHING_INTERVAL } = config_1.default.getCurrent();
+        const intervalId = setInterval(reCheck, SOURCE_BUFFER_FLUSHING_INTERVAL);
+        this._sourceBuffer.addEventListener("error", onError);
+        this._sourceBuffer.addEventListener("updateend", reCheck);
+        this._canceller.signal.register(() => {
             clearInterval(intervalId);
-            _this._sourceBuffer.removeEventListener("error", onError);
-            _this._sourceBuffer.removeEventListener("updateend", reCheck);
+            this._sourceBuffer.removeEventListener("error", onError);
+            this._sourceBuffer.removeEventListener("updateend", reCheck);
         });
-        return _this;
     }
-    AudioVideoSegmentBuffer.prototype.declareInitSegment = function (uniqueId, initSegmentData) {
+    declareInitSegment(uniqueId, initSegmentData) {
         assertDataIsBufferSource(initSegmentData);
         this._initSegmentsMap.set(uniqueId, initSegmentData);
-    };
-    AudioVideoSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
+    }
+    freeInitSegment(uniqueId) {
         this._initSegmentsMap.delete(uniqueId);
-    };
+    }
     /**
      * Push a chunk of the media segment given to the attached SourceBuffer, in a
      * FIFO queue.
@@ -122,12 +107,12 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @param {Object} cancellationSignal
      * @returns {Promise}
      */
-    AudioVideoSegmentBuffer.prototype.pushChunk = function (infos, cancellationSignal) {
+    pushChunk(infos, cancellationSignal) {
         assertDataIsBufferSource(infos.data.chunk);
-        log.debug("AVSB: receiving order to push data to the SourceBuffer", this.bufferType, getLoggableSegmentId(infos.inventoryInfos));
-        return this._addToQueue({ type: SegmentBufferOperation.Push,
+        log_1.default.debug("AVSB: receiving order to push data to the SourceBuffer", this.bufferType, (0, manifest_1.getLoggableSegmentId)(infos.inventoryInfos));
+        return this._addToQueue({ type: types_1.SegmentBufferOperation.Push,
             value: infos }, cancellationSignal);
-    };
+    }
     /**
      * Remove buffered data (added to the same FIFO queue than `pushChunk`).
      * @param {number} start - start position, in seconds
@@ -135,11 +120,11 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @param {Object} cancellationSignal
      * @returns {Promise}
      */
-    AudioVideoSegmentBuffer.prototype.removeBuffer = function (start, end, cancellationSignal) {
-        log.debug("AVSB: receiving order to remove data from the SourceBuffer", this.bufferType, start, end);
-        return this._addToQueue({ type: SegmentBufferOperation.Remove,
-            value: { start: start, end: end } }, cancellationSignal);
-    };
+    removeBuffer(start, end, cancellationSignal) {
+        log_1.default.debug("AVSB: receiving order to remove data from the SourceBuffer", this.bufferType, start, end);
+        return this._addToQueue({ type: types_1.SegmentBufferOperation.Remove,
+            value: { start, end } }, cancellationSignal);
+    }
     /**
      * Indicate that every chunks from a Segment has been given to pushChunk so
      * far.
@@ -149,41 +134,41 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @param {Object} infos
      * @returns {Promise}
      */
-    AudioVideoSegmentBuffer.prototype.endOfSegment = function (infos, cancellationSignal) {
-        log.debug("AVSB: receiving order for validating end of segment", this.bufferType, getLoggableSegmentId(infos));
-        return this._addToQueue({ type: SegmentBufferOperation.EndOfSegment,
+    endOfSegment(infos, cancellationSignal) {
+        log_1.default.debug("AVSB: receiving order for validating end of segment", this.bufferType, (0, manifest_1.getLoggableSegmentId)(infos));
+        return this._addToQueue({ type: types_1.SegmentBufferOperation.EndOfSegment,
             value: infos }, cancellationSignal);
-    };
+    }
     /**
      * Returns the currently buffered data, in a TimeRanges object.
      * @returns {TimeRanges}
      */
-    AudioVideoSegmentBuffer.prototype.getBufferedRanges = function () {
+    getBufferedRanges() {
         return this._sourceBuffer.buffered;
-    };
+    }
     /**
      * Returns the list of every operations that the `AudioVideoSegmentBuffer` is
      * still processing. From the one with the highest priority (like the one
      * being processed)
      * @returns {Array.<Object>}
      */
-    AudioVideoSegmentBuffer.prototype.getPendingOperations = function () {
-        var parseQueuedOperation = function (op) {
+    getPendingOperations() {
+        const parseQueuedOperation = (op) => {
             // Had to be written that way for TypeScript
             switch (op.type) {
-                case SegmentBufferOperation.Push:
+                case types_1.SegmentBufferOperation.Push:
                     return { type: op.type, value: op.value };
-                case SegmentBufferOperation.Remove:
+                case types_1.SegmentBufferOperation.Remove:
                     return { type: op.type, value: op.value };
-                case SegmentBufferOperation.EndOfSegment:
+                case types_1.SegmentBufferOperation.EndOfSegment:
                     return { type: op.type, value: op.value };
             }
         };
-        var queued = this._queue.map(parseQueuedOperation);
+        const queued = this._queue.map(parseQueuedOperation);
         return this._pendingTask === null ?
             queued :
             [parseQueuedOperation(this._pendingTask)].concat(queued);
-    };
+    }
     /**
      * Dispose of the resources used by this AudioVideoSegmentBuffer.
      *
@@ -191,100 +176,99 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * function.
      * @private
      */
-    AudioVideoSegmentBuffer.prototype.dispose = function () {
+    dispose() {
         this._canceller.cancel();
         if (this._pendingTask !== null) {
-            this._pendingTask.reject(new CancellationError());
+            this._pendingTask.reject(new task_canceller_1.CancellationError());
             this._pendingTask = null;
         }
         while (this._queue.length > 0) {
-            var nextElement = this._queue.shift();
+            const nextElement = this._queue.shift();
             if (nextElement !== undefined) {
-                nextElement.reject(new CancellationError());
+                nextElement.reject(new task_canceller_1.CancellationError());
             }
         }
         if (this._mediaSource.readyState === "open") {
             try {
-                log.debug("AVSB: Calling `abort` on the SourceBuffer");
+                log_1.default.debug("AVSB: Calling `abort` on the SourceBuffer");
                 this._sourceBuffer.abort();
             }
             catch (e) {
-                log.warn("AVSB: Failed to abort a ".concat(this.bufferType, " SourceBuffer:"), e instanceof Error ? e : "");
+                log_1.default.warn(`AVSB: Failed to abort a ${this.bufferType} SourceBuffer:`, e instanceof Error ? e : "");
             }
         }
-    };
+    }
     /**
      * Called when an error arised that made the current task fail.
      * @param {Event} err
      */
-    AudioVideoSegmentBuffer.prototype._onPendingTaskError = function (err) {
+    _onPendingTaskError(err) {
         this._lastInitSegmentUniqueId = null; // initialize init segment as a security
         if (this._pendingTask !== null) {
-            var error = err instanceof Error ?
+            const error = err instanceof Error ?
                 err :
                 new Error("An unknown error occured when doing operations " +
                     "on the SourceBuffer");
             this._pendingTask.reject(error);
         }
-    };
+    }
     /**
      * @private
      * @param {Object} operation
      * @param {Object} cancellationSignal
      * @returns {Promise}
      */
-    AudioVideoSegmentBuffer.prototype._addToQueue = function (operation, cancellationSignal) {
-        var _this = this;
-        return createCancellablePromise(cancellationSignal, function (resolve, reject) {
-            var shouldRestartQueue = _this._queue.length === 0 &&
-                _this._pendingTask === null;
-            var queueItem = objectAssign({ resolve: resolve, reject: reject }, operation);
-            _this._queue.push(queueItem);
+    _addToQueue(operation, cancellationSignal) {
+        return (0, create_cancellable_promise_1.default)(cancellationSignal, (resolve, reject) => {
+            const shouldRestartQueue = this._queue.length === 0 &&
+                this._pendingTask === null;
+            const queueItem = (0, object_assign_1.default)({ resolve, reject }, operation);
+            this._queue.push(queueItem);
             if (shouldRestartQueue) {
-                _this._flush();
+                this._flush();
             }
-            return function () {
+            return () => {
                 // Remove the corresponding element from the AudioVideoSegmentBuffer's
                 // queue.
                 // If the operation was a pending task, it should still continue to not
                 // let the AudioVideoSegmentBuffer in a weird state.
-                var index = _this._queue.indexOf(queueItem);
+                const index = this._queue.indexOf(queueItem);
                 if (index >= 0) {
-                    _this._queue.splice(index, 1);
+                    this._queue.splice(index, 1);
                 }
-                queueItem.resolve = noop;
-                queueItem.reject = noop;
+                queueItem.resolve = noop_1.default;
+                queueItem.reject = noop_1.default;
             };
         });
-    };
+    }
     /**
      * Perform next task if one.
      * @private
      */
-    AudioVideoSegmentBuffer.prototype._flush = function () {
+    _flush() {
         if (this._sourceBuffer.updating) {
             return; // still processing `this._pendingTask`
         }
         if (this._pendingTask !== null) {
-            var task = this._pendingTask;
-            if (task.type !== SegmentBufferOperation.Push || task.data.length === 0) {
+            const task = this._pendingTask;
+            if (task.type !== types_1.SegmentBufferOperation.Push || task.data.length === 0) {
                 // If we're here, we've finished processing the task
                 switch (task.type) {
-                    case SegmentBufferOperation.Push:
+                    case types_1.SegmentBufferOperation.Push:
                         if (task.inventoryData !== null) {
                             this._segmentInventory.insertChunk(task.inventoryData);
                         }
                         break;
-                    case SegmentBufferOperation.EndOfSegment:
+                    case types_1.SegmentBufferOperation.EndOfSegment:
                         this._segmentInventory.completeSegment(task.value, this.getBufferedRanges());
                         break;
-                    case SegmentBufferOperation.Remove:
+                    case types_1.SegmentBufferOperation.Remove:
                         this.synchronizeInventory();
                         break;
                     default:
-                        assertUnreachable(task);
+                        (0, assert_unreachable_1.default)(task);
                 }
-                var resolve = task.resolve;
+                const { resolve } = task;
                 this._pendingTask = null;
                 resolve();
                 this._flush(); // Go to next item in queue
@@ -292,62 +276,62 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
             }
         }
         else { // if this._pendingTask is null, go to next item in queue
-            var nextItem = this._queue.shift();
+            const nextItem = this._queue.shift();
             if (nextItem === undefined) {
                 return; // we have nothing left to do
             }
-            else if (nextItem.type !== SegmentBufferOperation.Push) {
+            else if (nextItem.type !== types_1.SegmentBufferOperation.Push) {
                 this._pendingTask = nextItem;
             }
             else {
-                var itemValue = nextItem.value;
-                var dataToPush = void 0;
+                const itemValue = nextItem.value;
+                let dataToPush;
                 try {
                     dataToPush = this._preparePushOperation(itemValue.data);
                 }
                 catch (e) {
-                    this._pendingTask = objectAssign({ data: [],
+                    this._pendingTask = (0, object_assign_1.default)({ data: [],
                         inventoryData: itemValue.inventoryInfos }, nextItem);
-                    var error = e instanceof Error ?
+                    const error = e instanceof Error ?
                         e :
                         new Error("An unknown error occured when preparing a push operation");
                     this._lastInitSegmentUniqueId = null; // initialize init segment as a security
                     nextItem.reject(error);
                     return;
                 }
-                this._pendingTask = objectAssign({ data: dataToPush,
+                this._pendingTask = (0, object_assign_1.default)({ data: dataToPush,
                     inventoryData: itemValue.inventoryInfos }, nextItem);
             }
         }
         try {
             switch (this._pendingTask.type) {
-                case SegmentBufferOperation.EndOfSegment:
+                case types_1.SegmentBufferOperation.EndOfSegment:
                     // nothing to do, we will just acknowledge the segment.
-                    log.debug("AVSB: Acknowledging complete segment", getLoggableSegmentId(this._pendingTask.value));
+                    log_1.default.debug("AVSB: Acknowledging complete segment", (0, manifest_1.getLoggableSegmentId)(this._pendingTask.value));
                     this._flush();
                     return;
-                case SegmentBufferOperation.Push:
-                    var segmentData = this._pendingTask.data.shift();
+                case types_1.SegmentBufferOperation.Push:
+                    const segmentData = this._pendingTask.data.shift();
                     if (segmentData === undefined) {
                         this._flush();
                         return;
                     }
-                    log.debug("AVSB: pushing segment", this.bufferType, getLoggableSegmentId(this._pendingTask.inventoryData));
+                    log_1.default.debug("AVSB: pushing segment", this.bufferType, (0, manifest_1.getLoggableSegmentId)(this._pendingTask.inventoryData));
                     this._sourceBuffer.appendBuffer(segmentData);
                     break;
-                case SegmentBufferOperation.Remove:
-                    var _a = this._pendingTask.value, start = _a.start, end = _a.end;
-                    log.debug("AVSB: removing data from SourceBuffer", this.bufferType, start, end);
+                case types_1.SegmentBufferOperation.Remove:
+                    const { start, end } = this._pendingTask.value;
+                    log_1.default.debug("AVSB: removing data from SourceBuffer", this.bufferType, start, end);
                     this._sourceBuffer.remove(start, end);
                     break;
                 default:
-                    assertUnreachable(this._pendingTask);
+                    (0, assert_unreachable_1.default)(this._pendingTask);
             }
         }
         catch (e) {
             this._onPendingTaskError(e);
         }
-    };
+    }
     /**
      * A push Operation might necessitate to mutate some `SourceBuffer` and/or
      * `AudioVideoSegmentBuffer` properties and also might need to be divided into
@@ -359,57 +343,57 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @param {Object} data
      * @returns {Object}
      */
-    AudioVideoSegmentBuffer.prototype._preparePushOperation = function (data) {
+    _preparePushOperation(data) {
         // Push operation with both an init segment and a regular segment might
         // need to be separated into two steps
-        var dataToPush = [];
-        var codec = data.codec, timestampOffset = data.timestampOffset, appendWindow = data.appendWindow;
-        var hasUpdatedSourceBufferType = false;
+        const dataToPush = [];
+        const { codec, timestampOffset, appendWindow } = data;
+        let hasUpdatedSourceBufferType = false;
         if (codec !== undefined && codec !== this.codec) {
-            log.debug("AVSB: updating codec", codec);
-            hasUpdatedSourceBufferType = tryToChangeSourceBufferType(this._sourceBuffer, codec);
+            log_1.default.debug("AVSB: updating codec", codec);
+            hasUpdatedSourceBufferType = (0, compat_1.tryToChangeSourceBufferType)(this._sourceBuffer, codec);
             if (hasUpdatedSourceBufferType) {
                 this.codec = codec;
             }
             else {
-                log.debug("AVSB: could not update codec", codec, this.codec);
+                log_1.default.debug("AVSB: could not update codec", codec, this.codec);
             }
         }
         if (this._sourceBuffer.timestampOffset !== timestampOffset) {
-            var newTimestampOffset = timestampOffset;
-            log.debug("AVSB: updating timestampOffset", this.bufferType, this._sourceBuffer.timestampOffset, newTimestampOffset);
+            const newTimestampOffset = timestampOffset;
+            log_1.default.debug("AVSB: updating timestampOffset", this.bufferType, this._sourceBuffer.timestampOffset, newTimestampOffset);
             this._sourceBuffer.timestampOffset = newTimestampOffset;
         }
         if (appendWindow[0] === undefined) {
             if (this._sourceBuffer.appendWindowStart > 0) {
-                log.debug("AVSB: re-setting `appendWindowStart` to `0`");
+                log_1.default.debug("AVSB: re-setting `appendWindowStart` to `0`");
                 this._sourceBuffer.appendWindowStart = 0;
             }
         }
         else if (appendWindow[0] !== this._sourceBuffer.appendWindowStart) {
             if (appendWindow[0] >= this._sourceBuffer.appendWindowEnd) {
-                var newTmpEnd = appendWindow[0] + 1;
-                log.debug("AVSB: pre-updating `appendWindowEnd`", newTmpEnd);
+                const newTmpEnd = appendWindow[0] + 1;
+                log_1.default.debug("AVSB: pre-updating `appendWindowEnd`", newTmpEnd);
                 this._sourceBuffer.appendWindowEnd = newTmpEnd;
             }
-            log.debug("AVSB: setting `appendWindowStart`", appendWindow[0]);
+            log_1.default.debug("AVSB: setting `appendWindowStart`", appendWindow[0]);
             this._sourceBuffer.appendWindowStart = appendWindow[0];
         }
         if (appendWindow[1] === undefined) {
             if (this._sourceBuffer.appendWindowEnd !== Infinity) {
-                log.debug("AVSB: re-setting `appendWindowEnd` to `Infinity`");
+                log_1.default.debug("AVSB: re-setting `appendWindowEnd` to `Infinity`");
                 this._sourceBuffer.appendWindowEnd = Infinity;
             }
         }
         else if (appendWindow[1] !== this._sourceBuffer.appendWindowEnd) {
-            log.debug("AVSB: setting `appendWindowEnd`", appendWindow[1]);
+            log_1.default.debug("AVSB: setting `appendWindowEnd`", appendWindow[1]);
             this._sourceBuffer.appendWindowEnd = appendWindow[1];
         }
         if (data.initSegmentUniqueId !== null &&
             (hasUpdatedSourceBufferType ||
                 !this._isLastInitSegment(data.initSegmentUniqueId))) {
             // Push initialization segment before the media segment
-            var segmentData = this._initSegmentsMap.get(data.initSegmentUniqueId);
+            const segmentData = this._initSegmentsMap.get(data.initSegmentUniqueId);
             if (segmentData === undefined) {
                 throw new Error("Invalid initialization segment uniqueId");
             }
@@ -420,22 +404,21 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
             dataToPush.push(data.chunk);
         }
         return dataToPush;
-    };
+    }
     /**
      * Return `true` if the given `uniqueId` is the identifier of the last
      * initialization segment pushed to the `AudioVideoSegmentBuffer`.
      * @param {string} uniqueId
      * @returns {boolean}
      */
-    AudioVideoSegmentBuffer.prototype._isLastInitSegment = function (uniqueId) {
+    _isLastInitSegment(uniqueId) {
         if (this._lastInitSegmentUniqueId === null) {
             return false;
         }
         return this._lastInitSegmentUniqueId === uniqueId;
-    };
-    return AudioVideoSegmentBuffer;
-}(SegmentBuffer));
-export default AudioVideoSegmentBuffer;
+    }
+}
+exports.default = AudioVideoSegmentBuffer;
 /**
  * Throw if the given input is not in the expected format.
  * Allows to enforce runtime type-checking as compile-time type-checking here is

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,5 +14,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import AudioVideoSegmentBuffer from "./audio_video_segment_buffer";
-export default AudioVideoSegmentBuffer;
+Object.defineProperty(exports, "__esModule", { value: true });
+const audio_video_segment_buffer_1 = require("./audio_video_segment_buffer");
+exports.default = audio_video_segment_buffer_1.default;

package/dist/_esm5.processed/core/segment_buffers/implementations/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import AudioVideoSegmentBuffer from "./audio_video";
-export * from "./types";
-export { AudioVideoSegmentBuffer };
+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 });
+exports.AudioVideoSegmentBuffer = void 0;
+const audio_video_1 = require("./audio_video");
+exports.AudioVideoSegmentBuffer = audio_video_1.default;
+__exportStar(require("./types"), exports);