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

package/dist/es2017/parsers/manifest/local/representation_index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * 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 "../../../manifest";
+import type { ILocalIndex } from "./types";
+export default class LocalRepresentationIndex implements IRepresentationIndex {
+    private _index;
+    private _representationId;
+    constructor(index: ILocalIndex, representationId: string);
+    /**
+     * @returns {Object}
+     */
+    getInitSegment(): ISegment | null;
+    /**
+     * @param {Number} up
+     * @param {Number} duration
+     * @returns {Array.<Object>}
+     */
+    getSegments(up: number, duration: number): ISegment[];
+    /**
+     * @returns {Number|undefined}
+     */
+    getFirstAvailablePosition(): number | undefined;
+    /**
+     * @returns {Number|undefined}
+     */
+    getLastAvailablePosition(): number | undefined;
+    /**
+     * Returns the expected ending position of this RepresentationIndex.
+     * `undefined` if unknown.
+     * @returns {number|undefined}
+     */
+    getEnd(): number | 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.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    awaitSegmentBetween(start: number, end: number): boolean | undefined;
+    /**
+     * @returns {Boolean}
+     */
+    shouldRefresh(): false;
+    /**
+     * @returns {Boolean}
+     */
+    isSegmentStillAvailable(): true;
+    isStillAwaitingFutureSegments(): boolean;
+    /**
+     * @returns {Boolean}
+     */
+    canBeOutOfSyncError(): false;
+    /**
+     * @returns {null}
+     */
+    checkDiscontinuity(): null;
+    /**
+     * @returns {Boolean}
+     */
+    isInitialized(): true;
+    initialize(): void;
+    addPredictedSegments(): 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;
+    _replace(newIndex: LocalRepresentationIndex): void;
+    _update(newIndex: LocalRepresentationIndex): void;
+}
+//# sourceMappingURL=representation_index.d.ts.map

package/dist/es2017/parsers/manifest/local/representation_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"representation_index.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/manifest/local/representation_index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,SAAS,CAAC;AAE/D,MAAM,CAAC,OAAO,OAAO,wBAAyB,YAAW,oBAAoB;IAC3E,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,iBAAiB,CAAS;gBACtB,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM;IAKxD;;OAEG;IACH,cAAc,IAAI,QAAQ,GAAG,IAAI;IAgBjC;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAAE;IAoCrD;;OAEG;IACH,yBAAyB,IAAI,MAAM,GAAG,SAAS;IAQ/C;;OAEG;IACH,wBAAwB,IAAI,MAAM,GAAG,SAAS;IAQ9C;;;;OAIG;IACH,MAAM,IAAI,MAAM,GAAG,SAAS;IAmB5B;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAYpE;;OAEG;IACH,aAAa,IAAI,KAAK;IAItB;;OAEG;IACH,uBAAuB,IAAI,IAAI;IAI/B,6BAA6B,IAAI,OAAO;IAIxC;;OAEG;IACH,mBAAmB,IAAI,KAAK;IAI5B;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAI1B;;OAEG;IACH,aAAa,IAAI,IAAI;IAIrB,UAAU,IAAI,IAAI;IAIlB,oBAAoB,IAAI,IAAI;IAI5B;;;;;;;;;;OAUG;IACH,wBAAwB,IAAI;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS;IAUhF,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI;IAMlD,OAAO,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI;CA2ClD"}

package/dist/es2017/parsers/manifest/local/representation_index.js

@@ -0,0 +1,243 @@
+/**
+ * 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";
+export default class LocalRepresentationIndex {
+    constructor(index, representationId) {
+        this._index = index;
+        this._representationId = representationId;
+    }
+    /**
+     * @returns {Object}
+     */
+    getInitSegment() {
+        return {
+            id: `${this._representationId}_init`,
+            isInit: true,
+            time: 0,
+            end: 0,
+            duration: 0,
+            timescale: 1,
+            url: null,
+            complete: true,
+            privateInfos: {
+                localManifestInitSegment: { load: this._index.loadInitSegment },
+            },
+        };
+    }
+    /**
+     * @param {Number} up
+     * @param {Number} duration
+     * @returns {Array.<Object>}
+     */
+    getSegments(up, duration) {
+        const startTime = up;
+        const endTime = up + duration;
+        const wantedSegments = [];
+        for (const segment of this._index.segments) {
+            const segmentStart = segment.time;
+            if (endTime <= segmentStart) {
+                break;
+            }
+            const segmentEnd = segment.time + segment.duration;
+            if (segmentEnd > startTime) {
+                wantedSegments.push(segment);
+            }
+        }
+        return wantedSegments.map((wantedSegment) => {
+            return {
+                id: `${this._representationId}_${wantedSegment.time}`,
+                isInit: false,
+                time: wantedSegment.time,
+                end: wantedSegment.time + wantedSegment.duration,
+                duration: wantedSegment.duration,
+                timescale: 1,
+                timestampOffset: wantedSegment.timestampOffset,
+                url: null,
+                complete: true,
+                privateInfos: {
+                    localManifestSegment: {
+                        load: this._index.loadSegment,
+                        segment: wantedSegment,
+                    },
+                },
+            };
+        });
+    }
+    /**
+     * @returns {Number|undefined}
+     */
+    getFirstAvailablePosition() {
+        if (this._index.segments.length === 0) {
+            return undefined;
+        }
+        const firstSegment = this._index.segments[0];
+        return firstSegment.time;
+    }
+    /**
+     * @returns {Number|undefined}
+     */
+    getLastAvailablePosition() {
+        if (this._index.segments.length === 0) {
+            return undefined;
+        }
+        const lastSegment = this._index.segments[this._index.segments.length - 1];
+        return lastSegment.time + lastSegment.duration;
+    }
+    /**
+     * Returns the expected ending position of this RepresentationIndex.
+     * `undefined` if unknown.
+     * @returns {number|undefined}
+     */
+    getEnd() {
+        if (this._index.isFinished) {
+            return this.getLastAvailablePosition();
+        }
+        const { incomingRanges, segments } = this._index;
+        if (incomingRanges === undefined || incomingRanges.length === 0) {
+            // If incomingRanges is empty but not finished... It's ambiguous.
+            return undefined;
+        }
+        const lastIncomingRange = incomingRanges[incomingRanges.length - 1];
+        const futureEnd = lastIncomingRange.end;
+        if (segments.length === 0) {
+            return futureEnd;
+        }
+        const lastSegment = this._index.segments[this._index.segments.length - 1];
+        return Math.max(lastSegment.time + lastSegment.duration, futureEnd);
+    }
+    /**
+     * 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.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    awaitSegmentBetween(start, end) {
+        if (this.isStillAwaitingFutureSegments()) {
+            return false;
+        }
+        if (this._index.incomingRanges === undefined) {
+            return undefined;
+        }
+        return this._index.incomingRanges.some((range) => range.start < end && range.end > start);
+    }
+    /**
+     * @returns {Boolean}
+     */
+    shouldRefresh() {
+        return false;
+    }
+    /**
+     * @returns {Boolean}
+     */
+    isSegmentStillAvailable() {
+        return true;
+    }
+    isStillAwaitingFutureSegments() {
+        return !this._index.isFinished;
+    }
+    /**
+     * @returns {Boolean}
+     */
+    canBeOutOfSyncError() {
+        return false;
+    }
+    /**
+     * @returns {null}
+     */
+    checkDiscontinuity() {
+        return null;
+    }
+    /**
+     * @returns {Boolean}
+     */
+    isInitialized() {
+        return true;
+    }
+    initialize() {
+        log.error("dash", "A `LocalRepresentationIndex` does not need to be initialized");
+    }
+    addPredictedSegments() {
+        log.warn("dash", "Cannot add predicted segments to a `LocalRepresentationIndex`");
+    }
+    /**
+     * 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() {
+        if (this._index.segments.length === 0) {
+            return undefined;
+        }
+        return {
+            duration: this._index.segments[0].duration,
+            isPrecize: false,
+        };
+    }
+    _replace(newIndex) {
+        this._index.segments = newIndex._index.segments;
+        this._index.loadSegment = newIndex._index.loadSegment;
+        this._index.loadInitSegment = newIndex._index.loadInitSegment;
+    }
+    _update(newIndex) {
+        const newSegments = newIndex._index.segments;
+        if (newSegments.length <= 0) {
+            return;
+        }
+        const insertNewIndexAtPosition = (pos) => {
+            this._index.segments.splice(pos, oldIndexLength - pos, ...newSegments);
+            this._index.loadSegment = newIndex._index.loadSegment;
+            this._index.loadInitSegment = newIndex._index.loadInitSegment;
+        };
+        const oldIndexLength = this._index.segments.length;
+        const newIndexStart = newSegments[0].time;
+        for (let i = oldIndexLength - 1; i >= 0; i--) {
+            const currSegment = this._index.segments[i];
+            if (currSegment.time === newIndexStart) {
+                return insertNewIndexAtPosition(i);
+            }
+            else if (currSegment.time < newIndexStart) {
+                if (currSegment.time + currSegment.duration > newIndexStart) {
+                    // the new Manifest overlaps a previous segment (weird). Remove the latter.
+                    log.warn("dash", "Local RepresentationIndex: Manifest update removed previous segments");
+                    return insertNewIndexAtPosition(i);
+                }
+                return insertNewIndexAtPosition(i + 1);
+            }
+        }
+        // if we got here, it means that every segments in the previous manifest are
+        // after the new one. This is unusual.
+        // Either the new one has more depth or it's an older one.
+        const oldIndexEnd = this._index.segments[oldIndexLength - 1].time +
+            this._index.segments[oldIndexLength - 1].duration;
+        const newIndexEnd = newSegments[newSegments.length - 1].time +
+            newSegments[newSegments.length - 1].duration;
+        if (oldIndexEnd >= newIndexEnd) {
+            return;
+        }
+        return this._replace(newIndex);
+    }
+}

package/dist/es2017/parsers/manifest/local/types.d.ts

@@ -0,0 +1,288 @@
+/**
+ * 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.
+ */
+/**
+ * Callback allowing to retrieve an initialization segment. Each
+ * `ILocalManifestInitSegmentLoader` will be associated to a single
+ * `ILocalRepresentation`, so to only one possible initialization segment
+ * (or to the absence of one).
+ *
+ * It will be called when the RxPlayer wants to download the corresponding
+ * `ILocalRepresentation`'s initialization segment.
+ * When called, it will have a single argument containing two properties:
+ *   - `resolve`: function to call when the data has been loaded, with the
+ *                data itself.
+ *                If the corresponding `ILocalRepresentation` has no
+ *                initialization segment, this data can be set to `null`.
+ *   - `reject`: function to call when an error happened which made the
+ *               retrieval of the data impossible. The error should be given
+ *               to this function.
+ *
+ * Optionally, this callack can return a function. This function will be called
+ * in the case where the RxPlayer wants to cancel this request.
+ * You can thus abort every steps taken to retrieve the segment in that callback.
+ * Calls to `resolve` and to `reject` won't be considered after the returned
+ * callback is called.
+ */
+export type ILocalManifestInitSegmentLoader = (callbacks: {
+    resolve: (args: {
+        data: ArrayBuffer | null;
+    }) => void;
+    reject: (err?: Error) => void;
+}) => (() => void) | void;
+/**
+ * Callback allowing to retrieve a media segment. Each `ILocalManifestSegmentLoader`
+ * will be associated to a single `ILocalRepresentation`.
+ *
+ * It will be called when the RxPlayer wants to download a specific media
+ * segment for that `ILocalRepresentation` with two arguments.
+ *
+ * The first of those arguments is the segment the player wants to fetch.
+ * This coresponds to the same object than the one defined in the corresponding
+ * `ILocalIndex`.
+ *
+ * The second argument is an object containing two callbacks, that you can call
+ * either when the segment has been loaded or when an error happened while doing
+ * so:
+ *   - `resolve`: function to call when the data has been loaded, with the
+ *                data itself.
+ *   - `reject`: function to call when an error happened which made the
+ *               retrieval of the data impossible. The error should be given
+ *               to this function.
+ *
+ * Optionally, this callack can return a function. This function will be called
+ * in the case where the RxPlayer wants to cancel this request.
+ * You can thus abort every steps taken to retrieve the segment in that callback.
+ * Calls to `resolve` and to `reject` won't be considered after the returned
+ * callback is called.
+ */
+export type ILocalManifestSegmentLoader = (segment: ILocalIndexSegment, // Same than the segment from `segments`
+callbacks: {
+    resolve: (args: {
+        data: ArrayBuffer;
+    }) => void;
+    reject: (err?: Error) => void;
+}) => (() => void) | void;
+/**
+ * DRM information describing a "keyId" identifying a key with which a given
+ * `ILocalRepresentation` is encrypted.
+ */
+export interface IContentProtectionKID {
+    /** The corresponding "keyId", encoded as an array of bytes. */
+    keyId: Uint8Array;
+    /**
+     * Optional "systemId" (identifying a given key system) to which the keyId
+     * apply.
+     * This systemId should be defined as an hexadecimal string, with optional
+     * dashes in between. An example of possible systemId can be found here:
+     * https://dashif.org/identifiers/content_protection/
+     */
+    systemId?: string;
+}
+/**
+ * DRM information describing initialization data necessary to initialize a
+ * given CDM's instance.
+ * For the moment, this is limited to PSSH information.
+ */
+export interface IContentProtectionInitData {
+    /**
+     * The initialization data itself. For data coming from a pssh ISOBMFF box,
+     * this includes the size and name of the box.
+     */
+    data: Uint8Array;
+    /**
+     * Id defining what key system the initialization data applies to.
+     *
+     * This systemId should be defined as an hexadecimal string, with optional
+     * dashes in between. An example of possible systemId can be found here:
+     * https://dashif.org/identifiers/content_protection/
+     */
+    systemId: string;
+}
+/**
+ * Object describing DRM information for a given `ILocalRepresentation`.
+ * Note that any information here is optional. A content can be encrypted
+ * without these being properly defined.
+ * Those information are only used for supplementary features and optimizations
+ * in the RxPlayer.
+ */
+export interface IContentProtections {
+    /** All "keyId" that applies to the `ILocalRepresentation`. */
+    keyIds: IContentProtectionKID[];
+    /**
+     * DRM information describing initialization data necessary to initialize a
+     * given CDM's instance.
+     * This is an Object grouping such initialization data by "types" of data.
+     * Examples of possible initialization data type can be found here:
+     * https://www.w3.org/TR/eme-initdata-registry/
+     */
+    initData: Partial<Record<string, IContentProtectionInitData[]>>;
+}
+/** Object defining a single available media segment in a `ILocalIndex`. */
+export interface ILocalIndexSegment {
+    /** Earliest presentation time available for this segment, in seconds. */
+    time: number;
+    /**
+     * Time difference between the maximum available presentation time in this
+     * segment and the first (defined by `time`), in seconds.
+     */
+    duration: number;
+    /**
+     * If set, this is the amount of time in seconds we have to add to the
+     * segment once loaded so it can be decoded at the time indicated by the
+     * `time` property.
+     */
+    timestampOffset?: number;
+}
+/** "Index" of a `ILocalRepresentation`. Allow to declare available segments. */
+export interface ILocalIndex {
+    /** Every segments in that `ILocalIndex` has been downloaded. */
+    isFinished: boolean;
+    /** Callback used to retrieve the initialization segment of a `ILocalRepresentation`. */
+    loadInitSegment: ILocalManifestInitSegmentLoader;
+    /** Callback used to retrieve a media segment of a `ILocalRepresentation`. */
+    loadSegment: ILocalManifestSegmentLoader;
+    /**
+     * List of available media segments, in chronological order.
+     * Doesn't include the initialization segment.
+     */
+    segments: ILocalIndexSegment[];
+    /**
+     * List of not yet available time ranges, that should become available once
+     * the content is fully loaded.
+     */
+    incomingRanges?: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+/** A quality for a given "local" Manifest track (`ILocalAdaptation`). */
+export interface ILocalRepresentation {
+    /** Maximum number of bytes per second for the segments contained in this quality. */
+    bitrate: number;
+    /** DRM information. */
+    contentProtections?: IContentProtections;
+    /** Mime-type of the corresponding quality's segment. */
+    mimeType: string;
+    /** Codec(s) necessary to decode this quality's segment. */
+    codecs: string;
+    /**
+     * Width in pixels for this quality.
+     * This should only be set if the corresponding "track" contains video.
+     */
+    width?: number;
+    /**
+     * Height in pixels for this quality.
+     * This should only be set if the corresponding "track" contains video.
+     */
+    height?: number;
+    /** Interface allowing to retrieve media segments for this quality. */
+    index: ILocalIndex;
+    /** `true` if audio has Dolby Atmos. */
+    isSpatialAudio?: boolean;
+}
+/** A "track"" of a "local" Manifest. */
+export interface ILocalAdaptation {
+    /** The "type" of that track ("text" == subtitles, closed captions...). */
+    type: "audio" | "video" | "text";
+    /**
+     * If `true`, this track contains an audio description of what is happening
+     * visually on the screen.
+     */
+    audioDescription?: boolean;
+    /** If `true`, this track contains closed captions. */
+    closedCaption?: boolean;
+    /** If `true`, this track contains "forced subtitles". */
+    forcedSubtitles?: boolean;
+    /** The ISO 639-3, ISO 639-2 or ISO 639-1 language code for that track. */
+    language?: string;
+    /** The different qualities this track is available in. */
+    representations: ILocalRepresentation[];
+}
+/** Sub-part of a "local" Manifest, with specific tracks and qualities.  */
+export interface ILocalPeriod {
+    /** Start time at which the Period begins, in seconds. */
+    start: number;
+    /** End time at which the Period ends, in seconds. */
+    end: number;
+    /** The different "tracks" available for this Period. */
+    adaptations: ILocalAdaptation[];
+}
+/**
+ * Format of a "local" Manifest, which allows to play locally-stored contents.
+ *
+ * Special properties also allow to play content that are still being
+ * downloaded.
+ */
+export interface ILocalManifest {
+    /** Required. Confirms that the current object is a "local" Manifest */
+    type: "local";
+    /**
+     * Version of the object, under a `MAJOR.MINOR` format.
+     * MAJOR: A parser compatible to a different major version should not try to
+     *        parse it
+     * MINOR: Retro-compatible format change.
+     *
+     * The exception is the `0` MAJOR version (i.e. experimental versions).
+     * A parser for a version in that major (let's say `0.1`) might be unable to
+     * parse local Manifests of another version (e.g. `0.2`).
+     *
+     * There are two versions defined for now and we are compatible to both:
+     *
+     *   - "0.1": initial version
+     *
+     *   - "0.2": `minimumPosition` and `maximumPosition` are now defined.
+     *            `duration` has been removed.
+     *
+     *            `start` and `duration` from a ILocalPeriod and `time` and
+     *            `duration` from a `ILocalIndexSegment` are now in seconds
+     *            instead of milliseconds.
+     *
+     *   - "0.3": optional `futureSegments` has been added to `ILocalIndex`
+     *            `duration` has been removed.
+     *
+     *            A mandatory `isFinished` boolean should now be set on a
+     *            `ILocalIndex`.
+     */
+    version: string;
+    /**
+     * Minimum position reachable in this content once fully downloaded, in
+     * seconds.
+     *
+     * Set to `0` by default.
+     */
+    minimumPosition?: number;
+    /**
+     * Maximum position reachable in this content once fully downloaded, in
+     * seconds.
+     */
+    maximumPosition: number;
+    /**
+     * Optional Promise used to trigger a Manifest refresh.
+     *
+     * When this Promise resolves, it means that the Local Manifest needs to be
+     * updated.
+     */
+    expired?: Promise<void>;
+    /** Sub-parts of the content, each with specific tracks and qualities.  */
+    periods: ILocalPeriod[];
+    /**
+     * Whether the "local" Manifest generation is finished.
+     * `true` if it is already fully-loaded.
+     * `false` if it is still being downloaded.
+     */
+    isFinished: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/es2017/parsers/manifest/local/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/manifest/local/types.ts"],"names":[],"mappings":"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"}

package/dist/es2017/parsers/manifest/local/types.js

@@ -0,0 +1,16 @@
+/**
+ * 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 {};

package/dist/es2017/parsers/manifest/metaplaylist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { IMetaPlaylist, IMetaPlaylistTextTrack, IParserResponse } from "./metaplaylist_parser";
+import parseMetaPlaylist from "./metaplaylist_parser";
+export default parseMetaPlaylist;
+export type { IMetaPlaylist, IMetaPlaylistTextTrack, IParserResponse };
+//# sourceMappingURL=index.d.ts.map

package/dist/es2017/parsers/manifest/metaplaylist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/manifest/metaplaylist/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,sBAAsB,EACtB,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,iBAAiB,MAAM,uBAAuB,CAAC;AAEtD,eAAe,iBAAiB,CAAC;AACjC,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,eAAe,EAAE,CAAC"}