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

package/dist/es2017/parsers/manifest/dash/common/indexes/base.js

@@ -0,0 +1,285 @@
+/**
+ * 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 isNullOrUndefined from "../../../../../utils/is_null_or_undefined";
+import { fromIndexTime, getIndexSegmentEnd, toIndexTime, } from "../../../utils/index_helpers";
+import getInitSegment from "./get_init_segment";
+import getSegmentsFromTimeline from "./get_segments_from_timeline";
+import { constructRepresentationUrl } from "./tokens";
+/**
+ * Add a new segment to the index.
+ *
+ * /!\ Mutate the given index
+ * @param {Object} index
+ * @param {Object} segmentInfos
+ * @returns {Boolean} - true if the segment has been added
+ */
+function _addSegmentInfos(index, segmentInfos) {
+    if (segmentInfos.timescale !== index.timescale) {
+        const { timescale } = index;
+        index.timeline.push({
+            start: (segmentInfos.time / segmentInfos.timescale) * timescale,
+            duration: (segmentInfos.duration / segmentInfos.timescale) * timescale,
+            repeatCount: segmentInfos.count === undefined ? 0 : segmentInfos.count,
+            range: segmentInfos.range,
+        });
+    }
+    else {
+        index.timeline.push({
+            start: segmentInfos.time,
+            duration: segmentInfos.duration,
+            repeatCount: segmentInfos.count === undefined ? 0 : segmentInfos.count,
+            range: segmentInfos.range,
+        });
+    }
+    return true;
+}
+export default class BaseRepresentationIndex {
+    /**
+     * @param {Object} index
+     * @param {Object} context
+     */
+    constructor(index, context) {
+        var _a, _b, _c, _d;
+        const { periodStart, periodEnd, representationId, representationBitrate, isEMSGWhitelisted, } = context;
+        const timescale = (_a = index.timescale) !== null && _a !== void 0 ? _a : 1;
+        const presentationTimeOffset = (_b = index.presentationTimeOffset) !== null && _b !== void 0 ? _b : 0;
+        const indexTimeOffset = presentationTimeOffset - periodStart * timescale;
+        const initializationUrl = ((_c = index.initialization) === null || _c === void 0 ? void 0 : _c.media) === undefined
+            ? null
+            : constructRepresentationUrl(index.initialization.media, representationId, representationBitrate);
+        const segmentUrlTemplate = index.media === undefined
+            ? null
+            : constructRepresentationUrl(index.media, representationId, representationBitrate);
+        // TODO If indexRange is either undefined or behind the initialization segment
+        // the following logic will not work.
+        // However taking the nth first bytes like `dash.js` does (where n = 1500) is
+        // not straightforward as we would need to clean-up the segment after that.
+        // The following logic corresponds to 100% of tested cases, so good enough for
+        // now.
+        let range;
+        if (index.initialization !== undefined) {
+            range = index.initialization.range;
+        }
+        else if (index.indexRange !== undefined) {
+            range = [0, index.indexRange[0] - 1];
+        }
+        this._index = {
+            indexRange: index.indexRange,
+            indexTimeOffset,
+            initialization: { url: initializationUrl, range },
+            segmentUrlTemplate,
+            startNumber: index.startNumber,
+            endNumber: index.endNumber,
+            timeline: (_d = index.timeline) !== null && _d !== void 0 ? _d : [],
+            timescale,
+        };
+        this._manifestBoundsCalculator = context.manifestBoundsCalculator;
+        this._scaledPeriodStart = toIndexTime(periodStart, this._index);
+        this._scaledPeriodEnd = isNullOrUndefined(periodEnd)
+            ? undefined
+            : toIndexTime(periodEnd, this._index);
+        this._isInitialized = this._index.timeline.length > 0;
+        this._isEMSGWhitelisted = isEMSGWhitelisted;
+    }
+    /**
+     * Construct init Segment.
+     * @returns {Object}
+     */
+    getInitSegment() {
+        return getInitSegment(this._index, this._isEMSGWhitelisted);
+    }
+    /**
+     * Get the list of segments that are currently available from the `from`
+     * position, in seconds, ending `dur` seconds after that position.
+     *
+     * Note that if not already done, you might need to "initialize" the
+     * `BaseRepresentationIndex` first so that the list of available segments
+     * is known.
+     *
+     * @see isInitialized for more information on `BaseRepresentationIndex`
+     * initialization.
+     * @param {Number} from
+     * @param {Number} dur
+     * @returns {Array.<Object>}
+     */
+    getSegments(from, dur) {
+        return getSegmentsFromTimeline(this._index, from, dur, this._manifestBoundsCalculator, this._scaledPeriodEnd, this._isEMSGWhitelisted);
+    }
+    /**
+     * Returns false as no Segment-Base based index should need to be refreshed.
+     * @returns {Boolean}
+     */
+    shouldRefresh() {
+        return false;
+    }
+    /**
+     * Returns first position in index.
+     * @returns {Number|null}
+     */
+    getFirstAvailablePosition() {
+        const index = this._index;
+        if (index.timeline.length === 0) {
+            return null;
+        }
+        return fromIndexTime(Math.max(this._scaledPeriodStart, index.timeline[0].start), index);
+    }
+    /**
+     * Returns last position in index.
+     * @returns {Number|null}
+     */
+    getLastAvailablePosition() {
+        var _a;
+        const { timeline } = this._index;
+        if (timeline.length === 0) {
+            return null;
+        }
+        const lastTimelineElement = timeline[timeline.length - 1];
+        const lastTime = Math.min(getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd), (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+        return fromIndexTime(lastTime, this._index);
+    }
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    getEnd() {
+        return this.getLastAvailablePosition();
+    }
+    /**
+     * 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 `BaseRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    awaitSegmentBetween() {
+        return false;
+    }
+    /**
+     * Segments in a segmentBase scheme should stay available.
+     * @returns {Boolean|undefined}
+     */
+    isSegmentStillAvailable() {
+        return true;
+    }
+    /**
+     * We do not check for discontinuity in SegmentBase-based indexes.
+     * @returns {null}
+     */
+    checkDiscontinuity() {
+        return null;
+    }
+    /**
+     * Returns `false` as a `BaseRepresentationIndex` should not be dynamic and as
+     * such segments should never fall out-of-sync.
+     * @returns {Boolean}
+     */
+    canBeOutOfSyncError() {
+        return false;
+    }
+    /**
+     * Returns `true` as SegmentBase are not dynamic and as such no new segment
+     * should become available in the future.
+     * @returns {Boolean}
+     */
+    isStillAwaitingFutureSegments() {
+        return false;
+    }
+    /**
+     * No segment in a `BaseRepresentationIndex` are known initially.
+     * It is only defined generally in an "index segment" that will thus need to
+     * be first loaded and parsed.
+     *
+     * Once the index segment or equivalent has been parsed, the `initializeIndex`
+     * method have to be called with the corresponding segment information so the
+     * `BaseRepresentationIndex` can be considered as "initialized" (and so this
+     * method can return `true`).
+     * Until then this method will return `false` and segments linked to that
+     * Representation may be missing.
+     * @returns {Boolean}
+     */
+    isInitialized() {
+        return this._isInitialized;
+    }
+    /**
+     * No segment in a `BaseRepresentationIndex` are known initially.
+     *
+     * It is only defined generally in an "index segment" that will thus need to
+     * be first loaded and parsed.
+     * Until then, this `BaseRepresentationIndex` is considered as `uninitialized`
+     * (@see isInitialized).
+     *
+     * Once that those information are available, the present
+     * `BaseRepresentationIndex` can be "initialized" by adding that parsed
+     * segment information through this method.
+     * @param {Array.<Object>} indexSegments
+     * @returns {Array.<Object>}
+     */
+    initialize(indexSegments) {
+        if (this._isInitialized) {
+            return;
+        }
+        for (let i = 0; i < indexSegments.length; i++) {
+            _addSegmentInfos(this._index, indexSegments[i]);
+        }
+        this._isInitialized = true;
+    }
+    addPredictedSegments() {
+        log.warn("dash", "Cannot add predicted segments to a `BaseRepresentationIndex`");
+    }
+    /**
+     * 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() {
+        const { timeline, timescale } = this._index;
+        const firstElementInTimeline = timeline[0];
+        if (firstElementInTimeline === undefined) {
+            return undefined;
+        }
+        return {
+            duration: firstElementInTimeline.duration / timescale,
+            isPrecize: false,
+        };
+    }
+    /**
+     * Replace in-place this `BaseRepresentationIndex` information by the
+     * information from another one.
+     * @param {Object} newIndex
+     */
+    _replace(newIndex) {
+        this._index = newIndex._index;
+        this._isInitialized = newIndex._isInitialized;
+        this._scaledPeriodEnd = newIndex._scaledPeriodEnd;
+        this._isEMSGWhitelisted = newIndex._isEMSGWhitelisted;
+    }
+    _update() {
+        log.error("dash", "Base RepresentationIndex: Cannot update a SegmentList");
+    }
+}

package/dist/es2017/parsers/manifest/dash/common/indexes/get_init_segment.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 { ISegment } from "../../../../../manifest";
+import type { IEMSG } from "../../../../containers/isobmff";
+/**
+ * Construct init segment for the given index.
+ * @param {Object} index
+ * @param {function} isEMSGWhitelisted
+ * @returns {Object}
+ */
+export default function getInitSegment(index: {
+    timescale: number;
+    initialization?: {
+        url: string | null;
+        range?: [number, number] | undefined;
+    } | undefined;
+    indexRange?: [number, number] | undefined;
+    indexTimeOffset: number;
+}, isEMSGWhitelisted?: (inbandEvent: IEMSG) => boolean): ISegment;
+//# sourceMappingURL=get_init_segment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get_init_segment.d.ts","sourceRoot":"","sources":["../../../../../../../src/parsers/manifest/dash/common/indexes/get_init_segment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAiB,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEvE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,KAAK,EAAE;IACL,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EACX;QAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;KAAE,GAC5D,SAAS,CAAC;IACd,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1C,eAAe,EAAE,MAAM,CAAC;CACzB,EACD,iBAAiB,CAAC,EAAE,CAAC,WAAW,EAAE,KAAK,KAAK,OAAO,GAClD,QAAQ,CAqBV"}

package/dist/es2017/parsers/manifest/dash/common/indexes/get_init_segment.js

@@ -0,0 +1,44 @@
+/**
+ * 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 isNullOrUndefined from "../../../../../utils/is_null_or_undefined";
+/**
+ * Construct init segment for the given index.
+ * @param {Object} index
+ * @param {function} isEMSGWhitelisted
+ * @returns {Object}
+ */
+export default function getInitSegment(index, isEMSGWhitelisted) {
+    var _a;
+    const { initialization } = index;
+    const privateInfos = {};
+    if (isEMSGWhitelisted !== undefined) {
+        privateInfos.isEMSGWhitelisted = isEMSGWhitelisted;
+    }
+    return {
+        id: "init",
+        isInit: true,
+        time: 0,
+        end: 0,
+        duration: 0,
+        timescale: 1,
+        range: !isNullOrUndefined(initialization) ? initialization.range : undefined,
+        indexRange: index.indexRange,
+        url: (_a = initialization === null || initialization === void 0 ? void 0 : initialization.url) !== null && _a !== void 0 ? _a : null,
+        complete: true,
+        privateInfos,
+        timestampOffset: -(index.indexTimeOffset / index.timescale),
+    };
+}

package/dist/es2017/parsers/manifest/dash/common/indexes/get_segments_from_timeline.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { ISegment } from "../../../../../manifest";
+import type { IEMSG } from "../../../../containers/isobmff";
+import type { IIndexSegment } from "../../../utils/index_helpers";
+import type ManifestBoundsCalculator from "../manifest_bounds_calculator";
+/**
+ * Get a list of Segments for the time range wanted.
+ * @param {Object} index - index object, constructed by parsing the manifest.
+ * @param {number} from - starting timestamp wanted, in seconds
+ * @param {number} durationWanted - duration wanted, in seconds
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @param {function} isEMSGWhitelisted
+ * @returns {Array.<Object>}
+ */
+export default function getSegmentsFromTimeline(index: {
+    availabilityTimeComplete?: boolean | undefined;
+    availabilityTimeOffset?: number | undefined;
+    segmentUrlTemplate: string | null;
+    startNumber?: number | undefined;
+    endNumber?: number | undefined;
+    timeline: IIndexSegment[];
+    timescale: number;
+    indexTimeOffset: number;
+}, from: number, durationWanted: number, manifestBoundsCalculator: ManifestBoundsCalculator, scaledPeriodEnd: number | undefined, isEMSGWhitelisted: (inbandEvent: IEMSG) => boolean): ISegment[];
+//# sourceMappingURL=get_segments_from_timeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get_segments_from_timeline.d.ts","sourceRoot":"","sources":["../../../../../../../src/parsers/manifest/dash/common/indexes/get_segments_from_timeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,OAAO,KAAK,wBAAwB,MAAM,+BAA+B,CAAC;AAqB1E;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAC7C,KAAK,EAAE;IACL,wBAAwB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC/C,sBAAsB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;CACzB,EACD,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,EACtB,wBAAwB,EAAE,wBAAwB,EAClD,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,iBAAiB,EAAE,CAAC,WAAW,EAAE,KAAK,KAAK,OAAO,GACjD,QAAQ,EAAE,CAiFZ"}

package/dist/es2017/parsers/manifest/dash/common/indexes/get_segments_from_timeline.js

@@ -0,0 +1,109 @@
+/**
+ * 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 { calculateRepeat, toIndexTime } from "../../../utils/index_helpers";
+import { createDashUrlDetokenizer } from "./tokens";
+/**
+ * For the given start time and duration of a timeline element, calculate how
+ * much this element should be repeated to contain the time given.
+ * 0 being the same element, 1 being the next one etc.
+ * @param {Number} segmentStartTime
+ * @param {Number} segmentDuration
+ * @param {Number} wantedTime
+ * @returns {Number}
+ */
+function getWantedRepeatIndex(segmentStartTime, segmentDuration, wantedTime) {
+    const diff = wantedTime - segmentStartTime;
+    return diff > 0 ? Math.floor(diff / segmentDuration) : 0;
+}
+/**
+ * Get a list of Segments for the time range wanted.
+ * @param {Object} index - index object, constructed by parsing the manifest.
+ * @param {number} from - starting timestamp wanted, in seconds
+ * @param {number} durationWanted - duration wanted, in seconds
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @param {function} isEMSGWhitelisted
+ * @returns {Array.<Object>}
+ */
+export default function getSegmentsFromTimeline(index, from, durationWanted, manifestBoundsCalculator, scaledPeriodEnd, isEMSGWhitelisted) {
+    var _a;
+    const maximumTime = manifestBoundsCalculator.getEstimatedMaximumPosition((_a = index.availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0);
+    const wantedMaximum = Math.min(from + durationWanted, maximumTime !== null && maximumTime !== void 0 ? maximumTime : Infinity);
+    const scaledUp = toIndexTime(from, index);
+    const scaledTo = toIndexTime(wantedMaximum, index);
+    const { timeline, timescale, segmentUrlTemplate, startNumber, endNumber } = index;
+    let currentNumber = startNumber !== null && startNumber !== void 0 ? startNumber : 1;
+    const segments = [];
+    const timelineLength = timeline.length;
+    for (let i = 0; i < timelineLength; i++) {
+        const timelineItem = timeline[i];
+        const { duration, start, range } = timelineItem;
+        let maxRepeatTime;
+        if (maximumTime === undefined) {
+            maxRepeatTime = scaledPeriodEnd;
+        }
+        else {
+            maxRepeatTime = Math.min(maximumTime * timescale, scaledPeriodEnd !== null && scaledPeriodEnd !== void 0 ? scaledPeriodEnd : Infinity);
+        }
+        const repeat = calculateRepeat(timelineItem, timeline[i + 1], maxRepeatTime);
+        const complete = index.availabilityTimeComplete !== false ||
+            (i !== timelineLength - 1 && repeat !== 0);
+        let segmentNumberInCurrentRange = getWantedRepeatIndex(start, duration, scaledUp);
+        let segmentTime = start + segmentNumberInCurrentRange * duration;
+        while (segmentTime < scaledTo && segmentNumberInCurrentRange <= repeat) {
+            const segmentNumber = currentNumber + segmentNumberInCurrentRange;
+            if (endNumber !== undefined && segmentNumber > endNumber) {
+                break;
+            }
+            const detokenizedURL = segmentUrlTemplate === null
+                ? null
+                : createDashUrlDetokenizer(segmentTime, segmentNumber)(segmentUrlTemplate);
+            let time = segmentTime - index.indexTimeOffset;
+            let realDuration = duration;
+            if (time < 0) {
+                realDuration = duration + time; // Remove from duration the part before `0`
+                time = 0;
+            }
+            const segment = {
+                id: String(segmentTime),
+                time: time / timescale,
+                end: (time + realDuration) / timescale,
+                duration: realDuration / timescale,
+                isInit: false,
+                range,
+                timescale: 1,
+                url: detokenizedURL,
+                number: segmentNumber,
+                timestampOffset: -(index.indexTimeOffset / timescale),
+                complete,
+                privateInfos: { isEMSGWhitelisted },
+            };
+            segments.push(segment);
+            // update segment number and segment time for the next segment
+            segmentNumberInCurrentRange++;
+            segmentTime = start + segmentNumberInCurrentRange * duration;
+        }
+        if (segmentTime >= scaledTo) {
+            // we reached ``scaledTo``, we're done
+            return segments;
+        }
+        currentNumber += repeat + 1;
+        if (endNumber !== undefined && currentNumber > endNumber) {
+            return segments;
+        }
+    }
+    return segments;
+}

package/dist/es2017/parsers/manifest/dash/common/indexes/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { IBaseIndexContextArgument } from "./base";
+import BaseRepresentationIndex from "./base";
+import type { IListIndexContextArgument } from "./list";
+import ListRepresentationIndex from "./list";
+import type { ITemplateIndexContextArgument } from "./template";
+import TemplateRepresentationIndex from "./template";
+import type { ITimelineIndexContextArgument } from "./timeline";
+import TimelineRepresentationIndex from "./timeline";
+export type { IBaseIndexContextArgument, IListIndexContextArgument, ITemplateIndexContextArgument, ITimelineIndexContextArgument, };
+export { BaseRepresentationIndex, ListRepresentationIndex, TemplateRepresentationIndex, TimelineRepresentationIndex, };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/parsers/manifest/dash/common/indexes/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC;AACxD,OAAO,uBAAuB,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC;AACxD,OAAO,uBAAuB,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,2BAA2B,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,2BAA2B,MAAM,YAAY,CAAC;AAErD,YAAY,EACV,yBAAyB,EACzB,yBAAyB,EACzB,6BAA6B,EAC7B,6BAA6B,GAC9B,CAAC;AACF,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,EAC3B,2BAA2B,GAC5B,CAAC"}

package/dist/es2017/parsers/manifest/dash/common/indexes/index.js

@@ -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 BaseRepresentationIndex from "./base";
+import ListRepresentationIndex from "./list";
+import TemplateRepresentationIndex from "./template";
+import TimelineRepresentationIndex from "./timeline";
+export { BaseRepresentationIndex, ListRepresentationIndex, TemplateRepresentationIndex, TimelineRepresentationIndex, };