rx-player 3.33.0 → 3.33.1

package/src/typings/globals.d.ts

@@ -1,83 +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.
- */
-
-// Compile-time globals
-// Should be all replaced once the lib built.
-
-/* eslint-disable @typescript-eslint/naming-convention */
-
-declare const __FEATURES__ : {
-  IS_DISABLED : 0;
-  IS_ENABLED : 1;
-
-  BIF_PARSER : 0 | 1;
-  DASH : 0 | 1;
-  DIRECTFILE : 0 | 1;
-  EME : 0 | 1;
-  HTML_SAMI : 0 | 1;
-  HTML_SRT : 0 | 1;
-  HTML_TTML : 0 | 1;
-  HTML_VTT : 0 | 1;
-  LOCAL_MANIFEST : 0 | 1;
-  METAPLAYLIST : 0 | 1;
-  DEBUG_ELEMENT : 0 | 1;
-  NATIVE_SAMI : 0 | 1;
-  NATIVE_SRT : 0 | 1;
-  NATIVE_TTML : 0 | 1;
-  NATIVE_VTT : 0 | 1;
-  SMOOTH : 0 | 1;
-} | typeof FEATURES_ENUM;
-
-declare const enum FEATURES_ENUM {
-  IS_DISABLED,
-  IS_ENABLED,
-
-  BIF_PARSER,
-  DASH,
-  DIRECTFILE,
-  EME,
-  HTML_SAMI,
-  HTML_SRT,
-  HTML_TTML,
-  HTML_VTT,
-  LOCAL_MANIFEST,
-  METAPLAYLIST,
-  DEBUG_ELEMENT,
-  NATIVE_SAMI,
-  NATIVE_SRT,
-  NATIVE_TTML,
-  NATIVE_VTT,
-  SMOOTH,
-}
-
-declare const __ENVIRONMENT__ : {
-  CURRENT_ENV : 0 | 1;
-  DEV : 0;
-  PRODUCTION : 1;
-} | typeof ENVIRONMENT_ENUM;
-
-declare const enum ENVIRONMENT_ENUM {
-  CURRENT_ENV,
-  DEV,
-  PRODUCTION,
-}
-
-declare const __LOGGER_LEVEL__ : {
-  CURRENT_LEVEL : string;
-};
-
-// eslint-disable-next-line
-declare const require: (path: string) => any;

package/src/typings/next-tick.d.ts

@@ -1,23 +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.
- */
-
-declare module "next-tick" {
-  function nextTick(
-    fn : () => void
-  ) : void;
-
-  export default nextTick;
-}

package/src/utils/README.md

@@ -1,5 +0,0 @@
-# Utils ########################################################################
-
-This directory regroups utils function, which are small stand-alone (they
-shouldn't rely on any outside code, beside dependencies) functions that might be
-used by any part of the RxPlayer's code.

package/src/utils/__tests__/are_arrays_of_numbers_equal.test.ts

@@ -1,86 +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 areArraysOfNumbersEqual from "../are_arrays_of_numbers_equal";
-
-describe("are_arrays_of_numbers_equal", () => {
-
-  it("should return true for two empty arrays", () => {
-    expect(areArraysOfNumbersEqual([], [])).toEqual(true);
-    expect(areArraysOfNumbersEqual(new Uint8Array([]), [])).toEqual(true);
-    expect(areArraysOfNumbersEqual(new Uint8Array([]), new Uint8Array([]))).toEqual(true);
-    expect(areArraysOfNumbersEqual(new Uint8Array([]), [])).toEqual(true);
-  });
-
-  it("should return false when only one of the array is empty", () => {
-    expect(areArraysOfNumbersEqual([0], [])).toEqual(false);
-    expect(areArraysOfNumbersEqual([1], new Uint8Array([]))).toEqual(false);
-    expect(areArraysOfNumbersEqual(new Uint8Array([1]),
-                                   new Uint8Array([]))).toEqual(false);
-    expect(areArraysOfNumbersEqual(new Uint8Array([]),
-                                   new Uint8Array([0]))).toEqual(false);
-    expect(areArraysOfNumbersEqual([], [0])).toEqual(false);
-    expect(areArraysOfNumbersEqual([], [0, 1])).toEqual(false);
-  });
-
-  it("should return false if both arrays don't have the same length", () => {
-    expect(areArraysOfNumbersEqual([0, 1],
-                                   [1])).toEqual(false);
-    expect(areArraysOfNumbersEqual([1, 2, 3],
-                                   new Uint8Array([1, 2]))).toEqual(false);
-    expect(areArraysOfNumbersEqual(new Uint8Array([1, 2, 3]),
-                                   [1, 2])).toEqual(false);
-    expect(areArraysOfNumbersEqual(new Uint8Array([1, 2, 3]),
-                                   new Uint8Array([1, 2]))).toEqual(false);
-  });
-
-  /* eslint-disable max-len */
-  it("should return false if both arrays have the same length with different values", () => {
-  /* eslint-enable max-len */
-    expect(areArraysOfNumbersEqual([0, 1],
-                                   [0, 4])).toEqual(false);
-    expect(areArraysOfNumbersEqual([1, 2, 3],
-                                   new Uint8Array([8, 2, 3]))).toEqual(false);
-    expect(areArraysOfNumbersEqual(new Uint8Array([2, 2, 3]),
-                                   [1, 2, 3])).toEqual(false);
-    expect(areArraysOfNumbersEqual(new Uint8Array([2, 3]),
-                                   new Uint8Array([2, 4]))).toEqual(false);
-  });
-
-  it("should return true if both contain the same value in a different type", () => {
-    expect(areArraysOfNumbersEqual([5, 4, 7],
-                                   new Uint8Array([5, 4, 7]))).toEqual(true);
-    expect(areArraysOfNumbersEqual(new Uint8Array([47, 68, 9]),
-                                   [47, 68, 9])).toEqual(true);
-  });
-
-  it("should return true if both contain the same value in the same type", () => {
-    expect(areArraysOfNumbersEqual([45, 6985, 866, 856],
-                                   [45, 6985, 866, 856])).toEqual(true);
-    expect(areArraysOfNumbersEqual([8],
-                                   [8])).toEqual(true);
-    expect(areArraysOfNumbersEqual(new Uint8Array([45, 6985, 866, 856]),
-                                   new Uint8Array([45, 6985, 866, 856])))
-      .toEqual(true);
-  });
-
-  it("should return true if both are the same reference", () => {
-    const arr = [909, 432432, 124213];
-    const uint8Arr = new Uint8Array([23244, 35452, 54326, 867 ]);
-    expect(areArraysOfNumbersEqual(arr, arr)).toEqual(true);
-    expect(areArraysOfNumbersEqual(uint8Arr, uint8Arr)).toEqual(true);
-  });
-});

package/src/utils/__tests__/are_codecs_compatible.test.ts

@@ -1,88 +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 areCodecsCompatible from "../are_codecs_compatible";
-
-describe("are_codecs_compatible", () => {
-  it("should return false as one is different from the other", () => {
-    expect(areCodecsCompatible("", "audio/mp4;codecs=\"mp4a.42.2\"")).toEqual(
-      false
-    );
-  });
-
-  it("should return false as the mimeType is different", () => {
-    expect(
-      areCodecsCompatible(
-        "audio/mp4;codecs=\"mp4a.40.2\"",
-        "audio/mp3;codecs=\"mp4a.40.2\""
-      )
-    ).toEqual(false);
-  });
-
-  it("should return false as the codec is different", () => {
-    expect(
-      areCodecsCompatible(
-        "audio/mp4;codecs=\"mp4a.40.2\"",
-        "audio/mp4;codecs=\"av1.40.2\""
-      )
-    ).toEqual(false);
-  });
-
-  it("should return true as only the codec version is different", () => {
-    expect(
-      areCodecsCompatible(
-        "audio/mp4;codecs=\"mp4a.40.2\"",
-        "audio/mp4;codecs=\"mp4a.42.2\""
-      )
-    ).toEqual(true);
-  });
-
-  it("should return true as they are exactly same", () => {
-    expect(
-      areCodecsCompatible(
-        "audio/mp4;toto=5;codecs=\"mp4a.40.2\";test=4",
-        "audio/mp4;toto=5;codecs=\"mp4a.40.2\";test=4"
-      )
-    ).toEqual(true);
-  });
-
-  it("should return true as their codecs are same", () => {
-    expect(
-      areCodecsCompatible(
-        "audio/mp4;toto=6;codecs=\"mp4a.40.2\";test=4",
-        "audio/mp4;toto=5;codecs=\"mp4a.40.2\";test=4"
-      )
-    ).toEqual(true);
-  });
-
-  it("should return false as their codecs are different", () => {
-    expect(
-      areCodecsCompatible(
-        "audio/mp4;toto=6;codecs=\"av1.40.2\";test=4",
-        "audio/mp4;toto=5;codecs=\"mp4a.40.2\";test=4"
-      )
-    ).toEqual(false);
-  });
-
-  it("should return false as codecs have been found", () => {
-    expect(
-      areCodecsCompatible(
-        "audio/mp4;toto=6;test=4",
-        "audio/mp4;toto=5;test=4"
-      )
-    ).toEqual(false);
-  });
-});

package/src/utils/__tests__/array_find.test.ts

@@ -1,113 +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.
- */
-
-/* eslint-disable no-invalid-this */
-/* eslint-disable no-restricted-properties */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/ban-types */
-
-import arrayFind from "../array_find";
-
-/* eslint-disable @typescript-eslint/unbound-method */
-const initialArrayFind = (Array.prototype as { find : unknown }).find;
-/* eslint-enable @typescript-eslint/unbound-method */
-
-describe("utils - arrayFind", () => {
-  beforeEach(() => {
-    (Array.prototype as { find : unknown }).find = undefined;
-  });
-
-  afterEach(() => {
-    (Array.prototype as { find : unknown }).find = initialArrayFind;
-  });
-
-  it("should return undefined for an empty array", () => {
-    expect(arrayFind([], () => { return true; })).toBe(undefined);
-  });
-
-  it("should return the corresponding element", () => {
-    const obj1 = {};
-    const obj2 = {};
-    expect(arrayFind([obj2, obj1, obj2, obj1], (obj) => {
-      return obj === obj1;
-    })).toBe(obj1);
-  });
-
-  it("should return undefined if the element is not found", () => {
-    const obj1 = {};
-    const obj2 = {};
-    const obj3 = {};
-    expect(arrayFind([obj2, obj1, obj2, obj1], (obj) => {
-      return obj === obj3;
-    })).toBe(undefined);
-  });
-
-  it("should give an index as a second argument and the array as a third", () => {
-    const obj1 = {};
-    const obj2 = {};
-    const arr = [obj2, obj1, obj2, obj1];
-    let currentIndex = 0;
-    expect(arrayFind(arr, (obj, index, cArr) => {
-      expect(index).toBe(currentIndex++);
-      expect(cArr).toBe(arr);
-      return obj === obj1;
-    })).toBe(obj1);
-
-    expect(currentIndex).toBe(2);
-  });
-
-  it("should give give a context if the third argument is provided", () => {
-    const obj1 = {};
-    const obj2 = {};
-    const context = {};
-    const arr = [obj2, obj1, obj2, obj1];
-    arrayFind(arr, function(this : unknown) {
-      expect(this).toBe(context);
-      return false;
-    }, context);
-  });
-
-  if (typeof initialArrayFind === "function") {
-    it("should call the original array.find function if it exists", () => {
-      (Array.prototype as { find : unknown }).find = initialArrayFind;
-      const obj1 = {};
-      const obj2 = {};
-      const context = {};
-      const arr = [obj2, obj1, obj2, obj1];
-      const spy = jest.spyOn(arr as unknown as { find : () => unknown }, "find");
-
-      let currentIndex = 0;
-      const predicate = function(
-        this : unknown,
-        obj : {},
-        index : number,
-        cArr : Array<{}>
-      ) : boolean {
-        expect(this).toBe(context);
-        expect(index).toBe(currentIndex++);
-        expect(cArr).toBe(arr);
-        return obj === obj1;
-      };
-      expect(arrayFind(arr, predicate, context)).toBe(obj1);
-
-      expect(currentIndex).toBe(2);
-
-      expect(spy).toHaveBeenCalledTimes(1);
-      expect(spy).toHaveBeenCalledWith(predicate, context);
-    });
-  }
-});

package/src/utils/__tests__/array_find_index.test.ts

@@ -1,113 +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.
- */
-
-/* eslint-disable no-invalid-this */
-/* eslint-disable no-restricted-properties */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/ban-types */
-
-import arrayFindIndex from "../array_find_index";
-
-/* eslint-disable @typescript-eslint/unbound-method */
-const initialArrayFindIndex = (Array.prototype as { findIndex : unknown }).findIndex;
-/* eslint-enable @typescript-eslint/unbound-method */
-
-describe("utils - arrayFindIndex", () => {
-  beforeEach(() => {
-    (Array.prototype as { findIndex : unknown }).findIndex = undefined;
-  });
-
-  afterEach(() => {
-    (Array.prototype as { findIndex : unknown }).findIndex = initialArrayFindIndex;
-  });
-
-  it("should return -1 for an empty array", () => {
-    expect(arrayFindIndex([], () => { return true; })).toBe(-1);
-  });
-
-  it("should return the first corresponding index if found", () => {
-    const obj1 = {};
-    const obj2 = {};
-    expect(arrayFindIndex([obj2, obj1, obj2, obj1], (obj) => {
-      return obj === obj1;
-    })).toBe(1);
-  });
-
-  it("should return -1 if the element is not found", () => {
-    const obj1 = {};
-    const obj2 = {};
-    const obj3 = {};
-    expect(arrayFindIndex([obj2, obj1, obj2, obj1], (obj) => {
-      return obj === obj3;
-    })).toBe(-1);
-  });
-
-  it("should give an index as a second argument and the array as a third", () => {
-    const obj1 = {};
-    const obj2 = {};
-    const arr = [obj2, obj1, obj2, obj1];
-    let currentIndex = 0;
-    expect(arrayFindIndex(arr, (obj, index, cArr) => {
-      expect(index).toBe(currentIndex++);
-      expect(cArr).toBe(arr);
-      return obj === obj1;
-    })).toBe(1);
-
-    expect(currentIndex).toBe(2);
-  });
-
-  it("should give give a context if the third argument is provided", () => {
-    const obj1 = {};
-    const obj2 = {};
-    const context = {};
-    const arr = [obj2, obj1, obj2, obj1];
-    arrayFindIndex(arr, function(this : unknown) {
-      expect(this).toBe(context);
-      return false;
-    }, context);
-  });
-
-  if (typeof initialArrayFindIndex === "function") {
-    it("should call the original array.findIndex function if it exists", () => {
-      (Array.prototype as { findIndex : unknown }).findIndex = initialArrayFindIndex;
-      const obj1 = {};
-      const obj2 = {};
-      const context = {};
-      const arr = [obj2, obj1, obj2, obj1];
-      const spy = jest
-        .spyOn(arr as unknown as { findIndex : () => unknown }, "findIndex");
-
-      let currentIndex = 0;
-      const predicate = function(
-        this : unknown,
-        obj : {},
-        index : number,
-        cArr : Array<{}>
-      ) : boolean {
-        expect(this).toBe(context);
-        expect(index).toBe(currentIndex++);
-        expect(cArr).toBe(arr);
-        return obj === obj1;
-      };
-      expect(arrayFindIndex(arr, predicate, context)).toBe(1);
-      expect(currentIndex).toBe(2);
-
-      expect(spy).toHaveBeenCalledTimes(1);
-      expect(spy).toHaveBeenCalledWith(predicate, context);
-    });
-  }
-});

package/src/utils/__tests__/array_includes.test.ts

@@ -1,151 +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.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable no-restricted-properties */
-
-import arrayIncludes from "../array_includes";
-
-/* eslint-disable @typescript-eslint/unbound-method */
-const initialArrayIncludes = Array.prototype.includes;
-/* eslint-enable @typescript-eslint/unbound-method */
-describe("utils - array-includes", () => {
-  beforeEach(() => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (Array.prototype as any).includes = undefined;
-  });
-
-  afterEach(() => {
-    Array.prototype.includes = initialArrayIncludes;
-  });
-
-  it("should be true if a number is included", () => {
-    expect(arrayIncludes([1, 2, 3, 4, 5], 1)).toBe(true);
-    expect(arrayIncludes([1, 2, 3, 4, 5], 2)).toBe(true);
-    expect(arrayIncludes([1, 2, 3, 4, 5], 3)).toBe(true);
-    expect(arrayIncludes([1, 2, 3, 4, 5], 4)).toBe(true);
-    expect(arrayIncludes([1, 2, 3, 4, 5], 5)).toBe(true);
-
-    expect(arrayIncludes([1, "toto", /aa/, 4, []], 4)).toBe(true);
-  });
-
-  it("should always be false if an empty array is given", () => {
-    expect(arrayIncludes([], undefined)).toBe(false);
-    expect(arrayIncludes([], null)).toBe(false);
-    expect(arrayIncludes([], 0)).toBe(false);
-    expect(arrayIncludes([], "")).toBe(false);
-    expect(arrayIncludes([], [])).toBe(false);
-  });
-
-  it("should be false if a number is not included", () => {
-    expect(arrayIncludes([1, 2, 3, 4, 5], 0)).toBe(false);
-    expect(arrayIncludes([1, 2, /aaaa/, 4, 5], 6)).toBe(false);
-    expect(arrayIncludes([1, 2, 3, 4, 5], Infinity)).toBe(false);
-    expect(arrayIncludes([1, 2, 3, 4, 5], NaN)).toBe(false);
-  });
-
-  it("should be true for NaN values", () => {
-    expect(arrayIncludes([1, NaN, 3, 4, 5], NaN)).toBe(true);
-  });
-
-  it("should be true if a string is included", () => {
-    expect(arrayIncludes(["abc", "", "toto", "bar", "baz"], ""))
-      .toBe(true);
-    expect(arrayIncludes(["abc", "foo", "toto", "bar", "baz"], "abc"))
-      .toBe(true);
-    expect(arrayIncludes(["abc", "foo", "toto", "bar", "baz"], "foo"))
-      .toBe(true);
-    expect(arrayIncludes(["abc", "foo", "toto", "bar", "baz"], "toto"))
-      .toBe(true);
-    expect(arrayIncludes(["abc", "foo", "toto", "bar", "baz"], "bar"))
-      .toBe(true);
-    expect(arrayIncludes(["abc", "foo", "toto", "bar", "baz"], "baz"))
-      .toBe(true);
-
-    expect(arrayIncludes(["abc", "toto", /aa/, 4, []], "toto")).toBe(true);
-  });
-
-  it("should be true if a boolean is included", () => {
-    expect(arrayIncludes([true, false, true, "bar", "baz"], true))
-      .toBe(true);
-    expect(arrayIncludes([true, false, true, "bar", "baz"], false))
-      .toBe(true);
-    expect(arrayIncludes([true, false], true))
-      .toBe(true);
-    expect(arrayIncludes([false, "toto", /aa/, 4, []], false)).toBe(true);
-  });
-
-  it("should be true if an object is included", () => {
-    const obj1 = { a: 4, b: 3 };
-    const obj2 = { a: obj1, b: { a: 4 } };
-    expect(arrayIncludes([obj1, obj2], obj1))
-      .toBe(true);
-    expect(arrayIncludes([obj1, obj2], obj2))
-      .toBe(true);
-    expect(arrayIncludes([1, obj1, 3, obj2, 5], obj2)).toBe(true);
-  });
-
-  it("should be false if an object is not included", () => {
-    const obj1 = { a: 4, b: 3 };
-    const obj2 = { a: obj1, b: { a: 4 } };
-    const obj3 = { o: 4 };
-    const obj4 = { z: obj1, t: { a: 4 } };
-    expect(arrayIncludes<unknown>([obj1, obj2, obj3], obj4))
-      .toBe(false);
-    expect(arrayIncludes<unknown>([1, obj4, 3, obj3, 5], obj2)).toBe(false);
-  });
-
-  it("should not work for deep equality with objects", () => {
-    const obj1 = { a: 4, b: 3 };
-    const obj2 = { a: obj1, b: { a: 4 } };
-    const obj2bis = { a: obj1, b: { a: 4 } };
-    expect(arrayIncludes([obj1, obj2], obj2bis))
-      .toBe(false);
-  });
-
-  it("should take a starting index as first argument", () => {
-    const obj1 = { a: 4, b: 3 };
-    const obj2 = { a: obj1, b: { a: 4 } };
-    const obj3 = { a: obj1, b: { a: 4 } };
-    expect(arrayIncludes([obj1, obj2, obj3], obj2))
-      .toBe(true);
-    expect(arrayIncludes([obj1, obj2, obj3], obj2, 0))
-      .toBe(true);
-    expect(arrayIncludes([obj1, obj2, obj3], obj2, 1))
-      .toBe(true);
-    expect(arrayIncludes([obj1, obj2, obj3], obj2, 2))
-      .toBe(false);
-    expect(arrayIncludes([obj1, obj2, obj3], obj2, 3)) // out of bounds
-      .toBe(false);
-  });
-
-  it("should go from the end if the given index is negative", () => {
-    const obj1 = { a: 4, b: 3 };
-    const obj2 = { a: obj1, b: { a: 4 } };
-    const obj3 = { a: obj1, b: { a: 4 } };
-    const obj4 = {};
-    expect(arrayIncludes([obj1, obj2, obj3, obj4], obj3))
-      .toBe(true);
-    expect(arrayIncludes([obj1, obj2, obj3, obj4], obj3, -1))
-      .toBe(false);
-    expect(arrayIncludes([obj1, obj2, obj3, obj4], obj3, -2))
-      .toBe(true);
-    expect(arrayIncludes([obj1, obj2, obj3, obj4], obj3, -3))
-      .toBe(true);
-    expect(arrayIncludes([obj1, obj2, obj3, obj4], obj3, -12)) // out of bounds
-      .toBe(true);
-  });
-});