rx-player 4.4.1 → 4.5.0-dev.2026012301

package/dist/es2017/manifest/classes/representation.js

@@ -1,366 +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";
-import { isRepresentationPlayable } from "../../manifest";
-import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
-import idGenerator from "../../utils/id_generator";
-import { bytesToHex } from "../../utils/string_parsing";
-const generateRepresentationUniqueId = idGenerator();
-/**
- * Normalized Representation structure.
- * @class Representation
- */
-class Representation {
-    /**
-     * @param {Object} args
-     * @param {string} trackType
-     */
-    constructor(args, trackType, cachedCodecSupport) {
-        var _a, _b, _c, _d, _e;
-        this.id = args.id;
-        this.uniqueId = generateRepresentationUniqueId();
-        this.shouldBeAvoided = false;
-        this.bitrate = args.bitrate;
-        this.codecs = [];
-        this.trackType = trackType;
-        if (args.isSpatialAudio !== undefined) {
-            this.isSpatialAudio = args.isSpatialAudio;
-        }
-        if (args.height !== undefined) {
-            this.height = args.height;
-        }
-        if (args.width !== undefined) {
-            this.width = args.width;
-        }
-        if (args.mimeType !== undefined) {
-            this.mimeType = args.mimeType;
-        }
-        if (args.contentProtections !== undefined) {
-            this.contentProtections = args.contentProtections;
-        }
-        if (args.frameRate !== undefined) {
-            this.frameRate = args.frameRate;
-        }
-        if (args.hdrInfo !== undefined) {
-            this.hdrInfo = args.hdrInfo;
-        }
-        this.cdnMetadata = args.cdnMetadata;
-        this.index = args.index;
-        const isEncrypted = this.contentProtections !== undefined;
-        if (trackType === "audio" || trackType === "video") {
-            // Supplemental codecs are defined as backwards-compatible codecs enhancing
-            // the experience of a base layer codec
-            if (args.supplementalCodecs !== undefined) {
-                const isSupplementaryCodecSupported = cachedCodecSupport.isSupported((_a = this.mimeType) !== null && _a !== void 0 ? _a : "", (_b = args.supplementalCodecs) !== null && _b !== void 0 ? _b : "", isEncrypted);
-                if (isSupplementaryCodecSupported !== false) {
-                    this.codecs = [args.supplementalCodecs];
-                    this.isSupported = isSupplementaryCodecSupported;
-                }
-            }
-            if (this.isSupported !== true) {
-                if (this.codecs.length > 0) {
-                    // We couldn't check for support of another supplemental codec.
-                    // Just push that codec without testing support yet, we'll check
-                    // support later.
-                    this.codecs.push((_c = args.codecs) !== null && _c !== void 0 ? _c : "");
-                }
-                else {
-                    this.codecs = args.codecs === undefined ? [] : [args.codecs];
-                    this.isSupported = cachedCodecSupport.isSupported((_d = this.mimeType) !== null && _d !== void 0 ? _d : "", (_e = args.codecs) !== null && _e !== void 0 ? _e : "", isEncrypted);
-                }
-            }
-        }
-        else {
-            if (args.codecs !== undefined) {
-                this.codecs.push(args.codecs);
-            }
-            this.isSupported = true;
-        }
-    }
-    /**
-     * Some environments (e.g. in a WebWorker) may not have the capability to know
-     * if a mimetype+codec combination is supported on the current platform.
-     *
-     * Calling `refreshCodecSupport` manually once the codecs supported are known
-     * by the current environnement allows to work-around this issue.
-     *
-     * If the right mimetype+codec combination is found in the provided object,
-     * this `Representation`'s `isSupported` property will be updated accordingly.
-     *
-     * @param {Array.<Object>} cachedCodecSupport;
-     */
-    refreshCodecSupport(cachedCodecSupport) {
-        var _a, _b;
-        if (this.isSupported !== undefined) {
-            return;
-        }
-        const isEncrypted = this.contentProtections !== undefined;
-        let isSupported = false;
-        const mimeType = (_a = this.mimeType) !== null && _a !== void 0 ? _a : "";
-        let codecs = (_b = this.codecs) !== null && _b !== void 0 ? _b : [];
-        if (codecs.length === 0) {
-            codecs = [""];
-        }
-        let representationHasUnknownCodecs = false;
-        for (const codec of codecs) {
-            isSupported = cachedCodecSupport.isSupported(mimeType, codec, isEncrypted);
-            if (isSupported === true) {
-                this.codecs = [codec];
-                break;
-            }
-            if (isSupported === undefined) {
-                representationHasUnknownCodecs = true;
-            }
-        }
-        /** If any codec is supported, the representation is supported */
-        if (isSupported === true) {
-            this.isSupported = true;
-        }
-        else {
-            /** If some codecs support are not known it's too early to assume
-             *  representation is unsupported */
-            if (representationHasUnknownCodecs) {
-                this.isSupported = undefined;
-            }
-            else {
-                /** If all codecs support are known and none are supported,
-                 * the representation is not supported.
-                 */
-                this.isSupported = false;
-            }
-        }
-    }
-    /**
-     * Returns "mime-type string" which includes both the mime-type and the codec,
-     * which is often needed when interacting with the browser's APIs.
-     * @returns {string}
-     */
-    getMimeTypeString() {
-        var _a, _b, _c;
-        return `${(_a = this.mimeType) !== null && _a !== void 0 ? _a : ""};codecs="${(_c = (_b = this.codecs) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : ""}"`;
-    }
-    /**
-     * Returns encryption initialization data linked to the given DRM's system ID.
-     * This data may be useful to decrypt encrypted media segments.
-     *
-     * Returns an empty array if there is no data found for that system ID at the
-     * moment.
-     *
-     * When you know that all encryption data has been added to this
-     * Representation, you can also call the `getAllEncryptionData` method.
-     * This second function will return all encryption initialization data
-     * regardless of the DRM system, and might thus be used in all cases.
-     *
-     * /!\ Note that encryption initialization data may be progressively added to
-     * this Representation after `_addProtectionData` calls or Manifest updates.
-     * Because of this, the return value of this function might change after those
-     * events.
-     *
-     * @param {string} drmSystemId - The hexa-encoded DRM system ID
-     * @returns {Array.<Object>}
-     */
-    getEncryptionData(drmSystemId) {
-        var _a;
-        const allInitData = this.getAllEncryptionData();
-        const filtered = [];
-        for (let i = 0; i < allInitData.length; i++) {
-            let createdObjForType = false;
-            const initData = allInitData[i];
-            for (let j = 0; j < initData.values.length; j++) {
-                if (initData.values[j].systemId.toLowerCase() === drmSystemId.toLowerCase()) {
-                    if (!createdObjForType) {
-                        const keyIds = (_a = this.contentProtections) === null || _a === void 0 ? void 0 : _a.keyIds;
-                        filtered.push({
-                            type: initData.type,
-                            keyIds,
-                            values: [initData.values[j]],
-                        });
-                        createdObjForType = true;
-                    }
-                    else {
-                        filtered[filtered.length - 1].values.push(initData.values[j]);
-                    }
-                }
-            }
-        }
-        return filtered;
-    }
-    /**
-     * Returns all currently-known encryption initialization data linked to this
-     * Representation.
-     * Encryption initialization data is generally required to be able to decrypt
-     * those Representation's media segments.
-     *
-     * Unlike `getEncryptionData`, this method will return all available
-     * encryption data.
-     * It might as such might be used when either the current drm's system id is
-     * not known or when no encryption data specific to it was found. In that
-     * case, providing every encryption data linked to this Representation might
-     * still allow decryption.
-     *
-     * Returns an empty array in two cases:
-     *   - the content is not encrypted.
-     *   - We don't have any decryption data yet.
-     *
-     * /!\ Note that new encryption initialization data can be added progressively
-     * through the `_addProtectionData` method or through Manifest updates.
-     * It is thus highly advised to only rely on this method once every protection
-     * data related to this Representation has been known to be added.
-     *
-     * The main situation where new encryption initialization data is added is
-     * after parsing this Representation's initialization segment, if one exists.
-     * @returns {Array.<Object>}
-     */
-    getAllEncryptionData() {
-        var _a;
-        if (this.contentProtections === undefined ||
-            this.contentProtections.initData.length === 0) {
-            return [];
-        }
-        const keyIds = (_a = this.contentProtections) === null || _a === void 0 ? void 0 : _a.keyIds;
-        return this.contentProtections.initData.map((x) => {
-            return { type: x.type, keyIds, values: x.values };
-        });
-    }
-    /**
-     * Add new encryption initialization data to this Representation if it was not
-     * already included.
-     *
-     * Returns `true` if new encryption initialization data has been added.
-     * Returns `false` if none has been added (e.g. because it was already known).
-     *
-     * /!\ Mutates the current Representation
-     *
-     * TODO better handle use cases like key rotation by not always grouping
-     * every protection data together? To check.
-     * @param {string} initDataType
-     * @param {Uint8Array|undefined} keyId
-     * @param {Uint8Array} data
-     * @returns {boolean}
-     */
-    addProtectionData(initDataType, keyId, data) {
-        let hasUpdatedProtectionData = false;
-        if (this.contentProtections === undefined) {
-            this.contentProtections = {
-                keyIds: keyId !== undefined ? [keyId] : [],
-                initData: [{ type: initDataType, values: data }],
-            };
-            return true;
-        }
-        if (keyId !== undefined) {
-            const keyIds = this.contentProtections.keyIds;
-            if (keyIds === undefined) {
-                this.contentProtections.keyIds = [keyId];
-            }
-            else {
-                let foundKeyId = false;
-                for (const knownKeyId of keyIds) {
-                    if (areArraysOfNumbersEqual(knownKeyId, keyId)) {
-                        foundKeyId = true;
-                    }
-                }
-                if (!foundKeyId) {
-                    log.warn("manifest", "found unanounced key id.", {
-                        keyId: bytesToHex(keyId),
-                    });
-                    keyIds.push(keyId);
-                }
-            }
-        }
-        const cInitData = this.contentProtections.initData;
-        for (let i = 0; i < cInitData.length; i++) {
-            if (cInitData[i].type === initDataType) {
-                const cValues = cInitData[i].values;
-                // loop through data
-                for (let dataI = 0; dataI < data.length; dataI++) {
-                    const dataToAdd = data[dataI];
-                    let cValuesIdx;
-                    for (cValuesIdx = 0; cValuesIdx < cValues.length; cValuesIdx++) {
-                        if (dataToAdd.systemId === cValues[cValuesIdx].systemId) {
-                            if (areArraysOfNumbersEqual(dataToAdd.data, cValues[cValuesIdx].data)) {
-                                // go to next dataToAdd
-                                break;
-                            }
-                            else {
-                                log.warn("manifest", "different init data for the same system ID", {
-                                    systemId: dataToAdd.systemId,
-                                });
-                            }
-                        }
-                    }
-                    if (cValuesIdx === cValues.length) {
-                        // we didn't break the loop === we didn't already find that value
-                        cValues.push(dataToAdd);
-                        hasUpdatedProtectionData = true;
-                    }
-                }
-                return hasUpdatedProtectionData;
-            }
-        }
-        // If we are here, this means that we didn't find the corresponding
-        // init data type in this.contentProtections.initData.
-        this.contentProtections.initData.push({ type: initDataType, values: data });
-        return true;
-    }
-    /**
-     * Returns `true` if the `Representation` has a high chance of being playable on
-     * the current device (its codec seems supported and we don't consider it to be
-     * un-decipherable).
-     *
-     * Returns `false` if the `Representation` has a high chance of being unplayable
-     * on the current device (its codec seems unsupported and/or we consider it to
-     * be un-decipherable).
-     *
-     * Returns `undefined` if we don't know as the codec has not been checked yet.
-     *
-     * @returns {boolean|undefined}
-     */
-    isPlayable() {
-        return isRepresentationPlayable(this);
-    }
-    /**
-     * Format the current `Representation`'s properties into a
-     * `IRepresentationMetadata` format which can better be communicated through
-     * another thread.
-     *
-     * Please bear in mind however that the returned object will not be updated
-     * when the current `Representation` instance is updated, it is only a
-     * snapshot at the current time.
-     *
-     * If you want to keep that data up-to-date with the current `Representation`
-     * instance, you will have to do it yourself.
-     *
-     * @returns {Object}
-     */
-    getMetadataSnapshot() {
-        return {
-            id: this.id,
-            uniqueId: this.uniqueId,
-            bitrate: this.bitrate,
-            codecs: this.codecs,
-            mimeType: this.mimeType,
-            width: this.width,
-            height: this.height,
-            frameRate: this.frameRate,
-            isSupported: this.isSupported,
-            hdrInfo: this.hdrInfo,
-            contentProtections: this.contentProtections,
-            decipherable: this.decipherable,
-            isCodecSupportedInWebWorker: this.isCodecSupportedInWebWorker,
-        };
-    }
-}
-export default Representation;

package/dist/es2017/manifest/classes/representation_index/index.d.ts

@@ -1,20 +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 StaticRepresentationIndex from "./static";
-import type { IMetaPlaylistPrivateInfos, IPrivateInfos, IRepresentationIndex, ISegment } from "./types";
-export type { IMetaPlaylistPrivateInfos, IPrivateInfos, IRepresentationIndex, ISegment };
-export { StaticRepresentationIndex };
-//# sourceMappingURL=index.d.ts.map

package/dist/es2017/manifest/classes/representation_index/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/manifest/classes/representation_index/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,yBAAyB,MAAM,UAAU,CAAC;AACjD,OAAO,KAAK,EACV,yBAAyB,EACzB,aAAa,EACb,oBAAoB,EACpB,QAAQ,EACT,MAAM,SAAS,CAAC;AAEjB,YAAY,EAAE,yBAAyB,EAAE,aAAa,EAAE,oBAAoB,EAAE,QAAQ,EAAE,CAAC;AACzF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/es2017/manifest/classes/representation_index/index.js

@@ -1,17 +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 StaticRepresentationIndex from "./static";
-export { StaticRepresentationIndex };

package/dist/es2017/manifest/classes/representation_index/static.d.ts

@@ -1,117 +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 { IRepresentationIndex, ISegment } from "./types";
-export interface IStaticRepresentationIndexInfos {
-    media: string;
-}
-/**
- * Simple RepresentationIndex implementation for static files.
- * @class StaticRepresentationIndex
- */
-export default class StaticRepresentationIndex implements IRepresentationIndex {
-    /** URL at which the content is available. */
-    private readonly _url;
-    /**
-     * @param {Object} infos
-     */
-    constructor(infos: IStaticRepresentationIndexInfos);
-    /**
-     * Static contents do not have any initialization segments.
-     * Just return null.
-     * @returns {null}
-     */
-    getInitSegment(): null;
-    /**
-     * Returns the only Segment available here.
-     * @returns {Array.<Object>}
-     */
-    getSegments(): ISegment[];
-    /**
-     * Returns first position in index.
-     * @returns {undefined}
-     */
-    getFirstAvailablePosition(): undefined;
-    /**
-     * Returns last position in index.
-     * @returns {undefined}
-     */
-    getLastAvailablePosition(): undefined;
-    /**
-     * Returns the absolute end in seconds this RepresentationIndex can reach once
-     * all segments are available.
-     * @returns {number|null|undefined}
-     */
-    getEnd(): undefined;
-    /**
-     * Returns:
-     *   - `true` if in the given time interval, at least one new segment is
-     *     expected to be available in the future.
-     *   - `false` either if all segments in that time interval are already
-     *     available for download or if none will ever be available for it.
-     *   - `undefined` when it is not possible to tell.
-     *
-     * Always `false` in a `StaticRepresentationIndex` because all segments should
-     * be directly available.
-     * @returns {boolean}
-     */
-    awaitSegmentBetween(): false;
-    /**
-     * Returns false as a static file never need to be refreshed.
-     * @returns {Boolean}
-     */
-    shouldRefresh(): false;
-    /**
-     * @returns {null}
-     */
-    checkDiscontinuity(): null;
-    /**
-     * Returns true as a static file should never need lose availability.
-     * @returns {Boolean}
-     */
-    isSegmentStillAvailable(): true;
-    /**
-     * @returns {Boolean}
-     */
-    canBeOutOfSyncError(): false;
-    /**
-     * @returns {Boolean}
-     */
-    isStillAwaitingFutureSegments(): false;
-    /**
-     * @returns {Boolean}
-     */
-    isInitialized(): true;
-    initialize(): void;
-    /**
-     * Returns the `duration` of each segment in the context of its Manifest (i.e.
-     * as the Manifest anounces them, actual segment duration may be different due
-     * to approximations), in seconds.
-     *
-     * NOTE: we could here do a median or a mean but I chose to be lazy (and
-     * more performant) by returning the duration of the first element instead.
-     * As `isPrecize` is `false`, the rest of the code should be notified that
-     * this is only an approximation.
-     * @returns {number}
-     */
-    getTargetSegmentDuration(): {
-        duration: number;
-        isPrecize: boolean;
-    } | undefined;
-    addPredictedSegments(): void;
-    _replace(): void;
-    _update(): void;
-}
-//# sourceMappingURL=static.d.ts.map

package/dist/es2017/manifest/classes/representation_index/static.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../../../../../src/manifest/classes/representation_index/static.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE9D,MAAM,WAAW,+BAA+B;IAC9C,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,yBAA0B,YAAW,oBAAoB;IAC5E,6CAA6C;IAC7C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAE9B;;OAEG;gBACS,KAAK,EAAE,+BAA+B;IAIlD;;;;OAIG;IACH,cAAc,IAAI,IAAI;IAItB;;;OAGG;IACH,WAAW,IAAI,QAAQ,EAAE;IAiBzB;;;OAGG;IACH,yBAAyB,IAAI,SAAS;IAItC;;;OAGG;IACH,wBAAwB,IAAI,SAAS;IAIrC;;;;OAIG;IACH,MAAM,IAAI,SAAS;IAInB;;;;;;;;;;;OAWG;IACH,mBAAmB,IAAI,KAAK;IAI5B;;;OAGG;IACH,aAAa,IAAI,KAAK;IAItB;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAI1B;;;OAGG;IACH,uBAAuB,IAAI,IAAI;IAI/B;;OAEG;IACH,mBAAmB,IAAI,KAAK;IAI5B;;OAEG;IACH,6BAA6B,IAAI,KAAK;IAItC;;OAEG;IACH,aAAa,IAAI,IAAI;IAIrB,UAAU,IAAI,IAAI;IAOlB;;;;;;;;;;OAUG;IACH,wBAAwB,IAAI;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS;IAOhF,oBAAoB,IAAI,IAAI;IAO5B,QAAQ,IAAI,IAAI;IAIhB,OAAO,IAAI,IAAI;CAGhB"}

package/dist/es2017/manifest/classes/representation_index/static.js

@@ -1,160 +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";
-/**
- * Simple RepresentationIndex implementation for static files.
- * @class StaticRepresentationIndex
- */
-export default class StaticRepresentationIndex {
-    /**
-     * @param {Object} infos
-     */
-    constructor(infos) {
-        this._url = infos.media;
-    }
-    /**
-     * Static contents do not have any initialization segments.
-     * Just return null.
-     * @returns {null}
-     */
-    getInitSegment() {
-        return null;
-    }
-    /**
-     * Returns the only Segment available here.
-     * @returns {Array.<Object>}
-     */
-    getSegments() {
-        return [
-            {
-                id: "0",
-                isInit: false,
-                number: 0,
-                url: this._url,
-                time: 0,
-                end: Number.MAX_VALUE,
-                duration: Number.MAX_VALUE,
-                complete: true,
-                privateInfos: {},
-                timescale: 1,
-            },
-        ];
-    }
-    /**
-     * Returns first position in index.
-     * @returns {undefined}
-     */
-    getFirstAvailablePosition() {
-        return;
-    }
-    /**
-     * Returns last position in index.
-     * @returns {undefined}
-     */
-    getLastAvailablePosition() {
-        return;
-    }
-    /**
-     * Returns the absolute end in seconds this RepresentationIndex can reach once
-     * all segments are available.
-     * @returns {number|null|undefined}
-     */
-    getEnd() {
-        return;
-    }
-    /**
-     * Returns:
-     *   - `true` if in the given time interval, at least one new segment is
-     *     expected to be available in the future.
-     *   - `false` either if all segments in that time interval are already
-     *     available for download or if none will ever be available for it.
-     *   - `undefined` when it is not possible to tell.
-     *
-     * Always `false` in a `StaticRepresentationIndex` because all segments should
-     * be directly available.
-     * @returns {boolean}
-     */
-    awaitSegmentBetween() {
-        return false;
-    }
-    /**
-     * Returns false as a static file never need to be refreshed.
-     * @returns {Boolean}
-     */
-    shouldRefresh() {
-        return false;
-    }
-    /**
-     * @returns {null}
-     */
-    checkDiscontinuity() {
-        return null;
-    }
-    /**
-     * Returns true as a static file should never need lose availability.
-     * @returns {Boolean}
-     */
-    isSegmentStillAvailable() {
-        return true;
-    }
-    /**
-     * @returns {Boolean}
-     */
-    canBeOutOfSyncError() {
-        return false;
-    }
-    /**
-     * @returns {Boolean}
-     */
-    isStillAwaitingFutureSegments() {
-        return false;
-    }
-    /**
-     * @returns {Boolean}
-     */
-    isInitialized() {
-        return true;
-    }
-    initialize() {
-        log.error("manifest", "A `StaticRepresentationIndex` does not need to be initialized");
-    }
-    /**
-     * Returns the `duration` of each segment in the context of its Manifest (i.e.
-     * as the Manifest anounces them, actual segment duration may be different due
-     * to approximations), in seconds.
-     *
-     * NOTE: we could here do a median or a mean but I chose to be lazy (and
-     * more performant) by returning the duration of the first element instead.
-     * As `isPrecize` is `false`, the rest of the code should be notified that
-     * this is only an approximation.
-     * @returns {number}
-     */
-    getTargetSegmentDuration() {
-        return {
-            duration: Number.MAX_VALUE,
-            isPrecize: false,
-        };
-    }
-    addPredictedSegments() {
-        log.warn("manifest", "Cannot add predicted segments to a `StaticRepresentationIndex`");
-    }
-    _replace() {
-        log.warn("manifest", "Tried to replace a static RepresentationIndex");
-    }
-    _update() {
-        log.warn("manifest", "Tried to update a static RepresentationIndex");
-    }
-}