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

package/dist/commonjs/mse/worker_media_source_interface.js

@@ -0,0 +1,382 @@
+"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);
+    };
+    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 __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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerSourceBufferInterface = void 0;
+var errors_1 = require("../errors");
+var log_1 = require("../log");
+var event_emitter_1 = require("../utils/event_emitter");
+var id_generator_1 = require("../utils/id_generator");
+var task_canceller_1 = require("../utils/task_canceller");
+var generateMediaSourceId = (0, id_generator_1.default)();
+var generateSourceBufferOperationId = (0, id_generator_1.default)();
+/**
+ * We may maintain a worker-side queue to avoid overwhelming the main thread
+ * with sent media segments. This queue maximum size if stored in that value.
+ *
+ * To set to `Infinity` to disable.
+ */
+var MAX_WORKER_SOURCE_BUFFER_QUEUE_SIZE = Infinity;
+/**
+ * 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
+ * available in WebWorker in the current environment you don't have to rely on
+ * this class).
+ *
+ * What this class actually does for most MSE API is to post a message
+ * corresponding to the wanted action - which will have to be processed on the
+ * main thread.
+ * @class {WorkerMediaSourceInterface}
+ */
+var WorkerMediaSourceInterface = /** @class */ (function (_super) {
+    __extends(WorkerMediaSourceInterface, _super);
+    function WorkerMediaSourceInterface(id, contentId, messageSender) {
+        var _this = _super.call(this) || this;
+        _this.id = id;
+        _this.sourceBuffers = [];
+        _this._canceller = new task_canceller_1.default("WorkerMediaSourceInterface");
+        _this.readyState = "closed";
+        _this._messageSender = messageSender;
+        var mediaSourceId = generateMediaSourceId();
+        _this._messageSender({
+            type: "create-media-source" /* CoreMessageType.CreateMediaSource */,
+            contentId: contentId,
+            mediaSourceId: mediaSourceId,
+        });
+        return _this;
+    }
+    WorkerMediaSourceInterface.prototype.onMediaSourceReadyStateChanged = function (readyState) {
+        switch (readyState) {
+            case "closed":
+                this.readyState = "closed";
+                this.trigger("mediaSourceClose", null);
+                break;
+            case "open":
+                this.readyState = "open";
+                this.trigger("mediaSourceOpen", null);
+                break;
+            case "ended":
+                this.readyState = "ended";
+                this.trigger("mediaSourceEnded", null);
+                break;
+        }
+    };
+    WorkerMediaSourceInterface.prototype.addSourceBuffer = function (sbType, codec) {
+        this._messageSender({
+            type: "add-source-buffer" /* CoreMessageType.AddSourceBuffer */,
+            mediaSourceId: this.id,
+            value: {
+                sourceBufferType: sbType,
+                codec: codec,
+            },
+        });
+        var sb = new WorkerSourceBufferInterface(sbType, codec, this.id, this._messageSender);
+        this.sourceBuffers.push(sb);
+        return sb;
+    };
+    WorkerMediaSourceInterface.prototype.setDuration = function (newDuration, isRealEndKnown) {
+        this._messageSender({
+            type: "update-media-source-duration" /* CoreMessageType.UpdateMediaSourceDuration */,
+            mediaSourceId: this.id,
+            value: {
+                duration: newDuration,
+                isRealEndKnown: isRealEndKnown,
+            },
+        });
+    };
+    WorkerMediaSourceInterface.prototype.interruptDurationSetting = function () {
+        this._messageSender({
+            type: "stop-media-source-duration" /* CoreMessageType.InterruptMediaSourceDurationUpdate */,
+            mediaSourceId: this.id,
+            value: null,
+        });
+    };
+    WorkerMediaSourceInterface.prototype.maintainEndOfStream = function () {
+        this._messageSender({
+            type: "end-of-stream" /* CoreMessageType.EndOfStream */,
+            mediaSourceId: this.id,
+            value: null,
+        });
+    };
+    WorkerMediaSourceInterface.prototype.stopEndOfStream = function () {
+        this._messageSender({
+            type: "stop-end-of-stream" /* CoreMessageType.InterruptEndOfStream */,
+            mediaSourceId: this.id,
+            value: null,
+        });
+    };
+    /**
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    WorkerMediaSourceInterface.prototype.dispose = function (reason) {
+        this.sourceBuffers.forEach(function (s) { return s.dispose(reason); });
+        this._canceller.cancel("WorkerMediaSourceInterface dispose");
+        this._messageSender({
+            type: "dispose-media-source" /* CoreMessageType.DisposeMediaSource */,
+            mediaSourceId: this.id,
+            value: null,
+        });
+    };
+    return WorkerMediaSourceInterface;
+}(event_emitter_1.default));
+exports.default = WorkerMediaSourceInterface;
+var WorkerSourceBufferInterface = /** @class */ (function () {
+    function WorkerSourceBufferInterface(sbType, codec, mediaSourceId, messageSender) {
+        this.type = sbType;
+        this.codec = codec;
+        this._canceller = new task_canceller_1.default("WorkerSourceBufferInterface " + sbType);
+        this._mediaSourceId = mediaSourceId;
+        this._queuedOperations = [];
+        this._pendingOperations = new Map();
+        this._messageSender = messageSender;
+    }
+    WorkerSourceBufferInterface.prototype.onOperationSuccess = function (operationId, ranges) {
+        var mapElt = this._pendingOperations.get(operationId);
+        if (mapElt === undefined) {
+            log_1.default.warn("mse", "unknown SourceBuffer operation succeeded", {
+                type: this.type,
+            });
+        }
+        else {
+            this._pendingOperations.delete(operationId);
+            mapElt.resolve(ranges);
+        }
+        this._performNextQueuedOperationIfItExists();
+    };
+    WorkerSourceBufferInterface.prototype.onOperationFailure = function (operationId, error) {
+        var e_1, _a;
+        var formattedErr = error.errorName === "CancellationError"
+            ? new task_canceller_1.CancellationError("Pending SBI Operation " + this.type, "SBI Failure")
+            : new errors_1.SourceBufferError(error.errorName, error.message, error.isBufferFull);
+        var mapElt = this._pendingOperations.get(operationId);
+        if (mapElt === undefined) {
+            log_1.default.info("mse", "unknown SourceBuffer operation failed", { type: this.type }, formattedErr);
+        }
+        else {
+            this._pendingOperations.delete(operationId);
+            mapElt.reject(formattedErr);
+        }
+        var cancellationError = new task_canceller_1.CancellationError("Queued SBI Operation " + this.type, "SBI failure");
+        try {
+            for (var _b = __values(this._queuedOperations), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var operation = _c.value;
+                operation.reject(cancellationError);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this._queuedOperations = [];
+    };
+    WorkerSourceBufferInterface.prototype.appendBuffer = function (data, params) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (_this._queuedOperations.length > 0 ||
+                _this._pendingOperations.size >= MAX_WORKER_SOURCE_BUFFER_QUEUE_SIZE) {
+                _this._queuedOperations.push({
+                    operationName: 0 /* SbiOperationName.Push */,
+                    params: [data, params],
+                    resolve: resolve,
+                    reject: reject,
+                });
+                return;
+            }
+            try {
+                var segmentSinkPushed = void 0;
+                if (data instanceof ArrayBuffer) {
+                    segmentSinkPushed = data;
+                }
+                else if (data.byteLength === data.buffer.byteLength) {
+                    segmentSinkPushed = data.buffer;
+                }
+                else {
+                    segmentSinkPushed = data.buffer.slice(data.byteOffset, data.byteLength + data.byteOffset);
+                }
+                var operationId = generateSourceBufferOperationId();
+                _this._messageSender({
+                    type: "source-buffer-append" /* CoreMessageType.SourceBufferAppend */,
+                    mediaSourceId: _this._mediaSourceId,
+                    sourceBufferType: _this.type,
+                    operationId: operationId,
+                    value: {
+                        data: segmentSinkPushed,
+                        params: params,
+                    },
+                }, [segmentSinkPushed]);
+                _this._addOperationToQueue(operationId, resolve, reject);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
+    WorkerSourceBufferInterface.prototype.remove = function (start, end) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (_this._queuedOperations.length > 0 ||
+                _this._pendingOperations.size >= MAX_WORKER_SOURCE_BUFFER_QUEUE_SIZE) {
+                _this._queuedOperations.push({
+                    operationName: 1 /* SbiOperationName.Remove */,
+                    params: [start, end],
+                    resolve: resolve,
+                    reject: reject,
+                });
+                return;
+            }
+            try {
+                var operationId = generateSourceBufferOperationId();
+                _this._messageSender({
+                    type: "source-buffer-remove" /* CoreMessageType.SourceBufferRemove */,
+                    mediaSourceId: _this._mediaSourceId,
+                    sourceBufferType: _this.type,
+                    operationId: operationId,
+                    value: {
+                        start: start,
+                        end: end,
+                    },
+                });
+                _this._addOperationToQueue(operationId, resolve, reject);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
+    WorkerSourceBufferInterface.prototype.abort = function () {
+        this._messageSender({
+            type: "abort-source-buffer" /* CoreMessageType.AbortSourceBuffer */,
+            mediaSourceId: this._mediaSourceId,
+            sourceBufferType: this.type,
+            value: null,
+        });
+    };
+    /**
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    WorkerSourceBufferInterface.prototype.dispose = function (reason) {
+        this.abort();
+        this._canceller.cancel(reason !== null && reason !== void 0 ? reason : "WorkerSourceBufferInterface dispose");
+    };
+    WorkerSourceBufferInterface.prototype.getBuffered = function () {
+        return;
+    };
+    WorkerSourceBufferInterface.prototype._addOperationToQueue = function (operationId, resolve, reject) {
+        var _this = this;
+        this._pendingOperations.set(operationId, {
+            resolve: onResolve,
+            reject: onReject,
+        });
+        var unbindCanceller = this._canceller.signal.register(function (error) {
+            _this._pendingOperations.delete(operationId);
+            reject(error);
+        });
+        function onResolve(ranges) {
+            unbindCanceller();
+            resolve(ranges);
+        }
+        function onReject(err) {
+            unbindCanceller();
+            reject(err);
+        }
+    };
+    WorkerSourceBufferInterface.prototype._performNextQueuedOperationIfItExists = function () {
+        var nextOp = this._queuedOperations.shift();
+        if (nextOp !== undefined) {
+            try {
+                if (nextOp.operationName === 0 /* SbiOperationName.Push */) {
+                    var _a = __read(nextOp.params, 2), data = _a[0], params = _a[1];
+                    var segmentSinkPushed = void 0;
+                    if (data instanceof ArrayBuffer) {
+                        segmentSinkPushed = data;
+                    }
+                    else if (data.byteLength === data.buffer.byteLength) {
+                        segmentSinkPushed = data.buffer;
+                    }
+                    else {
+                        segmentSinkPushed = data.buffer.slice(data.byteOffset, data.byteLength + data.byteOffset);
+                    }
+                    var nOpId = generateSourceBufferOperationId();
+                    this._messageSender({
+                        type: "source-buffer-append" /* CoreMessageType.SourceBufferAppend */,
+                        mediaSourceId: this._mediaSourceId,
+                        sourceBufferType: this.type,
+                        operationId: nOpId,
+                        value: {
+                            data: segmentSinkPushed,
+                            params: params,
+                        },
+                    }, [segmentSinkPushed]);
+                    this._addOperationToQueue(nOpId, nextOp.resolve, nextOp.reject);
+                }
+                else {
+                    var _b = __read(nextOp.params, 2), start = _b[0], end = _b[1];
+                    var nOpId = generateSourceBufferOperationId();
+                    this._messageSender({
+                        type: "source-buffer-remove" /* CoreMessageType.SourceBufferRemove */,
+                        mediaSourceId: this._mediaSourceId,
+                        sourceBufferType: this.type,
+                        operationId: nOpId,
+                        value: {
+                            start: start,
+                            end: end,
+                        },
+                    });
+                    this._addOperationToQueue(nOpId, nextOp.resolve, nextOp.reject);
+                }
+            }
+            catch (err) {
+                nextOp.reject(err);
+            }
+        }
+    };
+    return WorkerSourceBufferInterface;
+}());
+exports.WorkerSourceBufferInterface = WorkerSourceBufferInterface;

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

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+/**
+ * Maximum integer that can be stored on 32 bits.
+ *
+ * This can be used for example to know what is the maximum ISOBMFF box size
+ * that can be stored on the first four bytes of a box. Any value higher than
+ * that will need 8 bytes (64 bits) to be stored.
+ */
+export declare const MAX_32_BIT_INT: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/commonjs/parsers/containers/isobmff/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/containers/isobmff/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,QAAsB,CAAC"}

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

@@ -0,0 +1,26 @@
+"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 });
+exports.MAX_32_BIT_INT = void 0;
+/**
+ * Maximum integer that can be stored on 32 bits.
+ *
+ * This can be used for example to know what is the maximum ISOBMFF box size
+ * that can be stored on the first four bytes of a box. Any value higher than
+ * that will need 8 bytes (64 bits) to be stored.
+ */
+exports.MAX_32_BIT_INT = Math.pow(2, 32) - 1;

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

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+/**
+ * Create a new ISOBMFF "box" with the given name.
+ * @param {string} name - name of the box you want to create, must always
+ * be 4 characters (uuid boxes not supported)
+ * @param {Uint8Array} buff - content of the box
+ * @returns {Uint8Array} - The entire ISOBMFF box (length+name+content)
+ */
+declare function createBox(name: string, buff: Uint8Array): Uint8Array<ArrayBuffer>;
+/**
+ * @param {string} name
+ * @param {Array.<Uint8Array>} children
+ * @returns {Uint8Array}
+ */
+declare function createBoxWithChildren(name: string, children: Uint8Array[]): Uint8Array<ArrayBuffer>;
+export { createBox, createBoxWithChildren };
+//# sourceMappingURL=create_box.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_box.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/containers/isobmff/create_box.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAkCH;;;;;;GAMG;AACH,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC,WAAW,CAAC,CAK1E;AAED;;;;GAIG;AACH,iBAAS,qBAAqB,CAC5B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,UAAU,EAAE,GACrB,UAAU,CAAC,WAAW,CAAC,CAEzB;AAED,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,CAAC"}

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

@@ -0,0 +1,93 @@
+"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 __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 });
+exports.createBox = createBox;
+exports.createBoxWithChildren = createBoxWithChildren;
+var byte_parsing_1 = require("../../../utils/byte_parsing");
+var string_parsing_1 = require("../../../utils/string_parsing");
+var constants_1 = require("./constants");
+/**
+ * Speed up string to bytes conversion by memorizing the result
+ *
+ * The keys here are ISOBMFF box names. The values are the corresponding
+ * bytes conversion for putting as an ISOBMFF boxes.
+ *
+ * Used by the boxName method.
+ * @type {Object}
+ */
+var boxNamesMem = {};
+/**
+ * Convert the string name of an ISOBMFF box into the corresponding bytes.
+ * Has a memorization mechanism to speed-up if you want to translate the
+ * same string multiple times.
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+function boxName(str) {
+    if (boxNamesMem[str] !== undefined) {
+        return boxNamesMem[str];
+    }
+    var nameInBytes = (0, string_parsing_1.strToUtf8)(str);
+    boxNamesMem[str] = nameInBytes;
+    return nameInBytes;
+}
+/**
+ * Create a new ISOBMFF "box" with the given name.
+ * @param {string} name - name of the box you want to create, must always
+ * be 4 characters (uuid boxes not supported)
+ * @param {Uint8Array} buff - content of the box
+ * @returns {Uint8Array} - The entire ISOBMFF box (length+name+content)
+ */
+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);
+}
+/**
+ * @param {string} name
+ * @param {Array.<Uint8Array>} children
+ * @returns {Uint8Array}
+ */
+function createBoxWithChildren(name, children) {
+    return createBox(name, byte_parsing_1.concat.apply(void 0, __spreadArray([], __read(children), false)));
+}

package/dist/commonjs/parsers/containers/isobmff/drm/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+export { getPlayReadyKIDFromPrivateData } from "./playready";
+//# sourceMappingURL=index.d.ts.map

package/dist/commonjs/parsers/containers/isobmff/drm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/parsers/containers/isobmff/drm/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC"}

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

@@ -0,0 +1,20 @@
+"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 });
+exports.getPlayReadyKIDFromPrivateData = void 0;
+var playready_1 = require("./playready");
+Object.defineProperty(exports, "getPlayReadyKIDFromPrivateData", { enumerable: true, get: function () { return playready_1.getPlayReadyKIDFromPrivateData; } });

package/dist/commonjs/parsers/containers/isobmff/drm/playready.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+/**
+ * Parse PlayReady privateData to get its Hexa-coded KeyID.
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+export declare function getPlayReadyKIDFromPrivateData(data: Uint8Array): string;
+//# sourceMappingURL=playready.d.ts.map

package/dist/commonjs/parsers/containers/isobmff/drm/playready.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playready.d.ts","sourceRoot":"","sources":["../../../../../../src/parsers/containers/isobmff/drm/playready.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAYvE"}

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

@@ -0,0 +1,38 @@
+"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 });
+exports.getPlayReadyKIDFromPrivateData = getPlayReadyKIDFromPrivateData;
+var base64_1 = require("../../../../utils/base64");
+var byte_parsing_1 = require("../../../../utils/byte_parsing");
+var string_parsing_1 = require("../../../../utils/string_parsing");
+/**
+ * Parse PlayReady privateData to get its Hexa-coded KeyID.
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function getPlayReadyKIDFromPrivateData(data) {
+    var xmlLength = (0, byte_parsing_1.le2toi)(data, 8);
+    var xml = (0, string_parsing_1.utf16LEToStr)(data.subarray(10, xmlLength + 10));
+    var doc = new DOMParser().parseFromString(xml, "application/xml");
+    var kidElement = doc.querySelector("KID");
+    if (kidElement === null) {
+        throw new Error("Cannot parse PlayReady private data: invalid XML");
+    }
+    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();
+}