rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/commonjs/importable_worker.js

@@ -0,0 +1,159 @@
+"use strict";
+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.");
+};
+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;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    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];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var features_1 = require("./features");
+var initialize_worker_1 = require("./initialize_worker");
+var log_1 = require("./log");
+var global_scope_1 = require("./utils/global_scope");
+var isInitialized = false;
+var RxPlayerWorker = /** @class */ (function () {
+    function RxPlayerWorker() {
+        var _this = this;
+        if (isInitialized) {
+            throw new Error("You can create only one RxPlayerWorker at most");
+        }
+        this._representationFiltersMap = new Map();
+        this._segmentLoadersMap = new Map();
+        this._manifestLoadersMap = new Map();
+        isInitialized = true;
+        this._messageListeners = new Map();
+        global_scope_1.default.addEventListener("message", function (evt) {
+            var e_1, _a;
+            if (evt.data.type === "app-defined" /* MainThreadMessageType.AppDefined */) {
+                var _b = evt.data.value, name_1 = _b.name, payload = _b.payload;
+                var listeners = _this._messageListeners.get(name_1);
+                if (listeners === undefined) {
+                    return;
+                }
+                try {
+                    for (var _c = __values(listeners.slice()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var listener = _d.value;
+                        try {
+                            listener(payload);
+                        }
+                        catch (err) {
+                            log_1.default.error("Core", "A message listener failed with an error:", err instanceof Error ? err : "Unknown Error");
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+        });
+        (0, initialize_worker_1.default)({
+            representationFilters: this._representationFiltersMap,
+            segmentLoaders: this._segmentLoadersMap,
+            manifestLoaders: this._manifestLoadersMap,
+        });
+    }
+    /**
+     * Add feature(s) to the RxPlayer.
+     * @param {Array.<Object>} featureList - Features wanted.
+     */
+    RxPlayerWorker.addFeatures = function (featureList) {
+        (0, features_1.addFeatures)(featureList);
+    };
+    RxPlayerWorker.prototype.registerRepresentationFilter = function (identifier, implem) {
+        if (implem === null) {
+            this._representationFiltersMap.delete(identifier);
+            return;
+        }
+        this._representationFiltersMap.set(identifier, implem);
+    };
+    RxPlayerWorker.prototype.registerSegmentLoader = function (identifier, implem) {
+        if (implem === null) {
+            this._segmentLoadersMap.delete(identifier);
+            return;
+        }
+        this._segmentLoadersMap.set(identifier, implem);
+    };
+    RxPlayerWorker.prototype.registerManifestLoader = function (identifier, implem) {
+        if (implem === null) {
+            this._manifestLoadersMap.delete(identifier);
+            return;
+        }
+        this._manifestLoadersMap.set(identifier, implem);
+    };
+    RxPlayerWorker.prototype.addMessageListener = function (messageName, callback) {
+        var prev = this._messageListeners.get(messageName);
+        /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument */
+        // FIXME: I am not 100% certain why TypeScript is complaining here.
+        if (prev === undefined) {
+            this._messageListeners.set(messageName, [callback]);
+        }
+        else {
+            this._messageListeners.set(messageName, __spreadArray(__spreadArray([], __read(prev), false), [callback], false));
+        }
+        /* eslint-enable @typescript-eslint/no-explicit-any */
+    };
+    RxPlayerWorker.prototype.removeMessageListener = function (messageName, callback) {
+        var prev = this._messageListeners.get(messageName);
+        if (prev === undefined) {
+            return;
+        }
+        while (true) {
+            // FIXME: I am not 100% certain why TypeScript is complaining here.
+            /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+            var indexOf = prev.indexOf(callback);
+            if (indexOf < 0) {
+                return;
+            }
+            prev.splice(indexOf, 1);
+            if (prev.length === 0) {
+                this._messageListeners.delete(messageName);
+                return;
+            }
+        }
+    };
+    RxPlayerWorker.prototype.sendMessage = function (messageName, payload) {
+        global_scope_1.default.postMessage({
+            type: "app-defined" /* CoreMessageType.AppDefined */,
+            value: {
+                name: messageName,
+                payload: payload,
+            },
+        });
+    };
+    return RxPlayerWorker;
+}());
+exports.default = RxPlayerWorker;

package/dist/commonjs/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 Player from "./main_thread/api";
+export default Player;
+//# sourceMappingURL=index.d.ts.map

package/dist/commonjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAsBH,OAAO,MAAM,MAAM,mBAAmB,CAAC;AAmBvC,eAAe,MAAM,CAAC"}

package/dist/commonjs/index.js

@@ -0,0 +1,44 @@
+"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 });
+/**
+ * This file exports a Player class with a default feature set.
+ * This is the class used from a regular build.
+ */
+var patch_webkit_source_buffer_1 = require("./compat/patch_webkit_source_buffer");
+var list_1 = require("./features/list");
+var api_1 = require("./main_thread/api");
+var global_scope_1 = require("./utils/global_scope");
+(0, patch_webkit_source_buffer_1.default)();
+api_1.default.addFeatures([
+    list_1.SMOOTH,
+    list_1.DASH,
+    list_1.DIRECTFILE,
+    list_1.EME,
+    list_1.NATIVE_TTML_PARSER,
+    list_1.NATIVE_SAMI_PARSER,
+    list_1.NATIVE_VTT_PARSER,
+    list_1.NATIVE_SRT_PARSER,
+    list_1.HTML_TTML_PARSER,
+    list_1.HTML_SAMI_PARSER,
+    list_1.HTML_VTT_PARSER,
+    list_1.HTML_SRT_PARSER,
+]);
+exports.default = api_1.default;
+if (typeof __GLOBAL_SCOPE__ === "boolean" && __GLOBAL_SCOPE__) {
+    global_scope_1.default.RxPlayer = api_1.default;
+}

package/dist/commonjs/initialize_worker.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is the entry point of the default "RxPlayer Worker".
+ * It is only relied on when running in a multithread mode.
+ *
+ * Note that the application can also define its own "RxPlayer worker" in which
+ * case this file is not depended on.
+ */
+import type { ICorePlugins } from "./core/entry";
+export default function initializeWorker(corePlugins: ICorePlugins): void;
+//# sourceMappingURL=initialize_worker.d.ts.map

package/dist/commonjs/initialize_worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize_worker.d.ts","sourceRoot":"","sources":["../../src/initialize_worker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAWjD,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,WAAW,EAAE,YAAY,GAAG,IAAI,CAiBxE"}

package/dist/commonjs/initialize_worker.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * This file is the entry point of the default "RxPlayer Worker".
+ * It is only relied on when running in a multithread mode.
+ *
+ * Note that the application can also define its own "RxPlayer worker" in which
+ * case this file is not depended on.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = initializeWorker;
+var entry_1 = require("./core/entry");
+var log_1 = require("./experimental/tools/mediaCapabilitiesProber/log");
+var features_1 = require("./features");
+var classes_1 = require("./manifest/classes");
+var js_parser_1 = require("./parsers/manifest/dash/js-parser");
+var wasm_parser_1 = require("./parsers/manifest/dash/wasm-parser");
+var dash_1 = require("./transports/dash");
+var global_scope_1 = require("./utils/global_scope");
+function initializeWorker(corePlugins) {
+    // Initialize Manually a `DashWasmParser` and add the feature.
+    var dashWasmParser = new wasm_parser_1.default();
+    features_1.default.dashParsers.wasm = dashWasmParser;
+    features_1.default.dashParsers.js = js_parser_1.default;
+    features_1.default.transports.dash = dash_1.default;
+    global_scope_1.default.onmessageerror = function (_msg) {
+        log_1.default.error("Core", "Error when receiving message from main thread.");
+    };
+    (0, entry_1.default)(function (handler) {
+        onmessage = handler;
+    }, sendMessage, corePlugins);
+}
+/**
+ * Perform a `postMessage` to main thread with the given message.
+ * Arguments follow the `postMessage` API.
+ * @param {Object} msg
+ * @param {Array.<Object>} [transferables]
+ */
+function sendMessage(msg, transferables) {
+    updateMessageFormat(msg);
+    if (msg.type !== "log" /* CoreMessageType.LogMessage */) {
+        log_1.default.debug("M<--C", "Sending message from worker", { name: msg.type });
+    }
+    if (transferables === undefined) {
+        postMessage(msg);
+    }
+    else {
+        // TypeScript made a mistake here, and 2busy2fix
+        postMessage(msg, transferables);
+    }
+}
+/**
+ * Ensure that we're sending data that can be serialized, as this is a
+ * requirement for the `postMessage` browser API.
+ *
+ * If necessary, mutations are done in place.
+ * @param {Object} msg
+ */
+function updateMessageFormat(msg) {
+    if (msg.type === "manifest-ready" /* CoreMessageType.ManifestReady */ ||
+        msg.type === "manifest-update" /* CoreMessageType.ManifestUpdate */) {
+        if (msg.value.manifest instanceof classes_1.default) {
+            msg.value.manifest = msg.value.manifest.getMetadataSnapshot();
+            if (msg.type === "manifest-update" /* CoreMessageType.ManifestUpdate */) {
+                // Remove `periods` key to reduce cost of an unnecessary manifest
+                // clone.
+                msg.value.manifest.periods = [];
+            }
+        }
+        else {
+            log_1.default.warn("Core", "the Manifest instance should be communicated to `sendMessage`.");
+        }
+    }
+}

package/dist/commonjs/log.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 Logger from "./utils/logger";
+declare const logger: Logger;
+export default logger;
+//# sourceMappingURL=log.d.ts.map

package/dist/commonjs/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../src/log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,MAAM,MAAM,gBAAgB,CAAC;AAGpC,QAAA,MAAM,MAAM,QAAe,CAAC;AAE5B,eAAe,MAAM,CAAC"}

package/dist/commonjs/log.js

@@ -0,0 +1,21 @@
+"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 logger_1 = require("./utils/logger");
+// create a logger specifically for the RxPlayer.
+var logger = new logger_1.default();
+exports.default = logger;

package/dist/commonjs/main_thread/api/debug/buffer_graph.d.ts

@@ -0,0 +1,29 @@
+import type { IBufferedChunkSnapshot } from "../../../core/segment_sinks/segment_sinks_store";
+export interface ISegmentSinkGrapUpdateData {
+    currentTime: number;
+    inventory: IBufferedChunkSnapshot[];
+    width: number;
+    height: number;
+    minimumPosition: number | undefined;
+    maximumPosition: number | undefined;
+}
+export default class SegmentSinkGraph {
+    /** Link buffered Representation's uniqueId to their corresponding color. */
+    private readonly _colorMap;
+    /** Current amount of colors chosen to represent the various Representation. */
+    private _currNbColors;
+    /** Canvas that will contain the buffer graph itself. */
+    private readonly _canvasElt;
+    private readonly _canvasCtxt;
+    constructor(canvasElt: HTMLCanvasElement);
+    clear(): void;
+    update(data: ISegmentSinkGrapUpdateData): void;
+    /**
+     * Paint a given range in the canvas
+     * @param {Object} rangeScaled - Buffered segment information with added
+     * "scaling" information to know where it fits in the canvas.
+     */
+    private _paintRange;
+    private _getColorForRepresentation;
+}
+//# sourceMappingURL=buffer_graph.d.ts.map

package/dist/commonjs/main_thread/api/debug/buffer_graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_graph.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/api/debug/buffer_graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iDAAiD,CAAC;AAmB9F,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,sBAAsB,EAAE,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAEhD,+EAA+E;IAC/E,OAAO,CAAC,aAAa,CAAS;IAE9B,wDAAwD;IACxD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAE/C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkC;gBAElD,SAAS,EAAE,iBAAiB;IAQjC,KAAK;IAML,MAAM,CAAC,IAAI,EAAE,0BAA0B,GAAG,IAAI;IA6FrD;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,0BAA0B;CAUnC"}

package/dist/commonjs/main_thread/api/debug/buffer_graph.js

@@ -0,0 +1,213 @@
+"use strict";
+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 });
+var BUFFER_WIDTH_IN_SECONDS = 30 * 60;
+var COLORS = [
+    "#2ab7ca",
+    "#fed766",
+    "#4dd248",
+    "#a22c28",
+    "#556b2f", // darkolivegreen
+    "#add8e6", // lightblue
+    "#90ee90", // lightgreen
+    "#444444",
+    "#40bfc1",
+    "#57557e",
+    "#fbe555",
+];
+var SegmentSinkGraph = /** @class */ (function () {
+    function SegmentSinkGraph(canvasElt) {
+        this._colorMap = new Map();
+        this._currNbColors = 0;
+        this._canvasElt = canvasElt;
+        this._canvasCtxt = this._canvasElt.getContext("2d");
+        this.clear();
+    }
+    SegmentSinkGraph.prototype.clear = function () {
+        if (this._canvasCtxt !== null) {
+            this._canvasCtxt.clearRect(0, 0, this._canvasElt.width, this._canvasElt.height);
+        }
+    };
+    SegmentSinkGraph.prototype.update = function (data) {
+        var e_1, _a;
+        var _this = this;
+        var _b, _c, _d, _e;
+        // Following logic clear the colorMap entries if they are not used anymore
+        // to prevent memory usage.
+        var representationStillInUse = new Set();
+        data.inventory.forEach(function (chunk) {
+            representationStillInUse.add(chunk.infos.representation.uniqueId);
+        });
+        this._colorMap.forEach(function (representationId) {
+            if (!representationStillInUse.has(representationId)) {
+                _this._colorMap.delete(representationId);
+            }
+        });
+        if (this._canvasCtxt === null) {
+            return;
+        }
+        var inventory = data.inventory, currentTime = data.currentTime, width = data.width, height = data.height;
+        this._canvasElt.style.width = "".concat(width, "px");
+        this._canvasElt.style.height = "".concat(height, "px");
+        this._canvasElt.width = width;
+        this._canvasElt.height = height;
+        this.clear();
+        var minimumPoint;
+        if (data.minimumPosition !== undefined) {
+            if (inventory.length > 0) {
+                minimumPoint = Math.min(data.minimumPosition, inventory[0].start);
+            }
+            else {
+                minimumPoint = data.minimumPosition;
+            }
+        }
+        else {
+            minimumPoint = (_c = (_b = inventory[0]) === null || _b === void 0 ? void 0 : _b.start) !== null && _c !== void 0 ? _c : 0;
+        }
+        var maximumPoint;
+        if (data.maximumPosition !== undefined) {
+            if (inventory.length > 0) {
+                maximumPoint = Math.max(data.maximumPosition, inventory[inventory.length - 1].end);
+            }
+            else {
+                maximumPoint = data.maximumPosition;
+            }
+        }
+        else {
+            maximumPoint = (_e = (_d = inventory[inventory.length - 1]) === null || _d === void 0 ? void 0 : _d.end) !== null && _e !== void 0 ? _e : 1000;
+        }
+        minimumPoint = Math.min(currentTime, minimumPoint);
+        maximumPoint = Math.max(currentTime, maximumPoint);
+        var minimumPosition;
+        var maximumPosition;
+        if (maximumPoint - minimumPoint > BUFFER_WIDTH_IN_SECONDS) {
+            if (maximumPoint - currentTime < BUFFER_WIDTH_IN_SECONDS / 2) {
+                maximumPosition = maximumPoint;
+                minimumPosition = maximumPoint - BUFFER_WIDTH_IN_SECONDS;
+            }
+            else if (currentTime - minimumPoint < BUFFER_WIDTH_IN_SECONDS / 2) {
+                minimumPosition = minimumPoint;
+                maximumPosition = minimumPoint + BUFFER_WIDTH_IN_SECONDS;
+            }
+            else {
+                minimumPosition = currentTime - BUFFER_WIDTH_IN_SECONDS / 2;
+                maximumPosition = currentTime + BUFFER_WIDTH_IN_SECONDS / 2;
+            }
+        }
+        else {
+            minimumPosition = minimumPoint;
+            maximumPosition = maximumPoint;
+        }
+        if (minimumPosition >= maximumPosition) {
+            this.clear();
+            return;
+        }
+        var currentRangesScaled = scaleSegments(inventory, minimumPosition, maximumPosition);
+        try {
+            for (var currentRangesScaled_1 = __values(currentRangesScaled), currentRangesScaled_1_1 = currentRangesScaled_1.next(); !currentRangesScaled_1_1.done; currentRangesScaled_1_1 = currentRangesScaled_1.next()) {
+                var currentRange = currentRangesScaled_1_1.value;
+                this._paintRange(currentRange, width, height);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (currentRangesScaled_1_1 && !currentRangesScaled_1_1.done && (_a = currentRangesScaled_1.return)) _a.call(currentRangesScaled_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (currentTime !== undefined) {
+            paintCurrentPosition(currentTime, minimumPosition, maximumPosition, this._canvasCtxt, width, height);
+        }
+    };
+    /**
+     * Paint a given range in the canvas
+     * @param {Object} rangeScaled - Buffered segment information with added
+     * "scaling" information to know where it fits in the canvas.
+     */
+    SegmentSinkGraph.prototype._paintRange = function (rangeScaled, width, height) {
+        if (this._canvasCtxt === null) {
+            return;
+        }
+        var startX = rangeScaled.scaledStart * width;
+        var endX = rangeScaled.scaledEnd * width;
+        this._canvasCtxt.fillStyle = this._getColorForRepresentation(rangeScaled.info.infos.representation);
+        this._canvasCtxt.fillRect(Math.ceil(startX), 0, Math.ceil(endX - startX), height);
+    };
+    SegmentSinkGraph.prototype._getColorForRepresentation = function (representation) {
+        var color = this._colorMap.get(representation.uniqueId);
+        if (color !== undefined) {
+            return color;
+        }
+        var newColor = COLORS[this._currNbColors % COLORS.length];
+        this._currNbColors++;
+        this._colorMap.set(representation.uniqueId, newColor);
+        return newColor;
+    };
+    return SegmentSinkGraph;
+}());
+exports.default = SegmentSinkGraph;
+/**
+ * Represent the current position in the canvas.
+ * @param {number|undefined} position - The current position
+ * @param {number} minimumPosition - minimum possible position represented in
+ * the canvas.
+ * @param {number} maximumPosition - maximum possible position represented in
+ * the canvas.
+ * @param {Object} canvasCtx - The canvas' 2D context
+ */
+function paintCurrentPosition(position, minimumPosition, maximumPosition, canvasCtx, width, height) {
+    if (typeof position === "number" &&
+        position >= minimumPosition &&
+        position < maximumPosition) {
+        var lengthCanvas = maximumPosition - minimumPosition;
+        canvasCtx.fillStyle = "#FF0000";
+        canvasCtx.fillRect(Math.ceil(((position - minimumPosition) / lengthCanvas) * width) - 1, 5, 5, height);
+    }
+}
+/**
+ * Scale given bufferedData in terms of percentage between the minimum and
+ * maximum position. Filter out ranges which are not part of it.
+ * @param {Array.<Object>} bufferedData
+ * @param {number} minimumPosition
+ * @param {number} maximumPosition
+ * @returns {Array.<Object>}
+ */
+function scaleSegments(bufferedData, minimumPosition, maximumPosition) {
+    var e_2, _a;
+    var _b, _c;
+    var scaledSegments = [];
+    var wholeDuration = maximumPosition - minimumPosition;
+    try {
+        for (var bufferedData_1 = __values(bufferedData), bufferedData_1_1 = bufferedData_1.next(); !bufferedData_1_1.done; bufferedData_1_1 = bufferedData_1.next()) {
+            var info = bufferedData_1_1.value;
+            var start = (_b = info.bufferedStart) !== null && _b !== void 0 ? _b : info.start;
+            var end = (_c = info.bufferedEnd) !== null && _c !== void 0 ? _c : info.end;
+            if (end > minimumPosition && start < maximumPosition) {
+                var startPoint = Math.max(start - minimumPosition, 0);
+                var endPoint = Math.min(end - minimumPosition, maximumPosition);
+                var scaledStart = startPoint / wholeDuration;
+                var scaledEnd = endPoint / wholeDuration;
+                scaledSegments.push({ scaledStart: scaledStart, scaledEnd: scaledEnd, info: info });
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (bufferedData_1_1 && !bufferedData_1_1.done && (_a = bufferedData_1.return)) _a.call(bufferedData_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return scaledSegments;
+}

package/dist/commonjs/main_thread/api/debug/buffer_size_graph.d.ts

@@ -0,0 +1,11 @@
+export default class BufferSizeGraph {
+    private _history;
+    /** Canvas that will contain the buffer size graph itself. */
+    private readonly _canvasElt;
+    private readonly _canvasCtxt;
+    constructor(canvasElt: HTMLCanvasElement);
+    pushBufferSize(bufferSize: number): void;
+    clear(): void;
+    reRender(width: number, height: number): void;
+}
+//# sourceMappingURL=buffer_size_graph.d.ts.map

package/dist/commonjs/main_thread/api/debug/buffer_size_graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_size_graph.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/api/debug/buffer_size_graph.ts"],"names":[],"mappings":"AAmBA,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,OAAO,CAAC,QAAQ,CAAiB;IAEjC,6DAA6D;IAC7D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAE/C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkC;gBAElD,SAAS,EAAE,iBAAiB;IAMjC,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAiBxC,KAAK;IAML,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAiErD"}