rx-player 4.5.0 → 4.6.0-dev.2026100600

package/dist/commonjs/mse/main_media_source_interface.js

@@ -1,187 +1,313 @@
 "use strict";
-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);
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get MainSourceBufferInterface () {
+        return MainSourceBufferInterface;
+    },
+    get default () {
+        return MainMediaSourceInterface;
+    }
+});
+var _change_source_buffer_type = /*#__PURE__*/ _interop_require_default(require("../compat/change_source_buffer_type.js"));
+var _event_listeners = require("../compat/event_listeners.js");
+var _index = require("../errors/index.js");
+var _log = /*#__PURE__*/ _interop_require_default(require("../log.js"));
+var _byte_parsing = require("../utils/byte_parsing.js");
+var _event_emitter = /*#__PURE__*/ _interop_require_default(require("../utils/event_emitter.js"));
+var _is_null_or_undefined = /*#__PURE__*/ _interop_require_default(require("../utils/is_null_or_undefined.js"));
+var _object_assign = /*#__PURE__*/ _interop_require_default(require("../utils/object_assign.js"));
+var _ranges = require("../utils/ranges.js");
+var _task_canceller = /*#__PURE__*/ _interop_require_wildcard(require("../utils/task_canceller.js"));
+var _end_of_stream = require("./utils/end_of_stream.js");
+var _media_source_duration_updater = /*#__PURE__*/ _interop_require_default(require("./utils/media_source_duration_updater.js"));
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) return obj;
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") return {
+        default: obj
     };
-    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 __());
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) return cache.get(obj);
+    var newObj = {
+        __proto__: null
     };
-})();
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+            else newObj[key] = obj[key];
         }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
+    }
+    newObj.default = obj;
+    if (cache) cache.set(obj, newObj);
+    return newObj;
+}
+function _is_native_reflect_construct() {
     try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
     }
-    catch (error) { e = { error: error }; }
-    finally {
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
         try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
         }
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MainSourceBufferInterface = void 0;
-var browser_compatibility_types_1 = require("../compat/browser_compatibility_types");
-var change_source_buffer_type_1 = require("../compat/change_source_buffer_type");
-var event_listeners_1 = require("../compat/event_listeners");
-var errors_1 = require("../errors");
-var log_1 = require("../log");
-var byte_parsing_1 = require("../utils/byte_parsing");
-var event_emitter_1 = require("../utils/event_emitter");
-var is_null_or_undefined_1 = require("../utils/is_null_or_undefined");
-var object_assign_1 = require("../utils/object_assign");
-var ranges_1 = require("../utils/ranges");
-var task_canceller_1 = require("../utils/task_canceller");
-var end_of_stream_1 = require("./utils/end_of_stream");
-var media_source_duration_updater_1 = require("./utils/media_source_duration_updater");
-/**
- * `IMediaSourceInterface` object for when the MSE API are directly available.
- * @see IMediaSourceInterface
- * @class {MainMediaSourceInterface}
- */
-var MainMediaSourceInterface = /** @class */ (function (_super) {
-    __extends(MainMediaSourceInterface, _super);
-    /**
-     * Creates a new `MainMediaSourceInterface` alongside its `MediaSource` MSE
-     * object.
-     *
-     * You can then obtain a link to that `MediaSource`, for example to link it
-     * to an `HTMLMediaElement`, through the `handle` property.
-     */
-    function MainMediaSourceInterface(id, forcedMediaSource) {
-        var _this = _super.call(this) || this;
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) return call;
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var MainMediaSourceInterface = /*#__PURE__*/ function(EventEmitter) {
+    "use strict";
+    _inherits(MainMediaSourceInterface, EventEmitter);
+    function MainMediaSourceInterface(id, mediaSourceClass) {
+        _class_call_check(this, MainMediaSourceInterface);
+        var _this;
+        _this = _call_super(this, MainMediaSourceInterface);
         _this.id = id;
         _this.sourceBuffers = [];
-        _this._canceller = new task_canceller_1.default("MainMediaSourceInterface");
-        var MediaSource_ = browser_compatibility_types_1.default.MediaSource_;
-        if ((0, is_null_or_undefined_1.default)(MediaSource_)) {
-            throw new errors_1.MediaError("MEDIA_SOURCE_NOT_SUPPORTED", "No MediaSource Object was found in the current browser.");
-        }
-        log_1.default.info("mse", "Creating MediaSource");
-        var mediaSource = forcedMediaSource !== undefined ? new forcedMediaSource() : new MediaSource_();
+        _this._canceller = new _task_canceller.default("MainMediaSourceInterface");
+        _log.default.info("mse", "Creating MediaSource");
+        var mediaSource = new mediaSourceClass();
         var handle = mediaSource.handle;
-        _this.handle = (0, is_null_or_undefined_1.default)(handle)
-            ? // eslint-disable-next-line @typescript-eslint/no-restricted-types
-                { type: "media-source", value: mediaSource }
-            : { type: "handle", value: handle };
+        _this.handle = (0, _is_null_or_undefined.default)(handle) ? {
+            type: "media-source",
+            value: mediaSource
+        } : {
+            type: "handle",
+            value: handle
+        };
         _this._mediaSource = mediaSource;
         _this.readyState = mediaSource.readyState;
-        _this._durationUpdater = new media_source_duration_updater_1.default(mediaSource);
+        _this._durationUpdater = new _media_source_duration_updater.default(mediaSource);
         _this._endOfStreamCanceller = null;
-        (0, event_listeners_1.onSourceOpen)(mediaSource, function () {
+        (0, _event_listeners.onSourceOpen)(mediaSource, function() {
             _this.readyState = mediaSource.readyState;
             _this.trigger("mediaSourceOpen", null);
         }, _this._canceller.signal);
-        (0, event_listeners_1.onSourceEnded)(mediaSource, function () {
+        (0, _event_listeners.onSourceEnded)(mediaSource, function() {
             _this.readyState = mediaSource.readyState;
             _this.trigger("mediaSourceEnded", null);
         }, _this._canceller.signal);
-        (0, event_listeners_1.onSourceClose)(mediaSource, function () {
+        (0, _event_listeners.onSourceClose)(mediaSource, function() {
             _this.readyState = mediaSource.readyState;
             _this.trigger("mediaSourceClose", null);
         }, _this._canceller.signal);
         if (_this._mediaSource.streaming !== undefined) {
             _this.streaming = _this._mediaSource.streaming;
         }
-        _this._mediaSource.addEventListener("startstreaming", function () {
+        _this._mediaSource.addEventListener("startstreaming", function() {
             _this.streaming = true;
             _this.trigger("streamingChanged", null);
         });
-        _this._mediaSource.addEventListener("endstreaming", function () {
+        _this._mediaSource.addEventListener("endstreaming", function() {
             _this.streaming = false;
             _this.trigger("streamingChanged", null);
         });
         return _this;
     }
-    /** @see IMediaSourceInterface */
-    MainMediaSourceInterface.prototype.addSourceBuffer = function (sbType, codec) {
-        var sourceBuffer = this._mediaSource.addSourceBuffer(codec);
-        var sb = new MainSourceBufferInterface(sbType, codec, sourceBuffer);
-        this.sourceBuffers.push(sb);
-        return sb;
-    };
-    /** @see IMediaSourceInterface */
-    MainMediaSourceInterface.prototype.setDuration = function (newDuration, isRealEndKnown) {
-        this._durationUpdater.updateDuration(newDuration, isRealEndKnown);
-    };
-    /** @see IMediaSourceInterface */
-    MainMediaSourceInterface.prototype.interruptDurationSetting = function (reason) {
-        this._durationUpdater.stopUpdating(reason);
-    };
-    /** @see IMediaSourceInterface */
-    MainMediaSourceInterface.prototype.maintainEndOfStream = function () {
-        if (this._endOfStreamCanceller === null) {
-            this._endOfStreamCanceller = new task_canceller_1.default("MainMediaSourceInterface EndOfStream");
-            this._endOfStreamCanceller.linkToSignal(this._canceller.signal);
-            log_1.default.debug("mse", "end-of-stream order received.");
-            (0, end_of_stream_1.maintainEndOfStream)(this._mediaSource, this._endOfStreamCanceller.signal);
-        }
-    };
-    /** @see IMediaSourceInterface */
-    MainMediaSourceInterface.prototype.stopEndOfStream = function () {
-        if (this._endOfStreamCanceller !== null) {
-            log_1.default.debug("mse", "resume-stream order received.");
-            this._endOfStreamCanceller.cancel("MediaSourceInterface stopEndOfStream");
-            this._endOfStreamCanceller = null;
+    _create_class(MainMediaSourceInterface, [
+        {
+            /** @see IMediaSourceInterface */ key: "addSourceBuffer",
+            value: function addSourceBuffer(sbType, codec) {
+                var sourceBuffer = this._mediaSource.addSourceBuffer(codec);
+                var sb = new MainSourceBufferInterface(sbType, codec, sourceBuffer);
+                this.sourceBuffers.push(sb);
+                return sb;
+            }
+        },
+        {
+            /** @see IMediaSourceInterface */ key: "setDuration",
+            value: function setDuration(newDuration, isRealEndKnown) {
+                this._durationUpdater.updateDuration(newDuration, isRealEndKnown);
+            }
+        },
+        {
+            /** @see IMediaSourceInterface */ key: "interruptDurationSetting",
+            value: function interruptDurationSetting(reason) {
+                this._durationUpdater.stopUpdating(reason);
+            }
+        },
+        {
+            /** @see IMediaSourceInterface */ key: "maintainEndOfStream",
+            value: function maintainEndOfStream() {
+                if (this._endOfStreamCanceller === null) {
+                    this._endOfStreamCanceller = new _task_canceller.default("MainMediaSourceInterface EndOfStream");
+                    this._endOfStreamCanceller.linkToSignal(this._canceller.signal);
+                    _log.default.debug("mse", "end-of-stream order received.");
+                    (0, _end_of_stream.maintainEndOfStream)(this._mediaSource, this._endOfStreamCanceller.signal);
+                }
+            }
+        },
+        {
+            /** @see IMediaSourceInterface */ key: "stopEndOfStream",
+            value: function stopEndOfStream() {
+                if (this._endOfStreamCanceller !== null) {
+                    _log.default.debug("mse", "resume-stream order received.");
+                    this._endOfStreamCanceller.cancel("MediaSourceInterface stopEndOfStream");
+                    this._endOfStreamCanceller = null;
+                }
+            }
+        },
+        {
+            /** @see IMediaSourceInterface */ key: "dispose",
+            value: function dispose(reason) {
+                this.sourceBuffers.forEach(function(s) {
+                    return s.dispose(reason);
+                });
+                this._canceller.cancel(reason !== null && reason !== void 0 ? reason : "MainMediaSourceInterface dispose");
+                resetMediaSource(this._mediaSource);
+            }
         }
-    };
-    /** @see IMediaSourceInterface */
-    MainMediaSourceInterface.prototype.dispose = function (reason) {
-        this.sourceBuffers.forEach(function (s) { return s.dispose(reason); });
-        this._canceller.cancel(reason !== null && reason !== void 0 ? reason : "MainMediaSourceInterface dispose");
-        resetMediaSource(this._mediaSource);
-    };
+    ]);
     return MainMediaSourceInterface;
-}(event_emitter_1.default));
-exports.default = MainMediaSourceInterface;
-/**
- * `ISourceBufferInterface` object for when the MSE API are directly available.
- * @see ISourceBufferInterface
- * @class {MainSourceBufferInterface}
- */
-var MainSourceBufferInterface = /** @class */ (function () {
-    /**
-     * Creates a new `SourceBufferInterface` linked to the given `SourceBuffer`
-     * instance.
-     * @param {string} sbType
-     * @param {string} codec
-     * @param {SourceBuffer} sourceBuffer
-     */
+}(_event_emitter.default);
+var MainSourceBufferInterface = /*#__PURE__*/ function() {
+    "use strict";
     function MainSourceBufferInterface(sbType, codec, sourceBuffer) {
+        _class_call_check(this, MainSourceBufferInterface);
         this.type = sbType;
         this.codec = codec;
-        this._canceller = new task_canceller_1.default("MainSourceBufferInterface " + sbType);
+        this._canceller = new _task_canceller.default("MainSourceBufferInterface " + sbType);
         this._sourceBuffer = sourceBuffer;
         this._operationQueue = [];
         this._currentOperations = [];
@@ -189,423 +315,456 @@ var MainSourceBufferInterface = /** @class */ (function () {
         var onUpdateEnd = this._onUpdateEnd.bind(this);
         sourceBuffer.addEventListener("updateend", onUpdateEnd);
         sourceBuffer.addEventListener("error", onError);
-        this._canceller.signal.register(function () {
+        this._canceller.signal.register(function() {
             sourceBuffer.removeEventListener("updateend", onUpdateEnd);
             sourceBuffer.removeEventListener("error", onError);
         });
     }
-    /** @see ISourceBufferInterface */
-    MainSourceBufferInterface.prototype.appendBuffer = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        log_1.default.debug("mse", "receiving order to push data to the SourceBuffer", {
-            type: this.type,
-        });
-        return this._addToQueue({
-            operationName: 0 /* SbiOperationName.Push */,
-            params: args,
-        });
-    };
-    /** @see ISourceBufferInterface */
-    MainSourceBufferInterface.prototype.remove = function (start, end) {
-        log_1.default.debug("mse", "receiving order to remove data from the SourceBuffer", {
-            type: this.type,
-            start: start,
-            end: end,
-        });
-        return this._addToQueue({
-            operationName: 1 /* SbiOperationName.Remove */,
-            params: [start, end],
-        });
-    };
-    /** @see ISourceBufferInterface */
-    MainSourceBufferInterface.prototype.getBuffered = function () {
-        try {
-            return (0, ranges_1.convertToRanges)(this._sourceBuffer.buffered);
-        }
-        catch (err) {
-            log_1.default.error("mse", "Failed to get buffered time range of SourceBuffer", {
-                type: this.type,
-            }, err instanceof Error ? err : "Unknown Error");
-            return [];
-        }
-    };
-    /** @see ISourceBufferInterface */
-    MainSourceBufferInterface.prototype.abort = function (reason) {
-        try {
-            this._sourceBuffer.abort();
-        }
-        catch (err) {
-            log_1.default.debug("mse", "Failed to abort SourceBuffer:", err instanceof Error ? err : "Unknown Error");
-        }
-        this._emptyCurrentQueue(reason);
-    };
-    /** @see ISourceBufferInterface */
-    MainSourceBufferInterface.prototype.dispose = function (reason) {
-        try {
-            this._sourceBuffer.abort();
-        }
-        catch (_) {
-            // we don't care
-        }
-        this._emptyCurrentQueue(reason);
-    };
-    MainSourceBufferInterface.prototype._onError = function (evt) {
-        var e_1, _a;
-        var error;
-        if (evt instanceof Error) {
-            error = evt;
-        }
-        else if (evt.error instanceof Error) {
-            error = evt.error;
-        }
-        else {
-            error = new Error("Unknown SourceBuffer Error");
-        }
-        var currentOps = this._currentOperations;
-        this._currentOperations = [];
-        if (currentOps.length === 0) {
-            log_1.default.error("mse", "error for an unknown operation", error);
-        }
-        else {
-            var rejected = new errors_1.SourceBufferError(error.name, error.message, error.name === "QuotaExceededError");
-            try {
-                for (var currentOps_1 = __values(currentOps), currentOps_1_1 = currentOps_1.next(); !currentOps_1_1.done; currentOps_1_1 = currentOps_1.next()) {
-                    var op = currentOps_1_1.value;
-                    op.reject(rejected);
+    _create_class(MainSourceBufferInterface, [
+        {
+            /** @see ISourceBufferInterface */ key: "appendBuffer",
+            value: function appendBuffer() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
                 }
+                _log.default.debug("mse", "receiving order to push data to the SourceBuffer", {
+                    type: this.type
+                });
+                return this._addToQueue({
+                    operationName: 0 /* SbiOperationName.Push */ ,
+                    params: args
+                });
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
+        },
+        {
+            /** @see ISourceBufferInterface */ key: "remove",
+            value: function remove(start, end) {
+                _log.default.debug("mse", "receiving order to remove data from the SourceBuffer", {
+                    type: this.type,
+                    start: start,
+                    end: end
+                });
+                return this._addToQueue({
+                    operationName: 1 /* SbiOperationName.Remove */ ,
+                    params: [
+                        start,
+                        end
+                    ]
+                });
+            }
+        },
+        {
+            /** @see ISourceBufferInterface */ key: "getBuffered",
+            value: function getBuffered() {
                 try {
-                    if (currentOps_1_1 && !currentOps_1_1.done && (_a = currentOps_1.return)) _a.call(currentOps_1);
+                    return (0, _ranges.convertToRanges)(this._sourceBuffer.buffered);
+                } catch (err) {
+                    _log.default.error("mse", "Failed to get buffered time range of SourceBuffer", {
+                        type: this.type
+                    }, _instanceof(err, Error) ? err : "Unknown Error");
+                    return [];
                 }
-                finally { if (e_1) throw e_1.error; }
             }
-        }
-    };
-    MainSourceBufferInterface.prototype._onUpdateEnd = function () {
-        var e_2, _a, e_3, _b;
-        var currentOps = this._currentOperations;
-        this._currentOperations = [];
-        try {
-            try {
-                for (var currentOps_2 = __values(currentOps), currentOps_2_1 = currentOps_2.next(); !currentOps_2_1.done; currentOps_2_1 = currentOps_2.next()) {
-                    var op = currentOps_2_1.value;
-                    op.resolve((0, ranges_1.convertToRanges)(this._sourceBuffer.buffered));
+        },
+        {
+            /** @see ISourceBufferInterface */ key: "abort",
+            value: function abort(reason) {
+                try {
+                    this._sourceBuffer.abort();
+                } catch (err) {
+                    _log.default.debug("mse", "Failed to abort SourceBuffer:", _instanceof(err, Error) ? err : "Unknown Error");
                 }
+                this._emptyCurrentQueue(reason);
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
+        },
+        {
+            /** @see ISourceBufferInterface */ key: "dispose",
+            value: function dispose(reason) {
                 try {
-                    if (currentOps_2_1 && !currentOps_2_1.done && (_a = currentOps_2.return)) _a.call(currentOps_2);
+                    this._sourceBuffer.abort();
+                } catch (_) {
+                // we don't care
                 }
-                finally { if (e_2) throw e_2.error; }
+                this._emptyCurrentQueue(reason);
             }
-        }
-        catch (err) {
-            try {
-                for (var currentOps_3 = __values(currentOps), currentOps_3_1 = currentOps_3.next(); !currentOps_3_1.done; currentOps_3_1 = currentOps_3.next()) {
-                    var op = currentOps_3_1.value;
-                    if (err instanceof Error && err.name === "InvalidStateError") {
-                        // Most likely the SourceBuffer just has been removed from the
-                        // `MediaSource`.
-                        // Just return an empty buffered range.
-                        op.resolve([]);
-                    }
-                    else {
-                        op.reject(err);
+        },
+        {
+            key: "_onError",
+            value: function _onError(evt) {
+                var error;
+                if (_instanceof(evt, Error)) {
+                    error = evt;
+                } else if (_instanceof(evt.error, Error)) {
+                    error = evt.error;
+                } else {
+                    error = new Error("Unknown SourceBuffer Error");
+                }
+                var currentOps = this._currentOperations;
+                this._currentOperations = [];
+                if (currentOps.length === 0) {
+                    _log.default.error("mse", "error for an unknown operation", error);
+                } else {
+                    var rejected = new _index.SourceBufferError(error.name, error.message, error.name === "QuotaExceededError");
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = currentOps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var op = _step.value;
+                            op.reject(rejected);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
                     }
                 }
             }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
+        },
+        {
+            key: "_onUpdateEnd",
+            value: function _onUpdateEnd() {
+                var currentOps = this._currentOperations;
+                this._currentOperations = [];
                 try {
-                    if (currentOps_3_1 && !currentOps_3_1.done && (_b = currentOps_3.return)) _b.call(currentOps_3);
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = currentOps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var op = _step.value;
+                            op.resolve((0, _ranges.convertToRanges)(this._sourceBuffer.buffered));
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                } catch (err1) {
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = currentOps[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var op1 = _step1.value;
+                            if (_instanceof(err1, Error) && err1.name === "InvalidStateError") {
+                                // Most likely the SourceBuffer just has been removed from the
+                                // `MediaSource`.
+                                // Just return an empty buffered range.
+                                op1.resolve([]);
+                            } else {
+                                op1.reject(err1);
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
                 }
-                finally { if (e_3) throw e_3.error; }
+                this._performNextOperation();
             }
-        }
-        this._performNextOperation();
-    };
-    /**
+        },
+        {
+            /**
      * @param {string | undefined} reason - Human-inspectable reason behind the
      * action. Used for debugging matters, especially for debug log
      * inspection.
-     */
-    MainSourceBufferInterface.prototype._emptyCurrentQueue = function (reason) {
-        var error = new task_canceller_1.CancellationError("MainSourceBufferInterface queue " + this.type, reason);
-        if (this._currentOperations.length > 0) {
-            this._currentOperations.forEach(function (op) {
-                op.reject(error);
-            });
-            this._currentOperations = [];
-        }
-        if (this._operationQueue.length > 0) {
-            this._operationQueue.forEach(function (op) {
-                op.reject(error);
-            });
-            this._operationQueue = [];
-        }
-    };
-    MainSourceBufferInterface.prototype._addToQueue = function (operation) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var shouldRestartQueue = _this._operationQueue.length === 0 && _this._currentOperations.length === 0;
-            var queueItem = (0, object_assign_1.default)({ resolve: resolve, reject: reject }, operation);
-            _this._operationQueue.push(queueItem);
-            if (shouldRestartQueue) {
-                _this._performNextOperation();
-            }
-        });
-    };
-    MainSourceBufferInterface.prototype._performNextOperation = function () {
-        var _a, _b, _c, _d, _e;
-        if (this._currentOperations.length !== 0 || this._sourceBuffer.updating) {
-            return;
-        }
-        var nextElem = this._operationQueue.shift();
-        if (nextElem === undefined) {
-            return;
-        }
-        else if (nextElem.operationName === 0 /* SbiOperationName.Push */) {
-            this._currentOperations = [
-                {
-                    operationName: 0 /* SbiOperationName.Push */,
-                    resolve: nextElem.resolve,
-                    reject: nextElem.reject,
-                },
-            ];
-            var ogData = nextElem.params[0];
-            var params = nextElem.params[1];
-            var segmentData = ogData;
-            // In some cases with very poor performances, tens of appendBuffer
-            // requests could be waiting for their turn here.
-            //
-            // Instead of pushing each one, one by one, waiting in-between for each
-            // one's `"updateend"` event (which would probably have lot of time
-            // overhead involved, even more considering that we're probably
-            // encountering performance issues), the idea is to concatenate all
-            // similar push operations into one huge segment.
-            //
-            // This seems to have a very large positive effect on the more
-            // extreme scenario, such as low-latency CMAF with very small chunks and
-            // huge CPU usage in the thread doing the push operation.
-            //
-            // Because this should still be relatively rare, we pre-check here
-            // the condition.
-            if (this._operationQueue.length > 0 &&
-                this._operationQueue[0].operationName === 0 /* SbiOperationName.Push */) {
-                var prevU8 = void 0;
-                if (ogData instanceof ArrayBuffer) {
-                    prevU8 = new Uint8Array(ogData);
+     */ key: "_emptyCurrentQueue",
+            value: function _emptyCurrentQueue(reason) {
+                var error = new _task_canceller.CancellationError("MainSourceBufferInterface queue " + this.type, reason);
+                if (this._currentOperations.length > 0) {
+                    this._currentOperations.forEach(function(op) {
+                        op.reject(error);
+                    });
+                    this._currentOperations = [];
                 }
-                else if (ogData instanceof Uint8Array) {
-                    prevU8 = ogData;
+                if (this._operationQueue.length > 0) {
+                    this._operationQueue.forEach(function(op) {
+                        op.reject(error);
+                    });
+                    this._operationQueue = [];
                 }
-                else {
-                    prevU8 = new Uint8Array(ogData.buffer);
+            }
+        },
+        {
+            key: "_addToQueue",
+            value: function _addToQueue(operation) {
+                var _this = this;
+                return new Promise(function(resolve, reject) {
+                    var shouldRestartQueue = _this._operationQueue.length === 0 && _this._currentOperations.length === 0;
+                    var queueItem = (0, _object_assign.default)({
+                        resolve: resolve,
+                        reject: reject
+                    }, operation);
+                    _this._operationQueue.push(queueItem);
+                    if (shouldRestartQueue) {
+                        _this._performNextOperation();
+                    }
+                });
+            }
+        },
+        {
+            key: "_performNextOperation",
+            value: function _performNextOperation() {
+                var _a, _b, _c, _d, _e;
+                if (this._currentOperations.length !== 0 || this._sourceBuffer.updating) {
+                    return;
                 }
-                var toConcat = [prevU8];
-                while (((_a = this._operationQueue[0]) === null || _a === void 0 ? void 0 : _a.operationName) === 0 /* SbiOperationName.Push */) {
-                    var followingElem = this._operationQueue[0];
-                    var cAw = (_b = params.appendWindow) !== null && _b !== void 0 ? _b : [undefined, undefined];
-                    var fAw = (_c = followingElem.params[1].appendWindow) !== null && _c !== void 0 ? _c : [undefined, undefined];
-                    var cTo = (_d = params.timestampOffset) !== null && _d !== void 0 ? _d : 0;
-                    var fTo = (_e = followingElem.params[1].timestampOffset) !== null && _e !== void 0 ? _e : 0;
-                    if (cAw[0] === fAw[0] &&
-                        cAw[1] === fAw[1] &&
-                        params.codec === followingElem.params[1].codec &&
-                        cTo === fTo) {
-                        var newData = followingElem.params[0];
-                        var newU8 = void 0;
-                        if (newData instanceof ArrayBuffer) {
-                            newU8 = new Uint8Array(newData);
+                var nextElem = this._operationQueue.shift();
+                if (nextElem === undefined) {
+                    return;
+                } else if (nextElem.operationName === 0 /* SbiOperationName.Push */ ) {
+                    this._currentOperations = [
+                        {
+                            operationName: 0 /* SbiOperationName.Push */ ,
+                            resolve: nextElem.resolve,
+                            reject: nextElem.reject
                         }
-                        else if (newData instanceof Uint8Array) {
-                            newU8 = newData;
+                    ];
+                    var ogData = nextElem.params[0];
+                    var params = nextElem.params[1];
+                    var segmentData = ogData;
+                    // In some cases with very poor performances, tens of appendBuffer
+                    // requests could be waiting for their turn here.
+                    //
+                    // Instead of pushing each one, one by one, waiting in-between for each
+                    // one's `"updateend"` event (which would probably have lot of time
+                    // overhead involved, even more considering that we're probably
+                    // encountering performance issues), the idea is to concatenate all
+                    // similar push operations into one huge segment.
+                    //
+                    // This seems to have a very large positive effect on the more
+                    // extreme scenario, such as low-latency CMAF with very small chunks and
+                    // huge CPU usage in the thread doing the push operation.
+                    //
+                    // Because this should still be relatively rare, we pre-check here
+                    // the condition.
+                    if (this._operationQueue.length > 0 && this._operationQueue[0].operationName === 0 /* SbiOperationName.Push */ ) {
+                        var prevU8;
+                        if (_instanceof(ogData, ArrayBuffer)) {
+                            prevU8 = new Uint8Array(ogData);
+                        } else if (_instanceof(ogData, Uint8Array)) {
+                            prevU8 = ogData;
+                        } else {
+                            prevU8 = new Uint8Array(ogData.buffer);
                         }
-                        else {
-                            newU8 = new Uint8Array(newData.buffer);
+                        var toConcat = [
+                            prevU8
+                        ];
+                        while(((_a = this._operationQueue[0]) === null || _a === void 0 ? void 0 : _a.operationName) === 0 /* SbiOperationName.Push */ ){
+                            var followingElem = this._operationQueue[0];
+                            var cAw = (_b = params.appendWindow) !== null && _b !== void 0 ? _b : [
+                                undefined,
+                                undefined
+                            ];
+                            var fAw = (_c = followingElem.params[1].appendWindow) !== null && _c !== void 0 ? _c : [
+                                undefined,
+                                undefined
+                            ];
+                            var cTo = (_d = params.timestampOffset) !== null && _d !== void 0 ? _d : 0;
+                            var fTo = (_e = followingElem.params[1].timestampOffset) !== null && _e !== void 0 ? _e : 0;
+                            if (cAw[0] === fAw[0] && cAw[1] === fAw[1] && params.codec === followingElem.params[1].codec && cTo === fTo) {
+                                var newData = followingElem.params[0];
+                                var newU8 = void 0;
+                                if (_instanceof(newData, ArrayBuffer)) {
+                                    newU8 = new Uint8Array(newData);
+                                } else if (_instanceof(newData, Uint8Array)) {
+                                    newU8 = newData;
+                                } else {
+                                    newU8 = new Uint8Array(newData.buffer);
+                                }
+                                toConcat.push(newU8);
+                                this._operationQueue.splice(0, 1);
+                                this._currentOperations.push({
+                                    operationName: 0 /* SbiOperationName.Push */ ,
+                                    resolve: followingElem.resolve,
+                                    reject: followingElem.reject
+                                });
+                            } else {
+                                break;
+                            }
                         }
-                        toConcat.push(newU8);
-                        this._operationQueue.splice(0, 1);
-                        this._currentOperations.push({
-                            operationName: 0 /* SbiOperationName.Push */,
-                            resolve: followingElem.resolve,
-                            reject: followingElem.reject,
+                        if (toConcat.length > 1) {
+                            _log.default.info("mse", ": Merging ".concat(toConcat.length, " segments together for perf"), {
+                                type: this.type
+                            });
+                            segmentData = _byte_parsing.concat.apply(void 0, _to_consumable_array(toConcat)).buffer;
+                        }
+                    }
+                    try {
+                        this._appendBufferNow(segmentData, params);
+                    } catch (err) {
+                        var error = _instanceof(err, Error) ? new _index.SourceBufferError(err.name, err.message, err.name === "QuotaExceededError") : new _index.SourceBufferError("Error", "Unknown SourceBuffer Error during appendBuffer", false);
+                        this._currentOperations.forEach(function(op) {
+                            op.reject(error);
                         });
+                        this._currentOperations = [];
+                        // A synchronous error probably will not lead to updateend event, so we need to
+                        // go to next queue element manually
+                        //
+                        // FIXME: This here is needed to ensure that we're not left with a
+                        // dangling queue of operations.
+                        // However it can potentially be counter-productive if e.g. the `appendBuffer`
+                        // error was due to a full buffer and if there are pushing operations awaiting in
+                        // the queue.
+                        //
+                        // A better solution might just be to reject all push operations right away here?
+                        // Only for a `QuotaExceededError` (to check MSE)?
+                        // However this is too disruptive for what is now a hotfix
+                        this._performNextOperation();
                     }
-                    else {
-                        break;
+                } else {
+                    // TODO merge contiguous removes?
+                    this._currentOperations = [
+                        nextElem
+                    ];
+                    var _nextElem_params = _sliced_to_array(nextElem.params, 2), start = _nextElem_params[0], end = _nextElem_params[1];
+                    _log.default.debug("mse", "removing data from SourceBuffer", {
+                        type: this.type,
+                        start: start,
+                        end: end
+                    });
+                    try {
+                        this._sourceBuffer.remove(start, end);
+                    } catch (err) {
+                        var error1 = _instanceof(err, Error) ? new _index.SourceBufferError(err.name, err.message, false) : new _index.SourceBufferError("Error", "Unknown SourceBuffer Error during remove", false);
+                        nextElem.reject(error1);
+                        this._currentOperations.forEach(function(op) {
+                            op.reject(error1);
+                        });
+                        this._currentOperations = [];
+                        // A synchronous error probably will not lead to updateend event, so we need to
+                        // go to next queue element manually
+                        this._performNextOperation();
                     }
                 }
-                if (toConcat.length > 1) {
-                    log_1.default.info("mse", ": Merging ".concat(toConcat.length, " segments together for perf"), {
+            }
+        },
+        {
+            key: "_appendBufferNow",
+            value: function _appendBufferNow(data, params) {
+                var sourceBuffer = this._sourceBuffer;
+                var codec = params.codec, timestampOffset = params.timestampOffset, _params_appendWindow = params.appendWindow, appendWindow = _params_appendWindow === void 0 ? [] : _params_appendWindow;
+                if (codec !== undefined && codec !== this.codec) {
+                    _log.default.debug("mse", "updating codec", {
                         type: this.type,
+                        prevCodec: this.codec,
+                        newCodec: codec
                     });
-                    segmentData = byte_parsing_1.concat.apply(void 0, __spreadArray([], __read(toConcat), false)).buffer;
+                    var hasUpdatedSourceBufferType = (0, _change_source_buffer_type.default)(sourceBuffer, codec);
+                    if (hasUpdatedSourceBufferType) {
+                        this.codec = codec;
+                    } else {
+                        _log.default.debug("mse", "could not update codec", {
+                            type: this.type,
+                            prevCodec: this.codec,
+                            newCodec: codec
+                        });
+                    }
                 }
-            }
-            try {
-                this._appendBufferNow(segmentData, params);
-            }
-            catch (err) {
-                var error_1 = err instanceof Error
-                    ? new errors_1.SourceBufferError(err.name, err.message, err.name === "QuotaExceededError")
-                    : new errors_1.SourceBufferError("Error", "Unknown SourceBuffer Error during appendBuffer", false);
-                this._currentOperations.forEach(function (op) {
-                    op.reject(error_1);
-                });
-                this._currentOperations = [];
-                // A synchronous error probably will not lead to updateend event, so we need to
-                // go to next queue element manually
-                //
-                // FIXME: This here is needed to ensure that we're not left with a
-                // dangling queue of operations.
-                // However it can potentially be counter-productive if e.g. the `appendBuffer`
-                // error was due to a full buffer and if there are pushing operations awaiting in
-                // the queue.
-                //
-                // A better solution might just be to reject all push operations right away here?
-                // Only for a `QuotaExceededError` (to check MSE)?
-                // However this is too disruptive for what is now a hotfix
-                this._performNextOperation();
-            }
-        }
-        else {
-            // TODO merge contiguous removes?
-            this._currentOperations = [nextElem];
-            var _f = __read(nextElem.params, 2), start = _f[0], end = _f[1];
-            log_1.default.debug("mse", "removing data from SourceBuffer", {
-                type: this.type,
-                start: start,
-                end: end,
-            });
-            try {
-                this._sourceBuffer.remove(start, end);
-            }
-            catch (err) {
-                var error_2 = err instanceof Error
-                    ? new errors_1.SourceBufferError(err.name, err.message, false)
-                    : new errors_1.SourceBufferError("Error", "Unknown SourceBuffer Error during remove", false);
-                nextElem.reject(error_2);
-                this._currentOperations.forEach(function (op) {
-                    op.reject(error_2);
-                });
-                this._currentOperations = [];
-                // A synchronous error probably will not lead to updateend event, so we need to
-                // go to next queue element manually
-                this._performNextOperation();
-            }
-        }
-    };
-    MainSourceBufferInterface.prototype._appendBufferNow = function (data, params) {
-        var sourceBuffer = this._sourceBuffer;
-        var codec = params.codec, timestampOffset = params.timestampOffset, _a = params.appendWindow, appendWindow = _a === void 0 ? [] : _a;
-        if (codec !== undefined && codec !== this.codec) {
-            log_1.default.debug("mse", "updating codec", {
-                type: this.type,
-                prevCodec: this.codec,
-                newCodec: codec,
-            });
-            var hasUpdatedSourceBufferType = (0, change_source_buffer_type_1.default)(sourceBuffer, codec);
-            if (hasUpdatedSourceBufferType) {
-                this.codec = codec;
-            }
-            else {
-                log_1.default.debug("mse", "could not update codec", {
-                    type: this.type,
-                    prevCodec: this.codec,
-                    newCodec: codec,
-                });
-            }
-        }
-        if (timestampOffset !== undefined &&
-            sourceBuffer.timestampOffset !== timestampOffset) {
-            var newTimestampOffset = timestampOffset;
-            log_1.default.debug("mse", "updating timestampOffset", {
-                type: this.type,
-                codec: codec,
-                prevTimestampOffset: sourceBuffer.timestampOffset,
-                newTimestampOffset: newTimestampOffset,
-            });
-            sourceBuffer.timestampOffset = newTimestampOffset;
-        }
-        if (appendWindow[0] === undefined) {
-            if (sourceBuffer.appendWindowStart > 0) {
-                log_1.default.debug("mse", "re-setting `appendWindowStart`", {
-                    type: this.type,
-                    prevWindowStart: sourceBuffer.appendWindowStart,
-                });
-                sourceBuffer.appendWindowStart = 0;
-            }
-        }
-        else if (appendWindow[0] !== sourceBuffer.appendWindowStart) {
-            if (appendWindow[0] >= sourceBuffer.appendWindowEnd) {
-                var newWindowEnd = appendWindow[0] + 1;
-                log_1.default.debug("mse", "pre-updating `appendWindowEnd`", {
-                    type: this.type,
-                    prevWindowEnd: sourceBuffer.appendWindowEnd,
-                    newWindowEnd: newWindowEnd,
-                });
-                sourceBuffer.appendWindowEnd = newWindowEnd;
-            }
-            log_1.default.debug("mse", "setting `appendWindowStart`", {
-                type: this.type,
-                appendWindowStart: appendWindow[0],
-            });
-            sourceBuffer.appendWindowStart = appendWindow[0];
-        }
-        if (appendWindow[1] === undefined) {
-            if (sourceBuffer.appendWindowEnd !== Infinity) {
-                log_1.default.debug("mse", "re-setting `appendWindowEnd`", {
-                    type: this.type,
-                    prevWindowStart: sourceBuffer.appendWindowStart,
+                if (timestampOffset !== undefined && sourceBuffer.timestampOffset !== timestampOffset) {
+                    var newTimestampOffset = timestampOffset;
+                    _log.default.debug("mse", "updating timestampOffset", {
+                        type: this.type,
+                        codec: codec,
+                        prevTimestampOffset: sourceBuffer.timestampOffset,
+                        newTimestampOffset: newTimestampOffset
+                    });
+                    sourceBuffer.timestampOffset = newTimestampOffset;
+                }
+                if (appendWindow[0] === undefined) {
+                    if (sourceBuffer.appendWindowStart > 0) {
+                        _log.default.debug("mse", "re-setting `appendWindowStart`", {
+                            type: this.type,
+                            prevWindowStart: sourceBuffer.appendWindowStart
+                        });
+                        sourceBuffer.appendWindowStart = 0;
+                    }
+                } else if (appendWindow[0] !== sourceBuffer.appendWindowStart) {
+                    if (appendWindow[0] >= sourceBuffer.appendWindowEnd) {
+                        var newWindowEnd = appendWindow[0] + 1;
+                        _log.default.debug("mse", "pre-updating `appendWindowEnd`", {
+                            type: this.type,
+                            prevWindowEnd: sourceBuffer.appendWindowEnd,
+                            newWindowEnd: newWindowEnd
+                        });
+                        sourceBuffer.appendWindowEnd = newWindowEnd;
+                    }
+                    _log.default.debug("mse", "setting `appendWindowStart`", {
+                        type: this.type,
+                        appendWindowStart: appendWindow[0]
+                    });
+                    sourceBuffer.appendWindowStart = appendWindow[0];
+                }
+                if (appendWindow[1] === undefined) {
+                    if (sourceBuffer.appendWindowEnd !== Infinity) {
+                        _log.default.debug("mse", "re-setting `appendWindowEnd`", {
+                            type: this.type,
+                            prevWindowStart: sourceBuffer.appendWindowStart
+                        });
+                        sourceBuffer.appendWindowEnd = Infinity;
+                    }
+                } else if (appendWindow[1] !== sourceBuffer.appendWindowEnd) {
+                    _log.default.debug("mse", "setting `appendWindowEnd`", {
+                        type: this.type,
+                        prevWindowEnd: sourceBuffer.appendWindowEnd,
+                        newWindowEnd: appendWindow[1]
+                    });
+                    sourceBuffer.appendWindowEnd = appendWindow[1];
+                }
+                _log.default.debug("mse", "pushing segment", {
+                    type: this.type
                 });
-                sourceBuffer.appendWindowEnd = Infinity;
+                sourceBuffer.appendBuffer(data);
             }
         }
-        else if (appendWindow[1] !== sourceBuffer.appendWindowEnd) {
-            log_1.default.debug("mse", "setting `appendWindowEnd`", {
-                type: this.type,
-                prevWindowEnd: sourceBuffer.appendWindowEnd,
-                newWindowEnd: appendWindow[1],
-            });
-            sourceBuffer.appendWindowEnd = appendWindow[1];
-        }
-        log_1.default.debug("mse", "pushing segment", { type: this.type });
-        sourceBuffer.appendBuffer(data);
-    };
+    ]);
     return MainSourceBufferInterface;
-}());
-exports.MainSourceBufferInterface = MainSourceBufferInterface;
+}();
 function resetMediaSource(mediaSource) {
     if (mediaSource.readyState !== "closed") {
         var readyState = mediaSource.readyState, sourceBuffers = mediaSource.sourceBuffers;
-        for (var i = sourceBuffers.length - 1; i >= 0; i--) {
+        for(var i = sourceBuffers.length - 1; i >= 0; i--){
             var sourceBuffer = sourceBuffers[i];
             try {
                 if (readyState === "open") {
-                    log_1.default.info("mse", "Aborting SourceBuffer before removing");
+                    _log.default.info("mse", "Aborting SourceBuffer before removing");
                     try {
                         sourceBuffer.abort();
-                    }
-                    catch (_) {
-                        // We actually don't care at all when resetting
+                    } catch (_) {
+                    // We actually don't care at all when resetting
                     }
                 }
-                log_1.default.info("mse", "Removing SourceBuffer from mediaSource");
+                _log.default.info("mse", "Removing SourceBuffer from mediaSource");
                 mediaSource.removeSourceBuffer(sourceBuffer);
-            }
-            catch (_) {
-                // We actually don't care at all when resetting
+            } catch (_) {
+            // We actually don't care at all when resetting
             }
         }
         if (sourceBuffers.length > 0) {
-            log_1.default.info("mse", "Not all SourceBuffers could have been removed.");
+            _log.default.info("mse", "Not all SourceBuffers could have been removed.");
         }
     }
 }