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

package/dist/es2017/transports/utils/infer_segment_container.js

@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+/**
+ * Guess the type of container a segment is in based on Manifest information.
+ *
+ * Returns:
+ *   - "mp4" if we can say with confidence the segment will be in an mp4 format
+ *   - "webm" if we can say with confidence the segment will be in a webm format
+ *   - `undefined` if we cannot say with confidence in which container the
+ *     segment will be in.
+ * @param {string} adaptationType
+ * @param {string} mimeType
+ * @returns {string | undefined}
+ */
+export default function inferSegmentContainer(adaptationType, mimeType) {
+    if (adaptationType === "audio" || adaptationType === "video") {
+        if (mimeType === "video/mp4" || mimeType === "audio/mp4") {
+            return "mp4";
+        }
+        if (mimeType === "video/webm" || mimeType === "audio/webm") {
+            return "webm";
+        }
+        return undefined;
+    }
+    else if (adaptationType === "text") {
+        return mimeType === "application/mp4" ? "mp4" : undefined;
+    }
+    return undefined;
+}

package/dist/es2017/transports/utils/parse_text_track.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { IChunkTimeInfo, ISegmentContext, ITextTrackSegmentData } from "../types";
+/**
+ * Returns the a string expliciting the format of a text track when that text
+ * track is embedded into a ISOBMFF file.
+ * @param {string|undefined} codecs
+ * @returns {string}
+ */
+export declare function getISOBMFFTextTrackFormat(codecs: string | undefined): "ttml" | "vtt";
+/**
+ * Returns the a string expliciting the format of a text track in plain text.
+ * @param {string|undefined} codecs
+ * @param {string|undefined} mimeType
+ * @returns {string}
+ */
+export declare function getPlainTextTrackFormat(codecs: string | undefined, mimeType: string | undefined): "ttml" | "sami" | "vtt" | "srt";
+/**
+ * @param {Object} content
+ * @param {ArrayBuffer|UInt8Array|null} chunkBytes
+ * @param {number|undefined} initTimescale
+ * @param {Object|null} chunkInfos
+ * @param {boolean} isChunked
+ * @returns {Object|null}
+ */
+export declare function getISOBMFFEmbeddedTextTrackData({ segment, language, codecs, }: {
+    segment: ISegment;
+    codecs?: string | undefined;
+    language?: string | undefined;
+}, chunkBytes: Uint8Array<ArrayBuffer>, initTimescale: number | undefined, chunkInfos: IChunkTimeInfo | null, isChunked: boolean): ITextTrackSegmentData | null;
+/**
+ * @param {Object} context
+ * @param {ArrayBuffer|UInt8Array|null} textTrackData
+ * @param {number|undefined} initTimescale
+ * @param {boolean} isChunked
+ * @returns {Object|null}
+ */
+export declare function getPlainTextTrackData(context: ISegmentContext, textTrackData: string, initTimescale: number | undefined, isChunked: boolean): ITextTrackSegmentData | null;
+//# sourceMappingURL=parse_text_track.d.ts.map

package/dist/es2017/transports/utils/parse_text_track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_text_track.d.ts","sourceRoot":"","sources":["../../../../src/transports/utils/parse_text_track.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEvF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,CAepF;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAkBjC;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,EACE,OAAO,EACP,QAAQ,EACR,MAAM,GACP,EAAE;IACD,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B,EACD,UAAU,EAAE,UAAU,CAAC,WAAW,CAAC,EACnC,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,UAAU,EAAE,cAAc,GAAG,IAAI,EACjC,SAAS,EAAE,OAAO,GACjB,qBAAqB,GAAG,IAAI,CAiD9B;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EACxB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,SAAS,EAAE,OAAO,GACjB,qBAAqB,GAAG,IAAI,CA0B9B"}

package/dist/es2017/transports/utils/parse_text_track.js

@@ -0,0 +1,154 @@
+/**
+ * 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 { getMDAT } from "../../parsers/containers/isobmff";
+import startsWith from "../../utils/starts_with";
+import { utf8ToStr } from "../../utils/string_parsing";
+/**
+ * Returns the a string expliciting the format of a text track when that text
+ * track is embedded into a ISOBMFF file.
+ * @param {string|undefined} codecs
+ * @returns {string}
+ */
+export function getISOBMFFTextTrackFormat(codecs) {
+    if (codecs === undefined) {
+        throw new Error("Cannot parse subtitles: unknown format");
+    }
+    switch (codecs.toLowerCase()) {
+        case "stpp": // stpp === TTML in MP4
+        case "stpp.ttml":
+        case "stpp.ttml.im1t":
+            return "ttml";
+        case "wvtt": // wvtt === WebVTT in MP4
+            return "vtt";
+    }
+    throw new Error("The codec used for the subtitles " + `"${codecs}" is not managed yet.`);
+}
+/**
+ * Returns the a string expliciting the format of a text track in plain text.
+ * @param {string|undefined} codecs
+ * @param {string|undefined} mimeType
+ * @returns {string}
+ */
+export function getPlainTextTrackFormat(codecs, mimeType) {
+    switch (mimeType) {
+        case "application/ttml+xml":
+            return "ttml";
+        case "application/x-sami":
+        case "application/smil":
+            return "sami";
+        case "text/vtt":
+            return "vtt";
+    }
+    if (codecs !== undefined) {
+        const codeLC = codecs.toLowerCase();
+        if (codeLC === "srt") {
+            return "srt";
+        }
+    }
+    throw new Error(`could not find a text-track parser for the type ${mimeType !== null && mimeType !== void 0 ? mimeType : ""}`);
+}
+/**
+ * @param {Object} content
+ * @param {ArrayBuffer|UInt8Array|null} chunkBytes
+ * @param {number|undefined} initTimescale
+ * @param {Object|null} chunkInfos
+ * @param {boolean} isChunked
+ * @returns {Object|null}
+ */
+export function getISOBMFFEmbeddedTextTrackData({ segment, language, codecs, }, chunkBytes, initTimescale, chunkInfos, isChunked) {
+    if (segment.isInit) {
+        return null;
+    }
+    let startTime;
+    let endTime;
+    if (chunkInfos === null) {
+        if (!isChunked) {
+            log.warn("utils", "Unavailable time data for current text track.");
+        }
+        else {
+            startTime = segment.time;
+            endTime = segment.end;
+        }
+    }
+    else {
+        startTime = chunkInfos.time;
+        if (chunkInfos.duration !== undefined) {
+            endTime = startTime + chunkInfos.duration;
+        }
+        else if (!isChunked && segment.complete) {
+            endTime = startTime + segment.duration;
+        }
+    }
+    const type = getISOBMFFTextTrackFormat(codecs);
+    const mdat = getMDAT(chunkBytes);
+    const mdatStr = mdat !== null ? utf8ToStr(mdat) : "";
+    if (codecs === "wvtt" &&
+        !startsWith(mdatStr, "WEBVTT") &&
+        !startsWith(mdatStr, "\xfe\xffWEBVTT")) {
+        // From how I understand it, we're here in a special WebVTT format  embedded
+        // in an MP4 where the whole chunk contains information, now just the MDAT
+        return {
+            data: chunkBytes,
+            type: "mp4vtt",
+            language,
+            start: startTime,
+            end: endTime,
+            initTimescale: initTimescale !== null && initTimescale !== void 0 ? initTimescale : null,
+        };
+    }
+    return {
+        data: mdatStr,
+        type,
+        language,
+        start: startTime,
+        end: endTime,
+        initTimescale: initTimescale !== null && initTimescale !== void 0 ? initTimescale : null,
+    };
+}
+/**
+ * @param {Object} context
+ * @param {ArrayBuffer|UInt8Array|null} textTrackData
+ * @param {number|undefined} initTimescale
+ * @param {boolean} isChunked
+ * @returns {Object|null}
+ */
+export function getPlainTextTrackData(context, textTrackData, initTimescale, isChunked) {
+    const { segment } = context;
+    if (segment.isInit) {
+        return null;
+    }
+    let start;
+    let end;
+    if (isChunked) {
+        log.warn("utils", "Unavailable time data for current text track.");
+    }
+    else {
+        start = segment.time;
+        if (segment.complete) {
+            end = segment.time + segment.duration;
+        }
+    }
+    const type = getPlainTextTrackFormat(context.codecs, context.mimeType);
+    return {
+        data: textTrackData,
+        type,
+        language: context.language,
+        start,
+        end,
+        initTimescale: initTimescale !== null && initTimescale !== void 0 ? initTimescale : null,
+    };
+}

package/dist/es2017/utils/are_arrays_of_numbers_equal.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+/**
+ * Check if two two arrays containing only numbers are equal.
+ * @param {Array.<number>|TypedArray} arr1
+ * @param {Array.<number>|TypedArray} arr2
+ * @returns {Boolean}
+ */
+export default function areArraysOfNumbersEqual(arr1: Uint8Array | number[], arr2: Uint8Array | number[]): boolean;
+//# sourceMappingURL=are_arrays_of_numbers_equal.d.ts.map

package/dist/es2017/utils/are_arrays_of_numbers_equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"are_arrays_of_numbers_equal.d.ts","sourceRoot":"","sources":["../../../src/utils/are_arrays_of_numbers_equal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAC7C,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,EAC3B,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,GAC1B,OAAO,CAaT"}

package/dist/es2017/utils/are_arrays_of_numbers_equal.js

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+/**
+ * Check if two two arrays containing only numbers are equal.
+ * @param {Array.<number>|TypedArray} arr1
+ * @param {Array.<number>|TypedArray} arr2
+ * @returns {Boolean}
+ */
+export default function areArraysOfNumbersEqual(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    if (arr1 === arr2) {
+        return true;
+    }
+    for (let i = arr1.length - 1; i >= 0; i--) {
+        if (arr1[i] !== arr2[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/es2017/utils/are_codecs_compatible.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ */
+/**
+ * This function is a shortcut that helps differentiate two codecs
+ * of the form "audio/mp4;codecs=\"av1.40.2\"".
+ *
+ * @param codecA
+ * @param codecB
+ * @returns A boolean that tell whether or not those two codecs provided are even.
+ */
+declare function areCodecsCompatible(a: string, b: string): boolean;
+export declare function parseCodec(unparsedCodec: string): {
+    mimeType: string;
+    codecs: string;
+};
+export default areCodecsCompatible;
+//# sourceMappingURL=are_codecs_compatible.d.ts.map

package/dist/es2017/utils/are_codecs_compatible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"are_codecs_compatible.d.ts","sourceRoot":"","sources":["../../../src/utils/are_codecs_compatible.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH;;;;;;;GAOG;AACH,iBAAS,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAkB1D;AAID,wBAAgB,UAAU,CAAC,aAAa,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAWtF;AAED,eAAe,mBAAmB,CAAC"}

package/dist/es2017/utils/are_codecs_compatible.js

@@ -0,0 +1,57 @@
+/**
+ * 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 arrayFind from "./array_find";
+import startsWith from "./starts_with";
+/**
+ * This function is a shortcut that helps differentiate two codecs
+ * of the form "audio/mp4;codecs=\"av1.40.2\"".
+ *
+ * @param codecA
+ * @param codecB
+ * @returns A boolean that tell whether or not those two codecs provided are even.
+ */
+function areCodecsCompatible(a, b) {
+    const { mimeType: mimeTypeA, codecs: codecsA } = parseCodec(a);
+    const { mimeType: mimeTypeB, codecs: codecsB } = parseCodec(b);
+    if (mimeTypeA !== mimeTypeB) {
+        return false;
+    }
+    if (codecsA === "" || codecsB === "") {
+        return false;
+    }
+    let initialPartA = codecsA.split(".")[0];
+    initialPartA = initialPartA === "hev1" ? "hvc1" : initialPartA;
+    let initialPartB = codecsB.split(".")[0];
+    initialPartB = initialPartB === "hev1" ? "hvc1" : initialPartB;
+    if (initialPartA !== initialPartB) {
+        return false;
+    }
+    return true;
+}
+const LENGTH_OF_CODEC_PREFIX = "codecs=".length;
+export function parseCodec(unparsedCodec) {
+    var _a;
+    const [mimeType, ...props] = unparsedCodec.split(";");
+    let codecs = (_a = arrayFind(props, (prop) => startsWith(prop, "codecs="))) !== null && _a !== void 0 ? _a : "";
+    // remove the 'codecs=' prefix
+    codecs = codecs.substring(LENGTH_OF_CODEC_PREFIX);
+    // remove the leading and trailing quote
+    if (codecs[0] === '"') {
+        codecs = codecs.substring(1, codecs.length - 1);
+    }
+    return { mimeType, codecs };
+}
+export default areCodecsCompatible;

package/dist/es2017/utils/array_find.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+/**
+ * Array.prototype.find ponyfill.
+ * @param {Array} arr
+ * @param {Function} predicate
+ * @param {*} thisArg
+ * @returns {boolean}
+ */
+export default function arrayFind<T>(arr: T[], predicate: (arg: T, index: number, fullArray: T[]) => boolean, thisArg?: unknown): T | undefined;
+//# sourceMappingURL=array_find.d.ts.map

package/dist/es2017/utils/array_find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_find.d.ts","sourceRoot":"","sources":["../../../src/utils/array_find.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,CAAC,EACjC,GAAG,EAAE,CAAC,EAAE,EACR,SAAS,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,OAAO,EAC7D,OAAO,CAAC,EAAE,OAAO,GAChB,CAAC,GAAG,SAAS,CAef"}

package/dist/es2017/utils/array_find.js

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+/**
+ * Array.prototype.find ponyfill.
+ * @param {Array} arr
+ * @param {Function} predicate
+ * @param {*} thisArg
+ * @returns {boolean}
+ */
+export default function arrayFind(arr, predicate, thisArg) {
+    // eslint-disable-next-line no-restricted-properties
+    if (typeof Array.prototype.find === "function") {
+        // eslint-disable-next-line no-restricted-properties
+        return arr.find(predicate, thisArg);
+    }
+    const len = arr.length >>> 0;
+    for (let i = 0; i < len; i++) {
+        const val = arr[i];
+        if (predicate.call(thisArg, val, i, arr)) {
+            return val;
+        }
+    }
+    return undefined;
+}

package/dist/es2017/utils/array_find_index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+/**
+ * Array.prototype.find ponyfill.
+ * @param {Array} arr
+ * @param {Function} predicate
+ * @param {*} thisArg
+ * @returns {boolean}
+ */
+export default function arrayFindIndex<T>(arr: T[], predicate: (arg: T, index: number, fullArray: T[]) => boolean, thisArg?: unknown): number;
+//# sourceMappingURL=array_find_index.d.ts.map

package/dist/es2017/utils/array_find_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_find_index.d.ts","sourceRoot":"","sources":["../../../src/utils/array_find_index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAUH;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,CAAC,EACtC,GAAG,EAAE,CAAC,EAAE,EACR,SAAS,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,OAAO,EAC7D,OAAO,CAAC,EAAE,OAAO,GAChB,MAAM,CAcR"}

package/dist/es2017/utils/array_find_index.js

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+/**
+ * Array.prototype.find ponyfill.
+ * @param {Array} arr
+ * @param {Function} predicate
+ * @param {*} thisArg
+ * @returns {boolean}
+ */
+export default function arrayFindIndex(arr, predicate, thisArg) {
+    // eslint-disable-next-line no-restricted-properties
+    if (typeof Array.prototype.findIndex === "function") {
+        // eslint-disable-next-line no-restricted-properties
+        return arr.findIndex(predicate, thisArg);
+    }
+    const len = arr.length >>> 0;
+    for (let i = 0; i < len; i++) {
+        if (predicate.call(thisArg, arr[i], i, arr)) {
+            return i;
+        }
+    }
+    return -1;
+}

package/dist/es2017/utils/array_includes.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+/**
+ * Array.prototype.includes ponyfill.
+ * Returns ``true`` if the given array ``arr`` contains the element
+ * ``searchElement``. false ``otherwise``.
+ *
+ * Inspired from MDN polyfill, but ponyfilled instead
+ *
+ * @example
+ * ```js
+ * arrayIncludes([1, 2, 3], 3);
+ * // => true
+ *
+ * arrayIncludes([1, 2, 3], 7);
+ * // => false
+ *
+ * const obj = { a: 4 };
+ * arrayIncludes([obj, { b: 7 }, { a: 3 }], obj);
+ * // => true
+ *
+ * // does not perform deep equality
+ * arrayIncludes([{ a: 4 }, { b: 7 }, { a: 3 }], { a: 4 });
+ * // => false
+ *
+ * // the third argument state the starting index. 0 if not set.
+ *
+ * arrayIncludes([1, 2, 3], 2, 1);
+ * // => true
+ *
+ * arrayIncludes([1, 2, 3], 2, 2);
+ * // => false
+ * ```
+ *
+ * @param {Array} arr
+ * @param {*} searchElement
+ * @param {number} [fromIndex]
+ * @returns {boolean}
+ */
+export default function arrayIncludes<T>(arr: T[], searchElement: T, fromIndex?: number): boolean;
+//# sourceMappingURL=array_includes.d.ts.map

package/dist/es2017/utils/array_includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_includes.d.ts","sourceRoot":"","sources":["../../../src/utils/array_includes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,CAAC,EACrC,GAAG,EAAE,CAAC,EAAE,EACR,aAAa,EAAE,CAAC,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CA6BT"}