rx-player 4.4.1 → 4.5.0-dev.2026012301

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

@@ -1,99 +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 "../../../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

@@ -1 +0,0 @@
-{"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

@@ -1,243 +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";
-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

@@ -1,288 +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.
- */
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -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 {};

package/dist/es2017/parsers/manifest/metaplaylist/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 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

@@ -1 +0,0 @@
-{"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"}