rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/es2017/text_displayer/html/text_track_cues_store.js

@@ -1,358 +0,0 @@
-import assert from "../../utils/assert";
-import { areNearlyEqual, getCuesAfter, getCuesBefore, removeCuesInfosBetween, } from "./utils";
-/**
- * first or last IHTMLCue in a group can have a slighlty different start
- * or end time than the start or end time of the ICuesGroup due to parsing
- * approximation.
- * DELTA_CUES_GROUP defines the tolerance level when comparing the start/end
- * of a IHTMLCue to the start/end of a ICuesGroup.
- * Having this value too high may lead to have unwanted subtitle displayed
- * Having this value too low may lead to have subtitles not displayed
- */
-const DELTA_CUES_GROUP = 1e-3;
-/**
- * segment_duration / RELATIVE_DELTA_RATIO = relative_delta
- *
- * relative_delta is the tolerance to determine if two segements are the same
- */
-const RELATIVE_DELTA_RATIO = 5;
-/**
- * Manage a buffer of text track cues.
- * Allows to add, remove and recuperate cues at given times.
- * @class TextTrackCuesStore
- */
-export default class TextTrackCuesStore {
-    constructor() {
-        this._cuesBuffer = [];
-    }
-    isEmpty() {
-        return this._cuesBuffer.length === 0;
-    }
-    /**
-     * Get corresponding cue(s) for the given time.
-     * A cue is an object with three properties:
-     *   - start {Number}: start time for which the cue should be displayed.
-     *   - end {Number}: end time for which the cue should be displayed.
-     *   - element {HTMLElement}: The cue to diplay
-     *
-     * We do not mutate individual cue here.
-     * That is, if the ``get`` method returns the same cue's reference than a
-     * previous ``get`` call, its properties are guaranteed to have the exact same
-     * values than before, if you did not mutate it on your side.
-     * The inverse is true, if the values are the same than before, the reference
-     * will stay the same (this is useful to easily check if the DOM should be
-     * updated, for example).
-     *
-     * @param {Number} time
-     * @returns {Array.<HTMLElement>} - The cues that need to be displayed at that
-     * time.
-     */
-    get(time) {
-        const cuesBuffer = this._cuesBuffer;
-        const ret = [];
-        // begins at the end as most of the time the player will ask for the last
-        // CuesGroup
-        for (let cueIdx = cuesBuffer.length - 1; cueIdx >= 0; cueIdx--) {
-            const segment = cuesBuffer[cueIdx];
-            if (time < segment.end && time >= segment.start) {
-                const cues = segment.cues;
-                for (let j = 0; j < cues.length; j++) {
-                    if (time >= cues[j].start && time < cues[j].end) {
-                        ret.push(cues[j].element);
-                    }
-                }
-                // first or last IHTMLCue in a group can have a slighlty different start
-                // or end time than the start or end time of the ICuesGroup due to parsing
-                // approximation.
-                // Add a tolerance of 1ms to fix this issue
-                if (ret.length === 0 && cues.length > 0) {
-                    for (let j = 0; j < cues.length; j++) {
-                        if (areNearlyEqual(time, cues[j].start, DELTA_CUES_GROUP)
-                            || areNearlyEqual(time, cues[j].end, DELTA_CUES_GROUP)) {
-                            ret.push(cues[j].element);
-                        }
-                    }
-                }
-                return ret;
-            }
-        }
-        return [];
-    }
-    /**
-     * Remove cue from a certain range of time.
-     * @param {Number} from
-     * @param {Number} _to
-     */
-    remove(from, _to) {
-        if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-            assert(from >= 0);
-            assert(_to >= 0);
-            assert(_to > from);
-        }
-        const to = Math.max(from, _to);
-        const cuesBuffer = this._cuesBuffer;
-        for (let cueIdx = 0; cueIdx < cuesBuffer.length; cueIdx++) {
-            if (cuesBuffer[cueIdx].end > from) {
-                // this cuesInfos is concerned by the remove
-                const startCuesInfos = cuesBuffer[cueIdx];
-                if (startCuesInfos.start >= to) {
-                    // our cuesInfos is strictly after this interval, we have nothing to do
-                    return;
-                }
-                if (startCuesInfos.end >= to) {
-                    // our cuesInfos ends after `to`, we have to keep the end of it
-                    if (from <= startCuesInfos.start) {
-                        // from -> to only remove the start of startCuesInfos
-                        startCuesInfos.cues = getCuesAfter(startCuesInfos.cues, to);
-                        startCuesInfos.start = to;
-                    }
-                    else {
-                        // from -> to is in the middle part of startCuesInfos
-                        const [cuesInfos1, cuesInfos2] = removeCuesInfosBetween(startCuesInfos, from, to);
-                        this._cuesBuffer[cueIdx] = cuesInfos1;
-                        cuesBuffer.splice(cueIdx + 1, 0, cuesInfos2);
-                    }
-                    // No cuesInfos can be concerned after this one, we can quit
-                    return;
-                }
-                // Else remove all part after `from`
-                if (startCuesInfos.start >= from) {
-                    // all the segment is concerned
-                    cuesBuffer.splice(cueIdx, 1);
-                    cueIdx--; // one less element, we have to decrement the loop
-                }
-                else {
-                    // only the end is concerned
-                    startCuesInfos.cues = getCuesBefore(startCuesInfos.cues, from);
-                    startCuesInfos.end = Math.max(from, startCuesInfos.start);
-                }
-            }
-        }
-    }
-    /**
-     * Insert new cues in our text buffer.
-     * cues is an array of objects with three properties:
-     *   - start {Number}: start time for which the cue should be displayed.
-     *   - end {Number}: end time for which the cue should be displayed.
-     *   - element {HTMLElement}: The cue to diplay
-     *
-     * @param {Array.<Object>} cues - CuesGroups, array of objects with the
-     * following properties:
-     *   - start {Number}: the time at which the cue will start to be displayed
-     *   - end {Number}: the time at which the cue will end to be displayed
-     *   - cue {HTMLElement}: The cue
-     * @param {Number} start - Start time at which the CuesGroup applies.
-     * This is different than the start of the first cue to display in it, this
-     * has more to do with the time at which the _text segment_ starts.
-     * @param {Number} end - End time at which the CuesGroup applies.
-     * This is different than the end of the last cue to display in it, this
-     * has more to do with the time at which the _text segment_ ends.
-     *
-     * TODO add securities to ensure that:
-     *   - the start of a CuesGroup is inferior or equal to the start of the first
-     *     cue in it
-     *   - the end of a CuesGroup is superior or equal to the end of the last
-     *     cue in it
-     * If those requirements are not met, we could delete some cues when adding
-     * a CuesGroup before/after. Find a solution.
-     */
-    insert(cues, start, end) {
-        const cuesBuffer = this._cuesBuffer;
-        const cuesInfosToInsert = { start, end, cues };
-        // it's preferable to have a delta depending on the duration of the segment
-        // if the delta is one fifth of the length of the segment:
-        // a segment of [0, 2] is the "same" segment as [0, 2.1]
-        // but [0, 0.04] is not the "same" segement as [0,04, 0.08]
-        const relativeDelta = Math.abs(start - end) / RELATIVE_DELTA_RATIO;
-        /**
-         * Called when we found the index of the next cue relative to the cue we
-         * want to insert (that is a cue starting after its start or at the same
-         * time but ending strictly after its end).
-         * Will insert the cue at the right place and update the next cue
-         * accordingly.
-         * @param {number} indexOfNextCue
-         */
-        function onIndexOfNextCueFound(indexOfNextCue) {
-            const nextCue = cuesBuffer[indexOfNextCue];
-            if (nextCue === undefined || // no cue
-                areNearlyEqual(cuesInfosToInsert.end, nextCue.end, relativeDelta)) // samey end
-             {
-                //   ours:            |AAAAA|
-                //   the current one: |BBBBB|
-                //   Result:          |AAAAA|
-                cuesBuffer[indexOfNextCue] = cuesInfosToInsert;
-            }
-            else if (nextCue.start >= cuesInfosToInsert.end) {
-                // Either
-                //   ours:            |AAAAA|
-                //   the current one:         |BBBBBB|
-                //   Result:          |AAAAA| |BBBBBB|
-                // Or:
-                //   ours:            |AAAAA|
-                //   the current one:       |BBBBBB|
-                //   Result:          |AAAAA|BBBBBB|
-                // Add ours before
-                cuesBuffer.splice(indexOfNextCue, 0, cuesInfosToInsert);
-            }
-            else {
-                // Either
-                //   ours:            |AAAAA|
-                //   the current one: |BBBBBBBB|
-                //   Result:          |AAAAABBB|
-                // Or:
-                //   ours:            |AAAAA|
-                //   the current one:    |BBBBB|
-                //   Result:          |AAAAABBB|
-                nextCue.cues = getCuesAfter(nextCue.cues, cuesInfosToInsert.end);
-                nextCue.start = cuesInfosToInsert.end;
-                cuesBuffer.splice(indexOfNextCue, 0, cuesInfosToInsert);
-            }
-        }
-        for (let cueIdx = 0; cueIdx < cuesBuffer.length; cueIdx++) {
-            let cuesInfos = cuesBuffer[cueIdx];
-            if (start < cuesInfos.end) {
-                if (areNearlyEqual(start, cuesInfos.start, relativeDelta)) {
-                    if (areNearlyEqual(end, cuesInfos.end, relativeDelta)) {
-                        // exact same segment
-                        //   ours:            |AAAAA|
-                        //   the current one: |BBBBB|
-                        //   Result:          |AAAAA|
-                        // Which means:
-                        //   1. replace the current cue with ours
-                        cuesBuffer[cueIdx] = cuesInfosToInsert;
-                        return;
-                    }
-                    else if (end < cuesInfos.end) {
-                        // our cue overlaps with the current one:
-                        //   ours:            |AAAAA|
-                        //   the current one: |BBBBBBBB|
-                        //   Result:          |AAAAABBB|
-                        // Which means:
-                        //   1. remove some cues at the start of the current one
-                        //   2. update start of current one
-                        //   3. add ours before the current one
-                        cuesInfos.cues = getCuesAfter(cuesInfos.cues, end);
-                        cuesInfos.start = end;
-                        cuesBuffer.splice(cueIdx, 0, cuesInfosToInsert);
-                        return;
-                    }
-                    // our cue goes beyond the current one:
-                    //   ours:            |AAAAAAA|
-                    //   the current one: |BBBB|...
-                    //   Result:          |AAAAAAA|
-                    // Here we have to delete any cuesInfos which end before ours end,
-                    // and see about the following one.
-                    do {
-                        cuesBuffer.splice(cueIdx, 1);
-                        cuesInfos = cuesBuffer[cueIdx];
-                    } while (cuesInfos !== undefined && end > cuesInfos.end);
-                    onIndexOfNextCueFound(cueIdx);
-                    return;
-                }
-                else if (start < cuesInfos.start) {
-                    if (end < cuesInfos.start) {
-                        // our cue goes strictly before the current one:
-                        //   ours:            |AAAAAAA|
-                        //   the current one:           |BBBB|
-                        //   Result:          |AAAAAAA| |BBBB|
-                        // Which means:
-                        //   - add ours before the current one
-                        cuesBuffer.splice(cueIdx, 0, cuesInfosToInsert);
-                        return;
-                    }
-                    else if (areNearlyEqual(end, cuesInfos.start, relativeDelta)) {
-                        // our cue goes just before the current one:
-                        //   ours:            |AAAAAAA|
-                        //   the current one:         |BBBB|
-                        //   Result:          |AAAAAAA|BBBB|
-                        // Which means:
-                        //   - update start time of the current one to be sure
-                        //   - add ours before the current one
-                        cuesInfos.start = end;
-                        cuesBuffer.splice(cueIdx, 0, cuesInfosToInsert);
-                        return;
-                    }
-                    else if (areNearlyEqual(end, cuesInfos.end, relativeDelta)) {
-                        //   ours:            |AAAAAAA|
-                        //   the current one:    |BBBB|
-                        //   Result:          |AAAAAAA|
-                        // Replace
-                        cuesBuffer.splice(cueIdx, 1, cuesInfosToInsert);
-                        return;
-                    }
-                    else if (end < cuesInfos.end) {
-                        //   ours:            |AAAAAAA|
-                        //   the current one:     |BBBBB|
-                        //   Result:          |AAAAAAABB|
-                        cuesInfos.cues = getCuesAfter(cuesInfos.cues, end);
-                        cuesInfos.start = end;
-                        cuesBuffer.splice(cueIdx, 0, cuesInfosToInsert);
-                        return;
-                    }
-                    //   ours:            |AAAAAAA|
-                    //   the current one:   |BBB|...
-                    //   Result:          |AAAAAAA|...
-                    do {
-                        cuesBuffer.splice(cueIdx, 1);
-                        cuesInfos = cuesBuffer[cueIdx];
-                    } while (cuesInfos !== undefined && end > cuesInfos.end);
-                    onIndexOfNextCueFound(cueIdx);
-                    return;
-                }
-                // else -> start > cuesInfos.start
-                if (areNearlyEqual(cuesInfos.end, end, relativeDelta)) {
-                    //   ours:              |AAAAAA|
-                    //   the current one: |BBBBBBBB|
-                    //   Result:          |BBAAAAAA|
-                    cuesInfos.cues = getCuesBefore(cuesInfos.cues, start);
-                    cuesInfos.end = start;
-                    cuesBuffer.splice(cueIdx + 1, 0, cuesInfosToInsert);
-                    return;
-                }
-                else if (cuesInfos.end > end) {
-                    //   ours:              |AAAAAA|
-                    //   the current one: |BBBBBBBBBBB|
-                    //   Result:          |BBAAAAAABBB|
-                    const [cuesInfos1, cuesInfos2] = removeCuesInfosBetween(cuesInfos, start, end);
-                    this._cuesBuffer[cueIdx] = cuesInfos1;
-                    cuesBuffer.splice(cueIdx + 1, 0, cuesInfosToInsert);
-                    cuesBuffer.splice(cueIdx + 2, 0, cuesInfos2);
-                    return;
-                }
-                else {
-                    //   ours:              |AAAAAA|
-                    //   the current one: |BBBBB|...
-                    //   Result:          |BBAAAAAA|...
-                    cuesInfos.cues = getCuesBefore(cuesInfos.cues, start);
-                    cuesInfos.end = start;
-                    const nextCueIdx = cueIdx + 1;
-                    cuesInfos = cuesBuffer[nextCueIdx];
-                    while (cuesInfos !== undefined && end > cuesInfos.end) {
-                        cuesBuffer.splice(nextCueIdx, 1);
-                        cuesInfos = cuesBuffer[nextCueIdx];
-                    }
-                    onIndexOfNextCueFound(nextCueIdx);
-                    return;
-                }
-            }
-        }
-        if (cuesBuffer.length) {
-            const lastCue = cuesBuffer[cuesBuffer.length - 1];
-            if (areNearlyEqual(lastCue.end, start, relativeDelta)) {
-                // Match the end of the previous cue to the start of the following one
-                // if they are close enough. If there is a small gap between two segments
-                // it can lead to having no subtitles for a short time, this is noticeable when
-                // two successive segments displays the same text, making it diseappear
-                // and reappear quickly, which gives the impression of blinking
-                //
-                //   ours:                   |AAAAA|
-                //   the current one: |BBBBB|...
-                //   Result:          |BBBBBBBAAAAA|
-                lastCue.end = start;
-            }
-        }
-        // no cues group has the end after our current start.
-        // These cues should be the last one
-        cuesBuffer.push(cuesInfosToInsert);
-    }
-}

package/dist/es2017/text_displayer/html/update_proportional_elements.js

@@ -1,62 +0,0 @@
-/**
- * Update size of element which are proportional to the current text track
- * element.
- * Returns `true` if at least a single styling information is proportional,
- * `false` otherwise.
- * @param {number} currentHeight
- * @param {number} currentWidth
- * @param {Object} resolution
- * @param {HTMLElement} textTrackElement
- * @returns {boolean}
- */
-export default function updateProportionalElements(currentHeight, currentWidth, resolution, textTrackElement) {
-    const cellUnit = [currentWidth / resolution.columns,
-        currentHeight / resolution.rows];
-    const proportElts = textTrackElement.getElementsByClassName("proportional-style");
-    for (let eltIdx = 0; eltIdx < proportElts.length; eltIdx++) {
-        const elt = proportElts[eltIdx];
-        if (elt instanceof HTMLElement) {
-            const fontSizeVal = elt.getAttribute("data-proportional-font-size");
-            if (fontSizeVal !== null && !isNaN(+fontSizeVal)) {
-                elt.style.fontSize = String(+fontSizeVal * cellUnit[1]) + "px";
-            }
-            const widthVal = elt.getAttribute("data-proportional-width");
-            if (widthVal !== null && !isNaN(+widthVal)) {
-                elt.style.width = String(+widthVal * cellUnit[0]) + "px";
-            }
-            const heightVal = elt.getAttribute("data-proportional-height");
-            if (heightVal !== null && !isNaN(+heightVal)) {
-                elt.style.height = String(+heightVal * cellUnit[1]) + "px";
-            }
-            const lineHeightVal = elt.getAttribute("data-proportional-line-height");
-            if (lineHeightVal !== null && !isNaN(+lineHeightVal)) {
-                elt.style.lineHeight = String(+lineHeightVal * cellUnit[1]) + "px";
-            }
-            const leftVal = elt.getAttribute("data-proportional-left");
-            if (leftVal !== null && !isNaN(+leftVal)) {
-                elt.style.left = String(+leftVal * cellUnit[0]) + "px";
-            }
-            const topVal = elt.getAttribute("data-proportional-top");
-            if (topVal !== null && !isNaN(+topVal)) {
-                elt.style.top = String(+topVal * cellUnit[1]) + "px";
-            }
-            const paddingTopVal = elt.getAttribute("data-proportional-padding-top");
-            if (paddingTopVal !== null && !isNaN(+paddingTopVal)) {
-                elt.style.paddingTop = String(+paddingTopVal * cellUnit[1]) + "px";
-            }
-            const paddingBottomVal = elt.getAttribute("data-proportional-padding-bottom");
-            if (paddingBottomVal !== null && !isNaN(+paddingBottomVal)) {
-                elt.style.paddingBottom = String(+paddingBottomVal * cellUnit[1]) + "px";
-            }
-            const paddingLeftVal = elt.getAttribute("data-proportional-padding-left");
-            if (paddingLeftVal !== null && !isNaN(+paddingLeftVal)) {
-                elt.style.paddingLeft = String(+paddingLeftVal * cellUnit[0]) + "px";
-            }
-            const paddingRightVal = elt.getAttribute("data-proportional-padding-right");
-            if (paddingRightVal !== null && !isNaN(+paddingRightVal)) {
-                elt.style.paddingRight = String(+paddingRightVal * cellUnit[0]) + "px";
-            }
-        }
-    }
-    return proportElts.length > 0;
-}

package/dist/es2017/text_displayer/html/utils.js

@@ -1,107 +0,0 @@
-/**
- * Maximum time difference, in seconds, between two text segment's start times
- * and/or end times for them to be considered the same.
- *
- * For example for two segments s1 and s2 which have a start time respectively
- * of st1 and st2 and end time of et1 and et2:
- *   - if both the absolute difference between st1 and st2 AND the one between
- *     et1 and et2 is inferior or equal to the MAX_DELTA_BUFFER_TIME, s1 and s2
- *     are considered to target the exact same time. As a consequence, if s2 is
- *     added after s1 in the buffer, s1 will be completely replaced by it and
- *     vice-versa.
- *   - if only one of the two (absolute difference between st1 and st2 OR et1
- *     and et2) is inferior to the MAX_DELTA_BUFFER_TIME then the last added
- *     is not completely considered the same. It WILL still replace - either
- *     partially or completely (depending on the sign of the other difference) -
- *     the previously added segment.
- *   - if both differences are strictly superior to the MAX_DELTA_BUFFER_TIME,
- *     then they are not considered to have the same start nor the same end.
- *     They can still overlap however, and MIGHT thus still replace partially
- *     or completely each other.
- *
- * Setting a value too low might lead to two segments targeting the same time,
- * both being present in the buffer. In worst case scenarios, this could lead
- * to indicate that an unwanted text track is still here (theorically though,
- * this is a case that should never happen for reasons that might be too long
- * to explain here).
- *
- * Setting a value too high might lead to two segments targeting different times
- * to be wrongly believed to target the same time. In worst case scenarios, this
- * could lead to wanted text tracks being removed.
- *
- * When comparing 2 segments s1 and s2, you may want to take into account the duration
- * of the segments:
- *   - if s1 is [0, 2] and s2 is [0, 2.1] s1 and s2 can be considered as nearly equal as
- *     there is a relative difference of: (2.1-2) / 2 = 5%;
- *     Formula: (end_s1 - end_s2) / duration_s2 = relative_difference
- *   - if s1 is [0, 0.04] and s2 is [0.04, 0.08] s1 and s2 may not considered as nearly
- *     equal as there is a relative difference of: (0.04-0.08) / 0.04 = 100%
- *
- * To compare relatively to the duration of a segment you can provide and additional
- * parameter "delta" that remplace MAX_DELTA_BUFFER_TIME.
- * If parameter "delta" is higher than MAX_DELTA_BUFFER_TIME, MAX_DELTA_BUFFER_TIME
- * is used instead of delta. This ensure that segments are nearly equal when comparing
- * relatively AND absolutely.
- *
- * @type Number
- */
-const MAX_DELTA_BUFFER_TIME = 0.2;
-/**
- * @see MAX_DELTA_BUFFER_TIME
- * @param {Number} a
- * @param {Number} b
- * @param {Number} delta
- * @returns {Boolean}
- */
-export function areNearlyEqual(a, b, delta = MAX_DELTA_BUFFER_TIME) {
-    return Math.abs(a - b) <= Math.min(delta, MAX_DELTA_BUFFER_TIME);
-}
-/**
- * Get all cues which have data before the given time.
- * @param {Object} cues
- * @param {Number} time
- * @returns {Array.<Object>}
- */
-export function getCuesBefore(cues, time) {
-    for (let i = cues.length - 1; i >= 0; i--) {
-        const cue = cues[i];
-        if (cue.start < time) {
-            return cues.slice(0, i + 1);
-        }
-    }
-    return [];
-}
-/**
- * Get all cues which have data after the given time.
- * @param {Object} cues
- * @param {Number} time
- * @returns {Array.<Object>}
- */
-export function getCuesAfter(cues, time) {
-    for (let i = 0; i < cues.length; i++) {
-        const cue = cues[i];
-        if (cue.end > time) {
-            return cues.slice(i, cues.length);
-        }
-    }
-    return [];
-}
-/**
- * @param {Object} cuesInfos
- * @param {Number} start
- * @param {Number} end
- * @returns {Array.<Object>}
- */
-export function removeCuesInfosBetween(cuesInfos, start, end) {
-    const endCuesInfos1 = Math.max(cuesInfos.start, start);
-    const cues1 = getCuesBefore(cuesInfos.cues, start);
-    const cuesInfos1 = { start: cuesInfos.start,
-        end: endCuesInfos1,
-        cues: cues1 };
-    const startCuesInfos2 = Math.min(end, cuesInfos.end);
-    const cues2 = getCuesAfter(cuesInfos.cues, end);
-    const cuesInfos2 = { start: startCuesInfos2,
-        end: cuesInfos.end,
-        cues: cues2 };
-    return [cuesInfos1, cuesInfos2];
-}

package/dist/es2017/text_displayer/index.d.ts

@@ -1,2 +0,0 @@
-import { ITextDisplayer, ITextDisplayerData } from "./types";
-export { ITextDisplayer, ITextDisplayerData, };

package/dist/es2017/text_displayer/manual_time_ranges.js

@@ -1,48 +0,0 @@
-import assert from "../utils/assert";
-import { insertInto, keepRangeIntersection, } from "../utils/ranges";
-/**
- * Simulate TimeRanges as returned by SourceBuffer.prototype.buffered.
- * Add an "insert" and "remove" methods to manually update it.
- * @class ManualTimeRanges
- */
-export default class ManualTimeRanges {
-    constructor() {
-        this._ranges = [];
-        this.length = 0;
-    }
-    insert(start, end) {
-        if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-            assert(start >= 0, "invalid start time");
-            assert(end - start > 0, "invalid end time");
-        }
-        insertInto(this._ranges, { start, end });
-        this.length = this._ranges.length;
-    }
-    remove(start, end) {
-        if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-            assert(start >= 0, "invalid start time");
-            assert(end - start > 0, "invalid end time");
-        }
-        const rangesToIntersect = [];
-        if (start > 0) {
-            rangesToIntersect.push({ start: 0, end: start });
-        }
-        if (end < Infinity) {
-            rangesToIntersect.push({ start: end, end: Infinity });
-        }
-        this._ranges = keepRangeIntersection(this._ranges, rangesToIntersect);
-        this.length = this._ranges.length;
-    }
-    start(index) {
-        if (index >= this._ranges.length) {
-            throw new Error("INDEX_SIZE_ERROR");
-        }
-        return this._ranges[index].start;
-    }
-    end(index) {
-        if (index >= this._ranges.length) {
-            throw new Error("INDEX_SIZE_ERROR");
-        }
-        return this._ranges[index].end;
-    }
-}

package/dist/es2017/text_displayer/native/native_parsers.d.ts

@@ -1,11 +0,0 @@
-import { ICompatVTTCue } from "../../compat";
-/**
- * Convert text track data into timed VTT Cues.
- * @param {string} type - Text track format wanted
- * @param {string} data - Text track data
- * @param {Number} timestampOffset - offset to apply to every timed text
- * @param {string} [language] - language of the text tracks
- * @returns {Array.<VTTCue>}
- * @throws Error - Throw if no parser is found for the given type
- */
-export default function parseTextTrackToCues(type: string, data: string, timestampOffset: number, language?: string): Array<ICompatVTTCue | TextTrackCue>;

package/dist/es2017/text_displayer/native/native_parsers.js

@@ -1,22 +0,0 @@
-import features from "../../features";
-import log from "../../log";
-/**
- * Convert text track data into timed VTT Cues.
- * @param {string} type - Text track format wanted
- * @param {string} data - Text track data
- * @param {Number} timestampOffset - offset to apply to every timed text
- * @param {string} [language] - language of the text tracks
- * @returns {Array.<VTTCue>}
- * @throws Error - Throw if no parser is found for the given type
- */
-export default function parseTextTrackToCues(type, data, timestampOffset, language) {
-    log.debug("NTSB: Finding parser for native text tracks:", type);
-    const parser = features.nativeTextTracksParsers[type];
-    if (typeof parser !== "function") {
-        throw new Error("no parser found for the given text track");
-    }
-    log.debug("NTSB: Parser found, parsing...");
-    const parsed = parser(data, timestampOffset, language);
-    log.debug("NTSB: Parsed successfully!", parsed.length);
-    return parsed;
-}

package/dist/es2017/text_displayer/native/native_text_displayer.d.ts

@@ -1,56 +0,0 @@
-import { IRange } from "../../utils/ranges";
-import { ITextDisplayer, ITextDisplayerData } from "../types";
-/**
- * Implementation of an `ITextDisplayer` for "native" text tracks.
- * "Native" text tracks rely on a `<track>` HTMLElement and its associated
- * expected behavior to display subtitles synchronized to the video.
- * @class NativeTextDisplayer
- */
-export default class NativeTextDisplayer implements ITextDisplayer {
-    private readonly _videoElement;
-    private readonly _track;
-    private readonly _trackElement;
-    private _buffered;
-    /**
-     * @param {HTMLMediaElement} videoElement
-     */
-    constructor(videoElement: HTMLMediaElement);
-    /**
-     * Push text segment to the NativeTextDisplayer.
-     * @param {Object} infos
-     * @returns {Object}
-     */
-    pushTextData(infos: ITextDisplayerData): IRange[];
-    /**
-     * Remove buffered data.
-     * @param {number} start - start position, in seconds
-     * @param {number} end - end position, in seconds
-     * @returns {Object}
-     */
-    removeBuffer(start: number, end: number): IRange[];
-    /**
-     * Returns the currently buffered data, in a TimeRanges object.
-     * @returns {Array.<Object>}
-     */
-    getBufferedRanges(): IRange[];
-    reset(): void;
-    stop(): void;
-    private _removeData;
-}
-/** Data of chunks that should be pushed to the NativeTextDisplayer. */
-export interface INativeTextTracksBufferSegmentData {
-    /** The text track data, in the format indicated in `type`. */
-    data: string;
-    /** The format of `data` (examples: "ttml", "srt" or "vtt") */
-    type: string;
-    /**
-     * Language in which the text track is, as a language code.
-     * This is mostly needed for "sami" subtitles, to know which cues can / should
-     * be parsed.
-     */
-    language?: string | undefined;
-    /** start time from which the segment apply, in seconds. */
-    start?: number | undefined;
-    /** end time until which the segment apply, in seconds. */
-    end?: number | undefined;
-}