rx-player 4.4.1 → 4.5.0-dev.2026012301

package/dist/es2017/parsers/containers/matroska/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/containers/matroska/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC"}

package/dist/es2017/parsers/containers/matroska/index.js

@@ -1,16 +0,0 @@
-/**
- * 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 { getSegmentsFromCues, getTimeCodeScale } from "./utils";

package/dist/es2017/parsers/containers/matroska/utils.d.ts

@@ -1,35 +0,0 @@
-/**
- * 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 interface ICuesSegment {
-    time: number;
-    duration: number;
-    timescale: number;
-    range: [number, number];
-}
-/**
- * Return the timecode scale (basically timescale) of the whole file.
- * @param {Uint8Array} buffer
- * @param {number} initialOffset
- * @returns {number|null}
- */
-export declare function getTimeCodeScale(buffer: Uint8Array, initialOffset: number): number | null;
-/**
- * @param {Uint8Array} buffer
- * @param {number} initialOffset
- * @returns {Array.<Object>|null}
- */
-export declare function getSegmentsFromCues(buffer: Uint8Array, initialOffset: number): ICuesSegment[] | null;
-//# sourceMappingURL=utils.d.ts.map

package/dist/es2017/parsers/containers/matroska/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/containers/matroska/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAcH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzB;AAqDD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,MAAM,GACpB,MAAM,GAAG,IAAI,CAYf;AA4BD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,MAAM,GACpB,YAAY,EAAE,GAAG,IAAI,CAmGvB"}

package/dist/es2017/parsers/containers/matroska/utils.js

@@ -1,256 +0,0 @@
-/**
- * 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 log from "../../../log";
-const SEGMENT_ID = 0x18538067;
-const INFO_ID = 0x1549a966;
-const TIMECODESCALE_ID = 0x2ad7b1;
-const DURATION_ID = 0x4489;
-const CUES_ID = 0x1c53bb6b;
-const CUE_POINT_ID = 0xbb;
-const CUE_TIME_ID = 0xb3;
-const CUE_TRACK_POSITIONS_ID = 0xb7;
-const CUE_CLUSTER_POSITIONS_ID = 0xf1;
-/**
- * Find the offsets of the value linked to the given element ID.
- * @param {number} elementID - ID for the searched element.
- * @param {Array.<number>} parents - eventual IDs of the parent elements. From
- * top level to lower level (from the furthest to the closest).
- * @param {Uint8Array} buffer - buffer where the ID will be searched
- * @param {Array.<number>} range - start and end offsets in the buffer where the
- * ID will be searched.
- * @returns {Array.<number>|null}
- */
-function findNextElement(elementID, parents, buffer, [initialOffset, maxOffset]) {
-    let currentOffset = initialOffset;
-    while (currentOffset < maxOffset) {
-        const parsedID = getEBMLID(buffer, currentOffset);
-        if (parsedID === null) {
-            return null;
-        }
-        const { value: ebmlTagID, length: ebmlTagLength } = parsedID;
-        const sizeOffset = currentOffset + ebmlTagLength;
-        const parsedValue = getEBMLValue(buffer, sizeOffset);
-        if (parsedValue === null) {
-            return null;
-        }
-        const { length: valueLengthLength, value: valueLength } = parsedValue;
-        const valueOffset = sizeOffset + valueLengthLength;
-        const valueEndOffset = valueOffset + valueLength;
-        if (ebmlTagID === elementID) {
-            return [valueOffset, valueEndOffset];
-        }
-        else if (parents.length > 0) {
-            for (let i = 0; i < parents.length; i++) {
-                if (ebmlTagID === parents[i]) {
-                    const newParents = parents.slice(i + 1, parents.length);
-                    return findNextElement(elementID, newParents, buffer, [
-                        valueOffset,
-                        valueEndOffset,
-                    ]);
-                }
-            }
-        }
-        currentOffset = valueEndOffset;
-    }
-    return null;
-}
-/**
- * Return the timecode scale (basically timescale) of the whole file.
- * @param {Uint8Array} buffer
- * @param {number} initialOffset
- * @returns {number|null}
- */
-export function getTimeCodeScale(buffer, initialOffset) {
-    const timeCodeScaleOffsets = findNextElement(TIMECODESCALE_ID, [SEGMENT_ID, INFO_ID], buffer, [initialOffset, buffer.length]);
-    if (timeCodeScaleOffsets === null) {
-        return null;
-    }
-    const length = timeCodeScaleOffsets[1] - timeCodeScaleOffsets[0];
-    return 1e9 / bytesToNumber(buffer, timeCodeScaleOffsets[0], length);
-}
-/**
- * Return the duration of the concerned media.
- * @param {Uint8Array} buffer
- * @param {number} initialOffset
- * @returns {number|null}
- */
-function getDuration(buffer, initialOffset) {
-    const timeCodeScaleOffsets = findNextElement(DURATION_ID, [SEGMENT_ID, INFO_ID], buffer, [initialOffset, buffer.length]);
-    if (timeCodeScaleOffsets === null) {
-        return null;
-    }
-    const length = timeCodeScaleOffsets[1] - timeCodeScaleOffsets[0];
-    if (length === 4) {
-        return get_IEEE754_32Bits(buffer, timeCodeScaleOffsets[0]);
-    }
-    else if (length === 8) {
-        return get_IEEE754_64Bits(buffer, timeCodeScaleOffsets[0]);
-    }
-    return null;
-}
-/**
- * @param {Uint8Array} buffer
- * @param {number} initialOffset
- * @returns {Array.<Object>|null}
- */
-export function getSegmentsFromCues(buffer, initialOffset) {
-    const segmentRange = findNextElement(SEGMENT_ID, [], buffer, [
-        initialOffset,
-        buffer.length,
-    ]);
-    if (segmentRange === null) {
-        return null;
-    }
-    const [segmentRangeStart, segmentRangeEnd] = segmentRange;
-    const timescale = getTimeCodeScale(buffer, segmentRangeStart);
-    if (timescale === null) {
-        return null;
-    }
-    const duration = getDuration(buffer, segmentRangeStart);
-    if (duration === null) {
-        return null;
-    }
-    const cuesRange = findNextElement(CUES_ID, [], buffer, [
-        segmentRangeStart,
-        segmentRangeEnd,
-    ]);
-    if (cuesRange === null) {
-        return null;
-    }
-    const rawInfos = [];
-    let currentOffset = cuesRange[0];
-    while (currentOffset < cuesRange[1]) {
-        const cuePointRange = findNextElement(CUE_POINT_ID, [], buffer, [
-            currentOffset,
-            cuesRange[1],
-        ]);
-        if (cuePointRange === null) {
-            break;
-        }
-        const cueTimeRange = findNextElement(CUE_TIME_ID, [], buffer, [
-            cuePointRange[0],
-            cuePointRange[1],
-        ]);
-        if (cueTimeRange === null) {
-            return null;
-        }
-        const time = bytesToNumber(buffer, cueTimeRange[0], cueTimeRange[1] - cueTimeRange[0]);
-        const cueOffsetRange = findNextElement(CUE_CLUSTER_POSITIONS_ID, [CUE_TRACK_POSITIONS_ID], buffer, [cuePointRange[0], cuePointRange[1]]);
-        if (cueOffsetRange === null) {
-            return null;
-        }
-        const rangeStart = bytesToNumber(buffer, cueOffsetRange[0], cueOffsetRange[1] - cueOffsetRange[0]) +
-            segmentRangeStart;
-        rawInfos.push({ time, rangeStart });
-        currentOffset = cuePointRange[1];
-    }
-    const segments = [];
-    for (let i = 0; i < rawInfos.length; i++) {
-        const currentSegment = rawInfos[i];
-        if (i === rawInfos.length - 1) {
-            segments.push({
-                time: currentSegment.time,
-                timescale,
-                duration: i === 0 ? duration : duration - currentSegment.time,
-                range: [currentSegment.rangeStart, Infinity],
-            });
-        }
-        else {
-            segments.push({
-                time: currentSegment.time,
-                timescale,
-                duration: rawInfos[i + 1].time - currentSegment.time,
-                range: [currentSegment.rangeStart, rawInfos[i + 1].rangeStart - 1],
-            });
-        }
-    }
-    return segments;
-}
-function getLength(buffer, offset) {
-    for (let length = 1; length <= 8; length++) {
-        if (buffer[offset] >= Math.pow(2, 8 - length)) {
-            return length;
-        }
-    }
-    return undefined;
-}
-function getEBMLID(buffer, offset) {
-    const length = getLength(buffer, offset);
-    if (length === undefined) {
-        log.warn("webm", "unrepresentable length");
-        return null;
-    }
-    if (offset + length > buffer.length) {
-        log.warn("webm", "impossible length", {
-            offset,
-            length,
-            bufferLength: buffer.length,
-        });
-        return null;
-    }
-    let value = 0;
-    for (let i = 0; i < length; i++) {
-        value = buffer[offset + i] * Math.pow(2, (length - i - 1) * 8) + value;
-    }
-    return { length, value };
-}
-function getEBMLValue(buffer, offset) {
-    const length = getLength(buffer, offset);
-    if (length === undefined) {
-        log.warn("webm", "unrepresentable length");
-        return null;
-    }
-    if (offset + length > buffer.length) {
-        log.warn("webm", "impossible length", {
-            offset,
-            length,
-            bufferLength: buffer.length,
-        });
-        return null;
-    }
-    let value = (buffer[offset] & ((1 << (8 - length)) - 1)) * Math.pow(2, (length - 1) * 8);
-    for (let i = 1; i < length; i++) {
-        value = buffer[offset + i] * Math.pow(2, (length - i - 1) * 8) + value;
-    }
-    return { length, value };
-}
-/**
- * Convert a IEEE754 32 bits floating number as an Uint8Array into its
- * corresponding Number.
- * @param {Uint8Array} buffer
- * @param {number} offset
- * @returns {number}
- */
-function get_IEEE754_32Bits(buffer, offset) {
-    return new DataView(buffer.buffer).getFloat32(offset);
-}
-/**
- * Convert a IEEE754 64 bits floating number as an Uint8Array into its
- * corresponding Number.
- * @param {Uint8Array} buffer
- * @param {number} offset
- * @returns {number}
- */
-function get_IEEE754_64Bits(buffer, offset) {
-    return new DataView(buffer.buffer).getFloat64(offset);
-}
-function bytesToNumber(buffer, offset, length) {
-    let value = 0;
-    for (let i = 0; i < length; i++) {
-        value = buffer[offset + i] * Math.pow(2, (length - i - 1) * 8) + value;
-    }
-    return value;
-}

package/dist/es2017/parsers/images/bif.d.ts

@@ -1,40 +0,0 @@
-/**
- * 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 interface IBifThumbnail {
-    index: number;
-    duration: number;
-    ts: number;
-    data: Uint8Array<ArrayBuffer>;
-}
-export interface IBifObject {
-    fileFormat: string;
-    version: string;
-    imageCount: number;
-    timescale: number;
-    format: string;
-    width: number;
-    height: number;
-    aspectRatio: string;
-    isVod: boolean;
-    thumbs: IBifThumbnail[];
-}
-/**
- * @param {UInt8Array} buf
- * @returns {Object}
- */
-declare function parseBif(buf: Uint8Array): IBifObject;
-export default parseBif;
-//# sourceMappingURL=bif.d.ts.map

package/dist/es2017/parsers/images/bif.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bif.d.ts","sourceRoot":"","sources":["../../../../src/parsers/images/bif.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAUH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAED;;;GAGG;AACH,iBAAS,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CA8F7C;AAED,eAAe,QAAQ,CAAC"}

package/dist/es2017/parsers/images/bif.js

@@ -1,101 +0,0 @@
-/**
- * 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.
- */
-/**
- * /!\ This file is feature-switchable.
- * It always should be imported through the `features` object.
- */
-import { le2toi, le4toi } from "../../utils/byte_parsing";
-import { utf8ToStr } from "../../utils/string_parsing";
-/**
- * @param {UInt8Array} buf
- * @returns {Object}
- */
-function parseBif(buf) {
-    let pos = 0;
-    const length = buf.length;
-    const fileFormat = utf8ToStr(buf.subarray(pos + 1, pos + 8));
-    pos += 8;
-    if (buf[0] !== 0x89 || fileFormat !== "BIF\r\n\u001a\n") {
-        throw new Error("Invalid BIF file");
-    }
-    const minorVersion = buf[pos];
-    pos += 1;
-    const majorVersion = buf[pos];
-    pos += 1;
-    const patchVersion = buf[pos];
-    pos += 1;
-    const increVersion = buf[pos];
-    pos += 1;
-    const version = [minorVersion, majorVersion, patchVersion, increVersion].join(".");
-    if (majorVersion > 0) {
-        throw new Error(`Unhandled version: ${majorVersion}`);
-    }
-    const imageCount = le4toi(buf, pos);
-    pos += 4;
-    const framewiseSeparation = le4toi(buf, pos);
-    pos += 4;
-    const format = utf8ToStr(buf.subarray(pos, pos + 4));
-    pos += 4;
-    const width = le2toi(buf, pos);
-    pos += 2;
-    const height = le2toi(buf, pos);
-    pos += 2;
-    const aspectRatio = [buf[pos], buf[pos + 1]].join(":");
-    pos += 2;
-    const isVod = buf[pos] === 1;
-    // bytes 0x1F to 0x40 is unused data for now
-    pos = 0x40;
-    const thumbs = [];
-    if (imageCount === 0) {
-        throw new Error("bif: no images to parse");
-    }
-    let index = 0;
-    let previousImageInfo = null;
-    while (pos < length) {
-        const currentImageTimestamp = le4toi(buf, pos);
-        pos += 4;
-        const currentImageOffset = le4toi(buf, pos);
-        pos += 4;
-        if (previousImageInfo !== null) {
-            // calculate for index-1
-            const ts = previousImageInfo.timestamp * framewiseSeparation;
-            const duration = framewiseSeparation;
-            const data = buf.slice(previousImageInfo.offset, currentImageOffset);
-            thumbs.push({ index, duration, ts, data });
-            index++;
-        }
-        if (currentImageTimestamp === 0xffffffff) {
-            break;
-        }
-        previousImageInfo = {
-            timestamp: currentImageTimestamp,
-            offset: currentImageOffset,
-        };
-    }
-    return {
-        fileFormat: "BIF",
-        version,
-        imageCount,
-        timescale: 1000,
-        format,
-        width,
-        height,
-        aspectRatio,
-        isVod,
-        thumbs,
-    };
-}
-export default parseBif;

package/dist/es2017/parsers/manifest/dash/common/attach_trickmode_track.d.ts

@@ -1,29 +0,0 @@
-/**
- * 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 { IParsedAdaptation, IParsedAdaptations } from "../../types";
-/**
- * Attach trick mode tracks to adaptations by assigning to the trickModeTracks
- * property an array of trick mode track adaptations.
- * @param {Object} adaptations
- * @param {Array.<Object>} trickModeTracks
- * @returns {void}
- */
-declare function attachTrickModeTrack(adaptations: IParsedAdaptations, trickModeTracks: Array<{
-    adaptation: IParsedAdaptation;
-    trickModeAttachedAdaptationIds: string[];
-}>): void;
-export default attachTrickModeTrack;
-//# sourceMappingURL=attach_trickmode_track.d.ts.map

package/dist/es2017/parsers/manifest/dash/common/attach_trickmode_track.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"attach_trickmode_track.d.ts","sourceRoot":"","sources":["../../../../../../src/parsers/manifest/dash/common/attach_trickmode_track.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEzE;;;;;;GAMG;AACH,iBAAS,oBAAoB,CAC3B,WAAW,EAAE,kBAAkB,EAC/B,eAAe,EAAE,KAAK,CAAC;IACrB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,8BAA8B,EAAE,MAAM,EAAE,CAAC;CAC1C,CAAC,GACD,IAAI,CAmBN;AAED,eAAe,oBAAoB,CAAC"}

package/dist/es2017/parsers/manifest/dash/common/attach_trickmode_track.js

@@ -1,44 +0,0 @@
-/**
- * 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 { SUPPORTED_ADAPTATIONS_TYPE } from "../../../../manifest";
-/**
- * Attach trick mode tracks to adaptations by assigning to the trickModeTracks
- * property an array of trick mode track adaptations.
- * @param {Object} adaptations
- * @param {Array.<Object>} trickModeTracks
- * @returns {void}
- */
-function attachTrickModeTrack(adaptations, trickModeTracks) {
-    for (const track of trickModeTracks) {
-        const { adaptation, trickModeAttachedAdaptationIds } = track;
-        for (const trickModeAttachedAdaptationId of trickModeAttachedAdaptationIds) {
-            for (const adaptationType of SUPPORTED_ADAPTATIONS_TYPE) {
-                const adaptationsByType = adaptations[adaptationType];
-                if (adaptationsByType !== undefined) {
-                    for (const adaptationByType of adaptationsByType) {
-                        if (adaptationByType.id === trickModeAttachedAdaptationId) {
-                            if (adaptationByType.trickModeTracks === undefined) {
-                                adaptationByType.trickModeTracks = [];
-                            }
-                            adaptationByType.trickModeTracks.push(adaptation);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-export default attachTrickModeTrack;

package/dist/es2017/parsers/manifest/dash/common/content_protection_parser.d.ts

@@ -1,99 +0,0 @@
-import type { IParsedRepresentation } from "../../types";
-import type { IContentProtectionIntermediateRepresentation } from "../node_parser_types";
-/**
- * Class whose purpose is to parse `<ContentProtection>` elements in a DASH MPD.
- *
- * This element has to be particularly considered because a ContentProtection
- * element can inherit another ContentProtection element coming before it yet
- * even after it in the MPD, through a system of "reference IDs".
- *
- * The idea here is that the main MPD parsing logic just needs to signal to this
- * class when a `ContentProtection` element is encountered - and to which
- * `Representation` it is associated, and this class will then perform the
- * ContentProtection-parsing operation as soon as it has all referenced
- * ContentProtection elements.
- *
- * @class ContentProtectionParser
- */
-export default class ContentProtectionParser {
-    /**
-     * Stores `ContentProtection` elements that can be referenced, identified by
-     * their `refId` attribute.
-     */
-    private _refs;
-    /**
-     * Storage of `ContentProtection` elements that could not yet have been parsed
-     * due to not-yet resolved references.
-     *
-     * This is only possible if a `ContentProtection` element performs a
-     * "forward-reference" to a later `ContentProtection` element that is not yet
-     * known by this `ContentProtectionParser`.
-     */
-    private _stored;
-    constructor();
-    /**
-     * Add new `IContentProtectionIntermediateRepresentation` objects that can
-     * be relied on as a reference by later
-     * `IContentProtectionIntermediateRepresentation` objects, without the need
-     * to actually apply it to a Representation.
-     * @param {Object} contentProtections
-     */
-    addReferences(contentProtections: IContentProtectionIntermediateRepresentation[]): void;
-    /**
-     * Add a new `IContentProtectionIntermediateRepresentation` object that should
-     * be parsed with the result linked to the given `IParsedRepresentation`.
-     * @param {Object} representation
-     * @param {Object} contentProt
-     */
-    add(representation: IParsedRepresentation, contentProt: IContentProtectionIntermediateRepresentation): void;
-    /**
-     * It is possible that even after parsing the full MPD,
-     */
-    finalize(): void;
-    /**
-     * Try to parse all ContentProtection that are currently waiting due to a
-     * referenced ContentProtection not being known yet.
-     *
-     * Return `true` if all ContentProtection references could have been found
-     * and `false` if at least one wasn't.
-     *
-     * The `force` parameter indicate what should be done if a reference linked
-     * to a ContentProtection couldn't be resolved: if `false`, we just keep that
-     * ContentProtection aside for later, if `true` we parse it right now even if
-     * information could be missing.
-     *
-     * @param {boolean} force
-     * @returns {boolean}
-     */
-    private _resolveStoredRefs;
-    /**
-     * Parse the `IContentProtectionIntermediateRepresentation` given and add the
-     * corresponding attributes to the given `IParsedRepresentation` when done.
-     *
-     * Because the `IContentProtectionIntermediateRepresentation` may be
-     * referencing another `IContentProtectionIntermediateRepresentation`, this
-     * method might not succeed to do so if the referenced
-     * `IContentProtectionIntermediateRepresentation` has not yet been encountered.
-     *
-     * In that last scenario, this method returns `false` and:
-     *   - Either `force` is set to `true`, in which case what could be parsed
-     *     will still be set on the `IParsedRepresentation`.
-     *   - Either `force` is set to `false`, in which case the parsing of this
-     *     `IContentProtectionIntermediateRepresentation` is skipped.
-     * @param {Object} representation
-     * @param {Object} contentProt
-     * @param {boolean} force
-     * @returns {boolean}
-     */
-    private _tryParsing;
-    /**
-     * Returns an `IContentProtectionIntermediateRepresentation` based on its
-     * "refId".
-     * Returns `undefined` if it is not known yet.
-     *
-     * @param {string} refId
-     * @returns {Object|undefined}
-     */
-    private _getReferenced;
-}
-//# sourceMappingURL=content_protection_parser.d.ts.map

package/dist/es2017/parsers/manifest/dash/common/content_protection_parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"content_protection_parser.d.ts","sourceRoot":"","sources":["../../../../../../src/parsers/manifest/dash/common/content_protection_parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EAAE,4CAA4C,EAAE,MAAM,sBAAsB,CAAC;AAEzF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAC1C;;;OAGG;IACH,OAAO,CAAC,KAAK,CAA4D;IACzE;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,CAEb;;IAOF;;;;;;OAMG;IACI,aAAa,CAClB,kBAAkB,EAAE,4CAA4C,EAAE,GACjE,IAAI;IAQP;;;;;OAKG;IACI,GAAG,CACR,cAAc,EAAE,qBAAqB,EACrC,WAAW,EAAE,4CAA4C,GACxD,IAAI;IAWP;;OAEG;IACI,QAAQ,IAAI,IAAI;IAIvB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,WAAW;IA8CnB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;CAKvB"}