rx-player 4.5.0-dev.2026031700 → 4.5.0-dev.2026033100

package/src/parsers/texttracks/webvtt/__tests__/parse_cue_block.test.ts

@@ -1,5 +1,16 @@
-import { describe, beforeEach, it, expect, vi } from "vitest";
-import type IParseCueBlock from "../parse_cue_block";
+import { describe, beforeEach, it, expect, vi, afterEach } from "vitest";
+import parseCueBlock from "../parse_cue_block";
+import type parseTimestamp from "../parse_timestamp";
+
+const mocks = vi.hoisted(() => {
+  return {
+    parseTimestamp: vi.fn(),
+  };
+});
+
+vi.mock("../parse_timestamp", () => ({
+  default: mocks.parseTimestamp,
+}));
 
 const cueBlock1 = [
   "112",
@@ -35,13 +46,17 @@ const notCueBlock6 = ["aa:18:31.080 --> 00:18:32.200", "TOTO", "TATA"];
 const notCueBlock7 = ["00:18:31.080 --> bb:18:32.200", "TOTO", "TATA"];
 
 describe("parsers - srt - parseCueBlocks", () => {
-  beforeEach(() => {
+  beforeEach(async () => {
     vi.resetModules();
+    const actualParseTimestamp = (await vi.importActual("../parse_timestamp"))
+      .default as typeof parseTimestamp;
+    mocks.parseTimestamp.mockImplementation(actualParseTimestamp);
+  });
+  afterEach(() => {
+    mocks.parseTimestamp.mockReset();
   });
 
-  it("should correctly parse regular cue blocks", async () => {
-    const parseCueBlock = (await vi.importActual("../parse_cue_block"))
-      .default as typeof IParseCueBlock;
+  it("should correctly parse regular cue blocks", () => {
     expect(parseCueBlock(cueBlock1, 0)).toEqual({
       start: 31.08,
       end: 452.2,
@@ -87,9 +102,7 @@ describe("parsers - srt - parseCueBlocks", () => {
     });
   });
 
-  it("should add timeOffset in seconds", async () => {
-    const parseCueBlock = (await vi.importActual("../parse_cue_block"))
-      .default as typeof IParseCueBlock;
+  it("should add timeOffset in seconds", () => {
     expect(parseCueBlock(cueBlock1, 10.1)).toEqual({
       start: 41.18,
       end: 462.3,
@@ -146,9 +159,7 @@ describe("parsers - srt - parseCueBlocks", () => {
     });
   });
 
-  it("should return null for invalid cue blocks", async () => {
-    const parseCueBlock = (await vi.importActual("../parse_cue_block"))
-      .default as typeof IParseCueBlock;
+  it("should return null for invalid cue blocks", () => {
     expect(parseCueBlock(notCueBlock1, 0)).toEqual(null);
     expect(parseCueBlock(notCueBlock1, 5)).toEqual(null);
     expect(parseCueBlock(notCueBlock2, 0)).toEqual(null);
@@ -161,27 +172,19 @@ describe("parsers - srt - parseCueBlocks", () => {
     expect(parseCueBlock(notCueBlock7, 0)).toEqual(null);
   });
 
-  it("should return null if parseTimestamp returns undefined either for the starting timestamp", async () => {
-    const parseTimestamp = vi.fn((arg) => (arg === "00:00:31.080" ? undefined : 10));
-    vi.doMock("../parse_timestamp", () => ({
-      default: parseTimestamp,
-    }));
-    const parseCueBlock = (await vi.importActual("../parse_cue_block"))
-      .default as typeof IParseCueBlock;
-
+  it("should return null if parseTimestamp returns undefined either for the starting timestamp", () => {
+    mocks.parseTimestamp.mockImplementation((arg) =>
+      arg === "00:00:31.080" ? undefined : 10,
+    );
     expect(parseCueBlock(cueBlock1, 0)).toEqual(null);
-    expect(parseTimestamp).toHaveBeenCalledTimes(2);
+    expect(mocks.parseTimestamp).toHaveBeenCalledTimes(2);
   });
 
-  it("should return null if parseTimestamp returns undefined either for the ending timestamp", async () => {
-    const parseTimestamp = vi.fn((arg) => (arg === "00:07:32.200" ? undefined : 10));
-    vi.doMock("../parse_timestamp", () => ({
-      default: parseTimestamp,
-    }));
-    const parseCueBlock = (await vi.importActual("../parse_cue_block"))
-      .default as typeof IParseCueBlock;
-
+  it("should return null if parseTimestamp returns undefined either for the ending timestamp", () => {
+    mocks.parseTimestamp.mockImplementation((arg) =>
+      arg === "00:07:32.200" ? undefined : 10,
+    );
     expect(parseCueBlock(cueBlock1, 0)).toEqual(null);
-    expect(parseTimestamp).toHaveBeenCalledTimes(2);
+    expect(mocks.parseTimestamp).toHaveBeenCalledTimes(2);
   });
 });

package/src/parsers/texttracks/webvtt/__tests__/parse_style_block.test.ts

@@ -1,29 +1,32 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
-import type IParseStyleBlock from "../parse_style_block";
+import parseStyleBlock from "../parse_style_block";
+
+const mocks = vi.hoisted(() => {
+  return {
+    createDefaultStyleElements: vi.fn(),
+  };
+});
+vi.mock("../create_default_style_elements", () => ({
+  default: mocks.createDefaultStyleElements,
+}));
 
 describe("parsers - webvtt - parseStyleBlock", () => {
   beforeEach(() => {
     vi.resetModules();
+    mocks.createDefaultStyleElements.mockReset();
   });
 
-  it("should correctly handle empty style blocks", async () => {
+  it("should correctly handle empty style blocks", () => {
     const webvttStyle = [["STYLE"], []];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {},
       global: "",
     });
   });
 
-  it("should parse global style", async () => {
+  it("should parse global style", () => {
     const webvttStyle = [
       [
         "STYLE",
@@ -33,15 +36,8 @@ describe("parsers - webvtt - parseStyleBlock", () => {
         "}",
       ],
     ];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {},
       global:
@@ -50,17 +46,10 @@ describe("parsers - webvtt - parseStyleBlock", () => {
     });
   });
 
-  it("should parse class style", async () => {
+  it("should parse class style", () => {
     const webvttStyle = [["STYLE", "::cue(b) {", "  color: peachpuff;", "}"]];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {
         b: "  color: peachpuff;",
@@ -69,7 +58,7 @@ describe("parsers - webvtt - parseStyleBlock", () => {
     });
   });
 
-  it("should parse both global and class style", async () => {
+  it("should parse both global and class style", () => {
     const webvttStyle = [
       [
         "STYLE",
@@ -80,15 +69,8 @@ describe("parsers - webvtt - parseStyleBlock", () => {
       ],
       ["STYLE", "::cue(b) {", "  color: peachpuff;", "}"],
     ];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       global:
         "background-image: linear-gradient(to bottom, dimgray, lightgray);" +
@@ -99,20 +81,13 @@ describe("parsers - webvtt - parseStyleBlock", () => {
     });
   });
 
-  it("should not parse unformed styles", async () => {
+  it("should not parse unformed styles", () => {
     const webvttStyle = [
       ["BAD STYLE"],
       ["STYLE", "::cue(b) {", "  color: peachpuff;", "}"],
     ];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {
         b: "  color: peachpuff;",
@@ -121,20 +96,13 @@ describe("parsers - webvtt - parseStyleBlock", () => {
     });
   });
 
-  it("should not override styles if class if declared several times", async () => {
+  it("should not override styles if class if declared several times", () => {
     const webvttStyle = [
       ["STYLE", "::cue(b) {", "  color: peachpuff;", "}"],
       ["STYLE", "::cue(b) {", "  background-color: dark;", "}"],
     ];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {
         b: "  color: peachpuff;  background-color: dark;",
@@ -143,7 +111,7 @@ describe("parsers - webvtt - parseStyleBlock", () => {
     });
   });
 
-  it("should take into account all cues declared in one style block", async () => {
+  it("should take into account all cues declared in one style block", () => {
     const webvttStyle = [
       [
         "STYLE",
@@ -155,15 +123,8 @@ describe("parsers - webvtt - parseStyleBlock", () => {
         "}",
       ],
     ];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {
         b: "  background-color: dark;",
@@ -172,7 +133,7 @@ describe("parsers - webvtt - parseStyleBlock", () => {
     });
   });
 
-  it("should consider a cue declared in multi-cue and mono-cue style blocks", async () => {
+  it("should consider a cue declared in multi-cue and mono-cue style blocks", () => {
     const webvttStyle = [
       [
         "STYLE",
@@ -185,15 +146,8 @@ describe("parsers - webvtt - parseStyleBlock", () => {
       ],
       ["STYLE", "::cue(b) {", "  color: salmon;", "}"],
     ];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {
         b: "  background-color: dark;  color: salmon;",
@@ -201,7 +155,7 @@ describe("parsers - webvtt - parseStyleBlock", () => {
       global: "  color: peachpuff;",
     });
   });
-  it("should consider a cue declared in multi-cue and mono-cue style blocks", async () => {
+  it("should consider a cue declared in multi-cue and mono-cue style blocks", () => {
     const webvttStyle = [
       [
         "STYLE",
@@ -214,15 +168,8 @@ describe("parsers - webvtt - parseStyleBlock", () => {
       ],
       ["STYLE", "::cue(b) {", "  color: salmon;", "}"],
     ];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {
         b: "  background-color: dark;  color: salmon;",
@@ -231,20 +178,13 @@ describe("parsers - webvtt - parseStyleBlock", () => {
     });
   });
 
-  it("should consider multiple class declaration for one stylesheet", async () => {
+  it("should consider multiple class declaration for one stylesheet", () => {
     const webvttStyle = [
       ["STYLE", "::cue(c),", "::cue(d),", "::cue(b) {", "  background-color: dark;", "}"],
       ["STYLE", "::cue(c) {", "  color: salmon;", "}"],
     ];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {
         b: "  background-color: dark;",
@@ -255,17 +195,10 @@ describe("parsers - webvtt - parseStyleBlock", () => {
     });
   });
 
-  it("should return empty style if no style block", async () => {
+  it("should return empty style if no style block", () => {
     const webvttStyle: string[][] = [];
+    mocks.createDefaultStyleElements.mockImplementation(() => ({}));
 
-    const mockCreateDefaultStyleElements = vi.fn(() => ({}));
-    vi.doMock("../create_default_style_elements", () => ({
-      default: () => {
-        return mockCreateDefaultStyleElements();
-      },
-    }));
-    const parseStyleBlock = (await vi.importActual("../parse_style_block"))
-      .default as typeof IParseStyleBlock;
     expect(parseStyleBlock(webvttStyle)).toEqual({
       classes: {},
       global: "",

package/src/parsers/texttracks/webvtt/html/__tests__/convert_payload_to_html.test.ts

@@ -1,16 +1,26 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
 import globalScope from "../../../../../utils/global_scope";
-import type IConvertPayloadToHTML from "../convert_payload_to_html";
+import convertPayloadToHTML from "../convert_payload_to_html";
+
+const mocks = vi.hoisted(() => {
+  return {
+    createStyledElement: vi.fn(),
+  };
+});
+vi.mock("../create_styled_element", () => ({
+  default: mocks.createStyledElement,
+}));
 
 describe("parsers - webvtt - convertPayloadToHTML", () => {
   beforeEach(() => {
     vi.resetModules();
+    mocks.createStyledElement.mockReset();
   });
 
   const gs = globalScope as {
     DOMParser: unknown;
   };
-  it("should return empty payload when input text is empty", async () => {
+  it("should return empty payload when input text is empty", () => {
     const spyParseFromString = vi.fn(() => {
       return {
         body: {
@@ -26,20 +36,13 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
       }
     };
 
-    const spy = vi.fn();
-    vi.doMock("../create_styled_element", () => ({
-      default: spy,
-    }));
-
-    const convertPayloadToHTML = (await vi.importActual("../convert_payload_to_html"))
-      .default as typeof IConvertPayloadToHTML;
     expect(convertPayloadToHTML("", {})).toEqual([]);
     expect(spyParseFromString).toHaveBeenCalledTimes(1);
-    expect(spy).not.toHaveBeenCalled();
+    expect(mocks.createStyledElement).not.toHaveBeenCalled();
     gs.DOMParser = origDOMParser;
   });
 
-  it("should convert normal input text with no style", async () => {
+  it("should convert normal input text with no style", () => {
     const innerText = "<b></b>Hello";
     const bNode = document.createElement("b");
     const textNode = document.createTextNode("Hello");
@@ -53,16 +56,13 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
 
     const span = document.createElement("span");
     span.textContent = "Hello";
-    const spyCreateStyledElement = vi.fn((input: Node) => {
+    mocks.createStyledElement.mockImplementation((input: Node) => {
       if (input.nodeName === bNode.nodeName) {
         return bNode;
       } else if (input.nodeName === textNode.nodeName) {
         return span;
       }
     });
-    vi.doMock("../create_styled_element", () => ({
-      default: spyCreateStyledElement,
-    }));
 
     const origDOMParser = gs.DOMParser;
     gs.DOMParser = class MockDOMParser {
@@ -71,11 +71,9 @@ describe("parsers - webvtt - convertPayloadToHTML", () => {
       }
     };
 
-    const convertPayloadToHTML = (await vi.importActual("../convert_payload_to_html"))
-      .default as typeof IConvertPayloadToHTML;
     expect(convertPayloadToHTML(innerText, {})).toEqual([bNode, span]);
     expect(spyParseFromString).toHaveBeenCalledTimes(1);
-    expect(spyCreateStyledElement).toHaveBeenCalledTimes(2);
+    expect(mocks.createStyledElement).toHaveBeenCalledTimes(2);
     gs.DOMParser = origDOMParser;
   });
 });

package/src/parsers/texttracks/webvtt/html/__tests__/parse_webvtt_to_div.test.ts

@@ -1,79 +1,94 @@
-import { describe, beforeEach, it, expect, vi } from "vitest";
-import type IParseWebVTTPlainText from "../parse_webvtt_plain_text";
+import { describe, beforeEach, it, expect, vi, afterEach } from "vitest";
+import parseWebVTT from "../parse_webvtt_plain_text";
+
+const mocks = vi.hoisted(() => {
+  return {
+    getStyleBlocks: vi.fn(),
+    getCueBlocks: vi.fn(),
+    parseStyleBlock: vi.fn(),
+    parseCueBlock: vi.fn(),
+    toHtml: vi.fn(),
+    getFirstLineAfterHeader: vi.fn(),
+  };
+});
+vi.mock("../../get_style_blocks", () => ({
+  default: mocks.getStyleBlocks,
+}));
+vi.mock("../../get_cue_blocks", () => ({
+  default: mocks.getCueBlocks,
+}));
+vi.mock("../../parse_cue_block", () => ({
+  default: mocks.parseCueBlock,
+}));
+vi.mock("../../parse_style_block", () => ({
+  default: mocks.parseStyleBlock,
+}));
+vi.mock("../to_html", () => ({
+  default: mocks.toHtml,
+}));
+vi.mock("../../utils", () => ({
+  getFirstLineAfterHeader: mocks.getFirstLineAfterHeader,
+}));
 
 describe("parsers - webvtt - parseWebVTT", () => {
   beforeEach(() => {
     vi.resetModules();
   });
+  afterEach(() => {
+    mocks.getStyleBlocks.mockReset();
+    mocks.getCueBlocks.mockReset();
+    mocks.parseStyleBlock.mockReset();
+    mocks.parseCueBlock.mockReset();
+    mocks.toHtml.mockReset();
+    mocks.getFirstLineAfterHeader.mockReset();
+  });
 
-  it("should throw if text is empty", async () => {
-    const parseWebVTT = (await vi.importActual("../parse_webvtt_plain_text.ts"))
-      .default as typeof IParseWebVTTPlainText;
-    expect(() => parseWebVTT("", 1, 0)).toThrowError("Can't parse WebVTT: Invalid File.");
+  it("should throw if text is empty", () => {
+    expect(() => parseWebVTT("", {}, 0)).toThrowError(
+      "Can't parse WebVTT: Invalid File.",
+    );
   });
 
-  it("should throw if file seems to be invalid", async () => {
-    const parseWebVTT = (await vi.importActual("../parse_webvtt_plain_text.ts"))
-      .default as typeof IParseWebVTTPlainText;
-    expect(() => parseWebVTT("WEBWTT\n", 1, 0)).toThrowError(
+  it("should throw if file seems to be invalid", () => {
+    expect(() => parseWebVTT("WEBWTT\n", {}, 0)).toThrowError(
       "Can't parse WebVTT: Invalid File.",
     );
   });
 
-  it("should return cues if inner contains right cues", async () => {
-    const spyGetStyleBlock = vi.fn(() => [
+  it("should return cues if inner contains right cues", () => {
+    mocks.getStyleBlocks.mockImplementation(() => [
       ["STYLE", ""],
       ["STYLE", ""],
     ]);
-    vi.doMock("../../get_style_blocks", () => ({
-      default: spyGetStyleBlock,
-    }));
 
-    const spyGetCueBlock = vi.fn(() => [
+    mocks.getCueBlocks.mockImplementation(() => [
       ["CUE", ""],
       ["CUE", ""],
     ]);
-    vi.doMock("../../get_cue_blocks", () => ({
-      default: spyGetCueBlock,
-    }));
 
-    const spyParseCueBlock = vi.fn(() => ({
+    mocks.parseCueBlock.mockImplementation(() => ({
       start: 0,
       end: 100,
       payload: "<b>Test</b>Bonjour",
       header: "b",
       settings: {},
     }));
-    vi.doMock("../../parse_cue_block", () => ({
-      default: spyParseCueBlock,
-    }));
 
-    const spyParseStyleBlock = vi.fn(() => ({
+    mocks.parseStyleBlock.mockImplementation(() => ({
       b: {
         styleContent: "color:blue;",
       },
     }));
-    vi.doMock("../../parse_style_block", () => ({
-      default: spyParseStyleBlock,
-    }));
 
-    const spyToHTML = vi.fn(() => ({
+    mocks.toHtml.mockImplementation(() => ({
       start: 0,
       end: 100,
       element: document.createElement("div"),
     }));
-    vi.doMock("../to_html", () => ({
-      default: spyToHTML,
-    }));
 
-    const spyGetFirstLineAfterHeader = vi.fn(() => 1);
-    vi.doMock("../../utils", () => ({
-      getFirstLineAfterHeader: spyGetFirstLineAfterHeader,
-    }));
+    mocks.getFirstLineAfterHeader.mockImplementation(() => 1);
 
-    const parseWebVTT = (await vi.importActual("../parse_webvtt_plain_text.ts"))
-      .default as typeof IParseWebVTTPlainText;
-    expect(parseWebVTT("WEBVTT\n", 1, 0)).toEqual([
+    expect(parseWebVTT("WEBVTT\n", {}, 0)).toEqual([
       {
         element: document.createElement("div"),
         end: 100,
@@ -85,67 +100,47 @@ describe("parsers - webvtt - parseWebVTT", () => {
         start: 0,
       },
     ]);
-    expect(spyGetFirstLineAfterHeader).toHaveBeenCalledTimes(1);
-    expect(spyGetStyleBlock).toHaveBeenCalledTimes(1);
-    expect(spyGetCueBlock).toHaveBeenCalledTimes(1);
-    expect(spyParseStyleBlock).toHaveBeenCalledTimes(1);
-    expect(spyParseCueBlock).toHaveBeenCalledTimes(2);
-    expect(spyToHTML).toHaveBeenCalledTimes(2);
+    expect(mocks.getFirstLineAfterHeader).toHaveBeenCalledTimes(1);
+    expect(mocks.getStyleBlocks).toHaveBeenCalledTimes(1);
+    expect(mocks.getCueBlocks).toHaveBeenCalledTimes(1);
+    expect(mocks.parseStyleBlock).toHaveBeenCalledTimes(1);
+    expect(mocks.parseCueBlock).toHaveBeenCalledTimes(2);
+    expect(mocks.toHtml).toHaveBeenCalledTimes(2);
   });
 
-  it("should return empty array if cue blocks can't be parsed", async () => {
-    const spyGetStyleBlock = vi.fn(() => [
+  it("should return empty array if cue blocks can't be parsed", () => {
+    mocks.getStyleBlocks.mockImplementation(() => [
       ["STYLE", ""],
       ["STYLE", ""],
     ]);
-    vi.doMock("../../get_style_blocks", () => ({
-      default: spyGetStyleBlock,
-    }));
 
-    const spyGetCueBlock = vi.fn(() => [
+    mocks.getCueBlocks.mockImplementation(() => [
       ["CUE", ""],
       ["CUE", ""],
     ]);
-    vi.doMock("../../get_cue_blocks", () => ({
-      default: spyGetCueBlock,
-    }));
 
-    const spyParseCueBlock = vi.fn(() => null);
-    vi.doMock("../../parse_cue_block", () => ({
-      default: spyParseCueBlock,
-    }));
+    mocks.parseCueBlock.mockImplementation(() => null);
 
-    const spyParseStyleBlock = vi.fn(() => ({
+    mocks.parseStyleBlock.mockImplementation(() => ({
       b: {
         styleContent: "color:blue;",
       },
     }));
-    vi.doMock("../../parse_style_block", () => ({
-      default: spyParseStyleBlock,
-    }));
 
-    const spyToHTML = vi.fn(() => ({
+    mocks.toHtml.mockImplementation(() => ({
       start: 0,
       end: 100,
       element: document.createElement("div"),
     }));
-    vi.doMock("../to_html", () => ({
-      default: spyToHTML,
-    }));
 
-    const spyGetFirstLineAfterHeader = vi.fn(() => 1);
-    vi.doMock("../../utils", () => ({
-      getFirstLineAfterHeader: spyGetFirstLineAfterHeader,
-    }));
+    mocks.getFirstLineAfterHeader.mockImplementation(() => 1);
 
-    const parseWebVTT = (await vi.importActual("../parse_webvtt_plain_text.ts"))
-      .default as typeof IParseWebVTTPlainText;
-    expect(parseWebVTT("WEBVTT\n", 1, 0)).toEqual([]);
-    expect(spyGetFirstLineAfterHeader).toHaveBeenCalledTimes(1);
-    expect(spyGetStyleBlock).toHaveBeenCalledTimes(1);
-    expect(spyGetCueBlock).toHaveBeenCalledTimes(1);
-    expect(spyParseStyleBlock).toHaveBeenCalledTimes(1);
-    expect(spyParseCueBlock).toHaveBeenCalledTimes(2);
-    expect(spyToHTML).not.toHaveBeenCalled();
+    expect(parseWebVTT("WEBVTT\n", {}, 0)).toEqual([]);
+    expect(mocks.getFirstLineAfterHeader).toHaveBeenCalledTimes(1);
+    expect(mocks.getStyleBlocks).toHaveBeenCalledTimes(1);
+    expect(mocks.getCueBlocks).toHaveBeenCalledTimes(1);
+    expect(mocks.parseStyleBlock).toHaveBeenCalledTimes(1);
+    expect(mocks.parseCueBlock).toHaveBeenCalledTimes(2);
+    expect(mocks.toHtml).not.toHaveBeenCalled();
   });
 });