rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/commonjs/mse/utils/end_of_stream.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { CancellationSignal } from "../../utils/task_canceller";
+/**
+ * Trigger the `endOfStream` method of a MediaSource.
+ *
+ * If the MediaSource is ended/closed, do not call this method.
+ * If SourceBuffers are updating, wait for them to be updated before closing
+ * it.
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ */
+export default function triggerEndOfStream(mediaSource: MediaSource, cancelSignal: CancellationSignal): void;
+/**
+ * Trigger the `endOfStream` method of a MediaSource each times it opens.
+ * @see triggerEndOfStream
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ */
+export declare function maintainEndOfStream(mediaSource: MediaSource, cancelSignal: CancellationSignal): void;

package/dist/commonjs/mse/utils/end_of_stream.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maintainEndOfStream = void 0;
+var event_listeners_1 = require("../../compat/event_listeners");
+var log_1 = require("../../log");
+var task_canceller_1 = require("../../utils/task_canceller");
+/**
+ * Get "updating" SourceBuffers from a SourceBufferList.
+ * @param {SourceBufferList} sourceBuffers
+ * @returns {Array.<SourceBuffer>}
+ */
+function getUpdatingSourceBuffers(sourceBuffers) {
+    var updatingSourceBuffers = [];
+    for (var i = 0; i < sourceBuffers.length; i++) {
+        var SourceBuffer_1 = sourceBuffers[i];
+        if (SourceBuffer_1.updating) {
+            updatingSourceBuffers.push(SourceBuffer_1);
+        }
+    }
+    return updatingSourceBuffers;
+}
+/**
+ * Trigger the `endOfStream` method of a MediaSource.
+ *
+ * If the MediaSource is ended/closed, do not call this method.
+ * If SourceBuffers are updating, wait for them to be updated before closing
+ * it.
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ */
+function triggerEndOfStream(mediaSource, cancelSignal) {
+    var e_1, _a;
+    log_1.default.debug("Init: Trying to call endOfStream");
+    if (mediaSource.readyState !== "open") {
+        log_1.default.debug("Init: MediaSource not open, cancel endOfStream");
+        return;
+    }
+    var sourceBuffers = mediaSource.sourceBuffers;
+    var updatingSourceBuffers = getUpdatingSourceBuffers(sourceBuffers);
+    if (updatingSourceBuffers.length === 0) {
+        log_1.default.info("Init: Triggering end of stream");
+        mediaSource.endOfStream();
+        return;
+    }
+    log_1.default.debug("Init: Waiting SourceBuffers to be updated before calling endOfStream.");
+    var innerCanceller = new task_canceller_1.default();
+    innerCanceller.linkToSignal(cancelSignal);
+    try {
+        for (var updatingSourceBuffers_1 = __values(updatingSourceBuffers), updatingSourceBuffers_1_1 = updatingSourceBuffers_1.next(); !updatingSourceBuffers_1_1.done; updatingSourceBuffers_1_1 = updatingSourceBuffers_1.next()) {
+            var sourceBuffer = updatingSourceBuffers_1_1.value;
+            (0, event_listeners_1.onSourceBufferUpdate)(sourceBuffer, function () {
+                innerCanceller.cancel();
+                triggerEndOfStream(mediaSource, cancelSignal);
+            }, innerCanceller.signal);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (updatingSourceBuffers_1_1 && !updatingSourceBuffers_1_1.done && (_a = updatingSourceBuffers_1.return)) _a.call(updatingSourceBuffers_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    (0, event_listeners_1.onRemoveSourceBuffers)(sourceBuffers, function () {
+        innerCanceller.cancel();
+        triggerEndOfStream(mediaSource, cancelSignal);
+    }, innerCanceller.signal);
+}
+exports.default = triggerEndOfStream;
+/**
+ * Trigger the `endOfStream` method of a MediaSource each times it opens.
+ * @see triggerEndOfStream
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ */
+function maintainEndOfStream(mediaSource, cancelSignal) {
+    var endOfStreamCanceller = new task_canceller_1.default();
+    endOfStreamCanceller.linkToSignal(cancelSignal);
+    (0, event_listeners_1.onSourceOpen)(mediaSource, function () {
+        log_1.default.debug("Init: MediaSource re-opened while end-of-stream is active");
+        endOfStreamCanceller.cancel();
+        endOfStreamCanceller = new task_canceller_1.default();
+        endOfStreamCanceller.linkToSignal(cancelSignal);
+        triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
+    }, cancelSignal);
+    triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
+}
+exports.maintainEndOfStream = maintainEndOfStream;

package/dist/commonjs/mse/utils/media_source_duration_updater.js

@@ -0,0 +1,272 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var event_listeners_1 = require("../../compat/event_listeners");
+var has_issues_with_high_media_source_duration_1 = require("../../compat/has_issues_with_high_media_source_duration");
+var log_1 = require("../../log");
+var reference_1 = require("../../utils/reference");
+var task_canceller_1 = require("../../utils/task_canceller");
+/** Number of seconds in a regular year. */
+var YEAR_IN_SECONDS = 365 * 24 * 3600;
+/**
+ * Keep the MediaSource's `duration` attribute up-to-date with the duration of
+ * the content played on it.
+ * @class MediaSourceDurationUpdater
+ */
+var MediaSourceDurationUpdater = /** @class */ (function () {
+    /**
+     * Create a new `MediaSourceDurationUpdater`,
+     * @param {MediaSource} mediaSource - The MediaSource on which the content is
+     * played.
+     */
+    function MediaSourceDurationUpdater(mediaSource) {
+        this._mediaSource = mediaSource;
+        this._currentMediaSourceDurationUpdateCanceller = null;
+    }
+    /**
+     * Indicate to the `MediaSourceDurationUpdater` the currently known duration
+     * of the content.
+     *
+     * The `MediaSourceDurationUpdater` will then use that value to determine
+     * which `duration` attribute should be set on the `MediaSource` associated
+     *
+     * @param {number} newDuration
+     * @param {boolean} isRealEndKnown - If set to `false`, the current content is
+     * a dynamic content (it might evolve in the future) and the `newDuration`
+     * communicated might be greater still. In effect the
+     * `MediaSourceDurationUpdater` will actually set a much higher value to the
+     * `MediaSource`'s duration to prevent being annoyed by the HTML-related
+     * side-effects of having a too low duration (such as the impossibility to
+     * seek over that value).
+     */
+    MediaSourceDurationUpdater.prototype.updateDuration = function (newDuration, isRealEndKnown) {
+        if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+            this._currentMediaSourceDurationUpdateCanceller.cancel();
+        }
+        this._currentMediaSourceDurationUpdateCanceller = new task_canceller_1.default();
+        var mediaSource = this._mediaSource;
+        var currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
+        var isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, currentSignal);
+        /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
+        var msOpenStatusCanceller = new task_canceller_1.default();
+        msOpenStatusCanceller.linkToSignal(currentSignal);
+        isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, {
+            emitCurrentValue: true,
+            clearSignal: currentSignal,
+        });
+        function onMediaSourceOpenedStatusChanged() {
+            msOpenStatusCanceller.cancel();
+            if (!isMediaSourceOpened.getValue()) {
+                return;
+            }
+            msOpenStatusCanceller = new task_canceller_1.default();
+            msOpenStatusCanceller.linkToSignal(currentSignal);
+            var areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, msOpenStatusCanceller.signal);
+            /** TaskCanceller triggered each time SourceBuffers' updating status changes */
+            var sourceBuffersUpdatingCanceller = new task_canceller_1.default();
+            sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
+            return areSourceBuffersUpdating.onUpdate(function (areUpdating) {
+                sourceBuffersUpdatingCanceller.cancel();
+                sourceBuffersUpdatingCanceller = new task_canceller_1.default();
+                sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
+                if (areUpdating) {
+                    return;
+                }
+                recursivelyForceDurationUpdate(mediaSource, newDuration, isRealEndKnown, sourceBuffersUpdatingCanceller.signal);
+            }, { clearSignal: msOpenStatusCanceller.signal, emitCurrentValue: true });
+        }
+    };
+    /**
+     * Abort the last duration-setting operation and free its resources.
+     */
+    MediaSourceDurationUpdater.prototype.stopUpdating = function () {
+        if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+            this._currentMediaSourceDurationUpdateCanceller.cancel();
+            this._currentMediaSourceDurationUpdateCanceller = null;
+        }
+    };
+    return MediaSourceDurationUpdater;
+}());
+exports.default = MediaSourceDurationUpdater;
+/**
+ * Checks that duration can be updated on the MediaSource, and then
+ * sets it.
+ *
+ * Returns either:
+ *   - the new duration it has been updated to if it has
+ *   - `null` if it hasn'nt been updated
+ *
+ * @param {MediaSource} mediaSource
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
+ * @returns {string}
+ */
+function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
+    var newDuration = duration;
+    if (!isRealEndKnown) {
+        newDuration = (0, has_issues_with_high_media_source_duration_1.default)()
+            ? Infinity
+            : getMaximumLiveSeekablePosition(duration);
+    }
+    var maxBufferedEnd = 0;
+    for (var i = 0; i < mediaSource.sourceBuffers.length; i++) {
+        var sourceBuffer = mediaSource.sourceBuffers[i];
+        var sbBufferedLen = sourceBuffer.buffered.length;
+        if (sbBufferedLen > 0) {
+            maxBufferedEnd = Math.max(sourceBuffer.buffered.end(sbBufferedLen - 1));
+        }
+    }
+    if (newDuration === mediaSource.duration) {
+        return "success" /* MediaSourceDurationUpdateStatus.Success */;
+    }
+    else if (maxBufferedEnd > newDuration) {
+        // We already buffered further than the duration we want to set.
+        // Keep the duration that was set at that time as a security.
+        if (maxBufferedEnd < mediaSource.duration) {
+            try {
+                log_1.default.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
+                mediaSource.duration = maxBufferedEnd;
+            }
+            catch (err) {
+                log_1.default.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
+                return "failed" /* MediaSourceDurationUpdateStatus.Failed */;
+            }
+        }
+        return "partial" /* MediaSourceDurationUpdateStatus.Partial */;
+    }
+    else {
+        var oldDuration = mediaSource.duration;
+        try {
+            log_1.default.info("Init: Updating duration", newDuration);
+            mediaSource.duration = newDuration;
+            if (mediaSource.readyState === "open" && !isFinite(newDuration)) {
+                var maxSeekable = getMaximumLiveSeekablePosition(duration);
+                log_1.default.info("Init: calling `mediaSource.setLiveSeekableRange`", maxSeekable);
+                mediaSource.setLiveSeekableRange(0, maxSeekable);
+            }
+        }
+        catch (err) {
+            log_1.default.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
+            return "failed" /* MediaSourceDurationUpdateStatus.Failed */;
+        }
+        var deltaToExpected = Math.abs(mediaSource.duration - newDuration);
+        if (deltaToExpected >= 0.1) {
+            var deltaToBefore = Math.abs(mediaSource.duration - oldDuration);
+            return deltaToExpected < deltaToBefore
+                ? "partial" /* MediaSourceDurationUpdateStatus.Partial */
+                : "failed" /* MediaSourceDurationUpdateStatus.Failed */;
+        }
+        return "success" /* MediaSourceDurationUpdateStatus.Success */;
+    }
+}
+/**
+ * Returns a `SharedReference` wrapping a boolean that tells if all the
+ * SourceBuffers ended all pending updates.
+ * @param {SourceBufferList} sourceBuffers
+ * @param {Object} cancelSignal
+ * @returns {Object}
+ */
+function createSourceBuffersUpdatingReference(sourceBuffers, cancelSignal) {
+    if (sourceBuffers.length === 0) {
+        var notOpenedRef = new reference_1.default(false);
+        notOpenedRef.finish();
+        return notOpenedRef;
+    }
+    var areUpdatingRef = new reference_1.default(false, cancelSignal);
+    reCheck();
+    var _loop_1 = function (i) {
+        var sourceBuffer = sourceBuffers[i];
+        sourceBuffer.addEventListener("updatestart", reCheck);
+        sourceBuffer.addEventListener("update", reCheck);
+        cancelSignal.register(function () {
+            sourceBuffer.removeEventListener("updatestart", reCheck);
+            sourceBuffer.removeEventListener("update", reCheck);
+        });
+    };
+    for (var i = 0; i < sourceBuffers.length; i++) {
+        _loop_1(i);
+    }
+    return areUpdatingRef;
+    function reCheck() {
+        for (var i = 0; i < sourceBuffers.length; i++) {
+            var sourceBuffer = sourceBuffers[i];
+            if (sourceBuffer.updating) {
+                areUpdatingRef.setValueIfChanged(true);
+                return;
+            }
+        }
+        areUpdatingRef.setValueIfChanged(false);
+    }
+}
+/**
+ * Returns a `SharedReference` wrapping a boolean that tells if the media
+ * source is opened or not.
+ * @param {MediaSource} mediaSource
+ * @param {Object} cancelSignal
+ * @returns {Object}
+ */
+function createMediaSourceOpenReference(mediaSource, cancelSignal) {
+    var isMediaSourceOpen = new reference_1.default(mediaSource.readyState === "open", cancelSignal);
+    (0, event_listeners_1.onSourceOpen)(mediaSource, function () {
+        log_1.default.debug("Init: Reacting to MediaSource open in duration updater");
+        isMediaSourceOpen.setValueIfChanged(true);
+    }, cancelSignal);
+    (0, event_listeners_1.onSourceEnded)(mediaSource, function () {
+        log_1.default.debug("Init: Reacting to MediaSource ended in duration updater");
+        isMediaSourceOpen.setValueIfChanged(false);
+    }, cancelSignal);
+    (0, event_listeners_1.onSourceClose)(mediaSource, function () {
+        log_1.default.debug("Init: Reacting to MediaSource close in duration updater");
+        isMediaSourceOpen.setValueIfChanged(false);
+    }, cancelSignal);
+    return isMediaSourceOpen;
+}
+/**
+ * Immediately tries to set the MediaSource's duration to the most appropriate
+ * one.
+ *
+ * If it fails, wait 2 seconds and retries.
+ *
+ * @param {MediaSource} mediaSource
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
+ * @param {Object} cancelSignal
+ */
+function recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal) {
+    var res = setMediaSourceDuration(mediaSource, duration, isRealEndKnown);
+    if (res === "success" /* MediaSourceDurationUpdateStatus.Success */) {
+        return;
+    }
+    var timeoutId = setTimeout(function () {
+        unregisterClear();
+        recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal);
+    }, 2000);
+    var unregisterClear = cancelSignal.register(function () {
+        clearTimeout(timeoutId);
+    });
+}
+function getMaximumLiveSeekablePosition(contentLastPosition) {
+    // Some targets poorly support setting a very high number for seekable
+    // ranges.
+    // Yet, in contents whose end is not yet known (e.g. live contents), we
+    // would prefer setting a value as high as possible to still be able to
+    // seek anywhere we want to (even ahead of the Manifest if we want to).
+    // As such, we put it at a safe default value of 2^32 excepted when the
+    // maximum position is already relatively close to that value, where we
+    // authorize exceptionally going over it.
+    return Math.max(Math.pow(2, 32), contentLastPosition + YEAR_IN_SECONDS);
+}

package/dist/commonjs/mse/worker_codec_support_prober.d.ts

@@ -1,4 +1,4 @@
-import { ICodecSupportProber } from "./types";
+import type { ICodecSupportProber } from "./types";
 /**
  * Class allowing to check for mimeType + codec support in a WebWorker
  * environment where MSE API are not available.

package/dist/commonjs/mse/worker_media_source_interface.d.ts

@@ -1,10 +1,10 @@
 import { SourceBufferError } from "../errors";
-import { ISerializedSourceBufferError } from "../errors/source_buffer_error";
-import { IAbortBufferWorkerMessage, IAddSourceBufferWorkerMessage, IAppendBufferWorkerMessage, ICreateMediaSourceWorkerMessage, IDisposeMediaSourceWorkerMessage, IEndOfStreamWorkerMessage, IInterruptMediaSourceDurationWorkerMessage, IRemoveBufferWorkerMessage, IStopEndOfStreamWorkerMessage, IUpdateMediaSourceDurationWorkerMessage } from "../multithread_types";
+import type { ISerializedSourceBufferError } from "../errors/source_buffer_error";
+import type { IAbortBufferWorkerMessage, IAddSourceBufferWorkerMessage, IAppendBufferWorkerMessage, ICreateMediaSourceWorkerMessage, IDisposeMediaSourceWorkerMessage, IEndOfStreamWorkerMessage, IInterruptMediaSourceDurationWorkerMessage, IRemoveBufferWorkerMessage, IStopEndOfStreamWorkerMessage, IUpdateMediaSourceDurationWorkerMessage } from "../multithread_types";
 import EventEmitter from "../utils/event_emitter";
-import { IRange } from "../utils/ranges";
+import type { IRange } from "../utils/ranges";
 import { CancellationError } from "../utils/task_canceller";
-import { IMediaSourceInterface, IMediaSourceInterfaceEvents, ISourceBufferInterface, ISourceBufferInterfaceAppendBufferParameters, SourceBufferType } from "./types";
+import type { IMediaSourceInterface, IMediaSourceInterfaceEvents, ISourceBufferInterface, ISourceBufferInterfaceAppendBufferParameters, SourceBufferType } from "./types";
 /**
  * Interface to the MediaSource browser APIs of the Media Source Extentions for
  * a WebWorker environment where MSE API are not available (if MSE API are

package/dist/commonjs/mse/worker_media_source_interface.js

@@ -180,9 +180,9 @@ var WorkerSourceBufferInterface = /** @class */ (function () {
     };
     WorkerSourceBufferInterface.prototype.onOperationFailure = function (operationId, error) {
         var e_1, _a;
-        var formattedErr = error.errorName === "CancellationError" ?
-            new task_canceller_1.CancellationError() :
-            new errors_1.SourceBufferError(error.errorName, error.message, error.isBufferFull);
+        var formattedErr = error.errorName === "CancellationError"
+            ? new task_canceller_1.CancellationError()
+            : new errors_1.SourceBufferError(error.errorName, error.message, error.isBufferFull);
         var mapElt = this._pendingOperations.get(operationId);
         if (mapElt === undefined) {
             log_1.default.info("SBI: unknown SourceBuffer operation failed", formattedErr);
@@ -221,15 +221,15 @@ var WorkerSourceBufferInterface = /** @class */ (function () {
                 return;
             }
             try {
-                var segmentBufferPushed = void 0;
+                var segmentSinkPushed = void 0;
                 if (data instanceof ArrayBuffer) {
-                    segmentBufferPushed = data;
+                    segmentSinkPushed = data;
                 }
                 else if (data.byteLength === data.buffer.byteLength) {
-                    segmentBufferPushed = data.buffer;
+                    segmentSinkPushed = data.buffer;
                 }
                 else {
-                    segmentBufferPushed = data.buffer.slice(data.byteOffset, data.byteLength + data.byteOffset);
+                    segmentSinkPushed = data.buffer.slice(data.byteOffset, data.byteLength + data.byteOffset);
                 }
                 var operationId = generateSourceBufferOperationId();
                 _this._messageSender({
@@ -238,10 +238,10 @@ var WorkerSourceBufferInterface = /** @class */ (function () {
                     sourceBufferType: _this.type,
                     operationId: operationId,
                     value: {
-                        data: segmentBufferPushed,
+                        data: segmentSinkPushed,
                         params: params,
                     },
-                }, [segmentBufferPushed]);
+                }, [segmentSinkPushed]);
                 _this._addOperationToQueue(operationId, resolve, reject);
             }
             catch (err) {
@@ -298,8 +298,10 @@ var WorkerSourceBufferInterface = /** @class */ (function () {
     };
     WorkerSourceBufferInterface.prototype._addOperationToQueue = function (operationId, resolve, reject) {
         var _this = this;
-        this._pendingOperations.set(operationId, { resolve: onResolve,
-            reject: onReject });
+        this._pendingOperations.set(operationId, {
+            resolve: onResolve,
+            reject: onReject,
+        });
         var unbindCanceller = this._canceller.signal.register(function (error) {
             _this._pendingOperations.delete(operationId);
             reject(error);
@@ -319,15 +321,15 @@ var WorkerSourceBufferInterface = /** @class */ (function () {
             try {
                 if (nextOp.operationName === 0 /* SbiOperationName.Push */) {
                     var _a = __read(nextOp.params, 2), data = _a[0], params = _a[1];
-                    var segmentBufferPushed = void 0;
+                    var segmentSinkPushed = void 0;
                     if (data instanceof ArrayBuffer) {
-                        segmentBufferPushed = data;
+                        segmentSinkPushed = data;
                     }
                     else if (data.byteLength === data.buffer.byteLength) {
-                        segmentBufferPushed = data.buffer;
+                        segmentSinkPushed = data.buffer;
                     }
                     else {
-                        segmentBufferPushed = data.buffer.slice(data.byteOffset, data.byteLength + data.byteOffset);
+                        segmentSinkPushed = data.buffer.slice(data.byteOffset, data.byteLength + data.byteOffset);
                     }
                     var nOpId = generateSourceBufferOperationId();
                     this._messageSender({
@@ -336,10 +338,10 @@ var WorkerSourceBufferInterface = /** @class */ (function () {
                         sourceBufferType: this.type,
                         operationId: nOpId,
                         value: {
-                            data: segmentBufferPushed,
+                            data: segmentSinkPushed,
                             params: params,
                         },
-                    }, [segmentBufferPushed]);
+                    }, [segmentSinkPushed]);
                     this._addOperationToQueue(nOpId, nextOp.resolve, nextOp.reject);
                 }
                 else {

package/dist/commonjs/multithread_types.d.ts

@@ -3,20 +3,17 @@
  * RxPlayer in a
  * multithread situation.
  */
-import { IResolutionInfo } from "./core/adaptive/utils/filter_by_resolution";
-import { IFreezingStatus, IRebufferingStatus } from "./core/api";
-import { IContentProtection } from "./core/decrypt";
-import { IManifestFetcherSettings, ISegmentFetcherCreatorBackoffOptions } from "./core/fetchers";
-import { IInbandEvent, IPausedPlaybackObservation, IRepresentationsChoice, ITrackSwitchingMode } from "./core/stream";
-import { ISerializedMediaError, ISerializedNetworkError, ISerializedEncryptedMediaError, ISerializedOtherError } from "./errors";
-import { ISerializedSourceBufferError } from "./errors/source_buffer_error";
-import { IManifestMetadata, IPeriodsUpdateResult } from "./manifest";
-import { ISourceBufferInterfaceAppendBufferParameters, SourceBufferType } from "./mse";
-import { ITrackType } from "./public_types";
-import { ITextDisplayerData } from "./text_displayer";
-import { ITransportOptions } from "./transports";
-import { ILoggerLevel } from "./utils/logger";
-import { IRange } from "./utils/ranges";
+import type { IResolutionInfo, IManifestFetcherSettings, ISegmentFetcherCreatorBackoffOptions, IInbandEvent, IPausedPlaybackObservation, IRepresentationsChoice, ITrackSwitchingMode } from "./core/types";
+import type { ISerializedMediaError, ISerializedNetworkError, ISerializedEncryptedMediaError, ISerializedOtherError } from "./errors";
+import type { ISerializedSourceBufferError } from "./errors/source_buffer_error";
+import type { IContentProtection, ITextDisplayerData } from "./main_thread/types";
+import type { IManifestMetadata, IPeriodsUpdateResult } from "./manifest";
+import type { ISourceBufferInterfaceAppendBufferParameters, SourceBufferType } from "./mse";
+import type { IFreezingStatus, IRebufferingStatus } from "./playback_observer";
+import type { ITrackType } from "./public_types";
+import type { ITransportOptions } from "./transports";
+import type { ILoggerLevel } from "./utils/logger";
+import type { IRange } from "./utils/ranges";
 /**
  * First message sent by the main thread to the WebWorker.
  * A WebWorker should only receive one `IInitMessage` at most and it should be
@@ -28,7 +25,7 @@ export interface IInitMessage {
     type: MainThreadMessageType.Init;
     value: {
         /** Link to the DASH_WASM's feature WebAssembly file to parse DASH MPDs. */
-        dashWasmUrl: string;
+        dashWasmUrl: string | undefined;
         /**
          * If `true` the final element on the current page displaying the content
          * can display video content.
@@ -166,7 +163,7 @@ export interface IStartPreparedContentMessageValue {
     /** The start time at which we should play, in seconds. */
     initialTime: number;
     /** The current playback observation. */
-    initialObservation: IWorkerPlaybackObservation;
+    initialObservation: ISerializedPlaybackObservation;
     /**
      * Hex-encoded string identifying the key system used.
      * May be cross-referenced with the content's metadata when performing
@@ -216,7 +213,7 @@ export interface IPlaybackObservationMessage {
      */
     contentId: string;
     /** The media-related metadata that has just been observed now. */
-    value: IWorkerPlaybackObservation;
+    value: ISerializedPlaybackObservation;
 }
 /**
  * Message sent by the main thread when at least one of the `Representation` of
@@ -308,7 +305,7 @@ export interface IRepresentationUpdateMessage {
     };
 }
 /** Media-related metadata. */
-export interface IWorkerPlaybackObservation {
+export interface ISerializedPlaybackObservation {
     /**
      * Information on whether the media element was paused at the time of the
      * Observation.

package/dist/commonjs/parsers/containers/isobmff/create_box.d.ts

@@ -27,4 +27,4 @@ declare function createBox(name: string, buff: Uint8Array): Uint8Array;
  * @returns {Uint8Array}
  */
 declare function createBoxWithChildren(name: string, children: Uint8Array[]): Uint8Array;
-export { createBox, createBoxWithChildren, };
+export { createBox, createBoxWithChildren };

package/dist/commonjs/parsers/containers/isobmff/create_box.js

@@ -62,7 +62,7 @@ var boxNamesMem = {};
  * @returns {Uint8Array}
  */
 function boxName(str) {
-    if (boxNamesMem[str] != null) {
+    if (boxNamesMem[str] !== undefined) {
         return boxNamesMem[str];
     }
     var nameInBytes = (0, string_parsing_1.strToUtf8)(str);
@@ -78,8 +78,9 @@ function boxName(str) {
  */
 function createBox(name, buff) {
     var len = buff.length + 8;
-    return len <= constants_1.MAX_32_BIT_INT ? (0, byte_parsing_1.concat)((0, byte_parsing_1.itobe4)(len), boxName(name), buff) :
-        (0, byte_parsing_1.concat)((0, byte_parsing_1.itobe4)(1), boxName(name), (0, byte_parsing_1.itobe8)(len + 8), buff);
+    return len <= constants_1.MAX_32_BIT_INT
+        ? (0, byte_parsing_1.concat)((0, byte_parsing_1.itobe4)(len), boxName(name), buff)
+        : (0, byte_parsing_1.concat)((0, byte_parsing_1.itobe4)(1), boxName(name), (0, byte_parsing_1.itobe8)(len + 8), buff);
 }
 exports.createBox = createBox;
 /**

package/dist/commonjs/parsers/containers/isobmff/drm/playready.js

@@ -32,8 +32,7 @@ function getPlayReadyKIDFromPrivateData(data) {
     if (kidElement === null) {
         throw new Error("Cannot parse PlayReady private data: invalid XML");
     }
-    var b64guidKid = kidElement.textContent === null ? "" :
-        kidElement.textContent;
+    var b64guidKid = kidElement.textContent === null ? "" : kidElement.textContent;
     var uuidKid = (0, string_parsing_1.guidToUuid)((0, base64_1.base64ToBytes)(b64guidKid));
     return (0, string_parsing_1.bytesToHex)(uuidKid).toLowerCase();
 }