@remotion/renderer 4.0.254 → 4.0.256

package/dist/browser/Browser.d.ts

@@ -50,12 +50,24 @@ export declare class HeadlessBrowser extends EventEmitter {
         runner: BrowserRunner;
     });
     browserContexts(): BrowserContext[];
-    newPage(context: SourceMapGetter, logLevel: LogLevel, indent: boolean): Promise<Page>;
-    _createPageInContext(context: SourceMapGetter, logLevel: LogLevel, indent: boolean): Promise<Page>;
+    newPage({ context, logLevel, indent, pageIndex, }: {
+        context: SourceMapGetter;
+        logLevel: LogLevel;
+        indent: boolean;
+        pageIndex: number;
+    }): Promise<Page>;
+    _createPageInContext({ context, logLevel, indent, pageIndex, }: {
+        context: SourceMapGetter;
+        logLevel: LogLevel;
+        indent: boolean;
+        pageIndex: number;
+    }): Promise<Page>;
     targets(): Target[];
     waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: WaitForTargetOptions): Promise<Target>;
-    pages(logLevel: LogLevel, indent: boolean): Promise<Page[]>;
-    close(silent: boolean, logLevel: LogLevel, indent: boolean): Promise<void>;
+    pages(): Promise<Page[]>;
+    close({ silent }: {
+        silent: boolean;
+    }): Promise<void>;
     disconnect(): void;
 }
 export declare class BrowserContext extends EventEmitter {
@@ -65,8 +77,13 @@ export declare class BrowserContext extends EventEmitter {
     waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: {
         timeout?: number;
     }): Promise<Target>;
-    pages(logLevel: LogLevel, indent: boolean): Promise<Page[]>;
-    newPage(context: SourceMapGetter, logLevel: LogLevel, indent: boolean): Promise<Page>;
+    pages(): Promise<Page[]>;
+    newPage({ context, logLevel, indent, pageIndex, }: {
+        context: SourceMapGetter;
+        logLevel: LogLevel;
+        indent: boolean;
+        pageIndex: number;
+    }): Promise<Page>;
     browser(): HeadlessBrowser;
 }
 export {};

package/dist/browser/Browser.js

@@ -75,10 +75,10 @@ class HeadlessBrowser extends EventEmitter_1.EventEmitter {
     browserContexts() {
         return [__classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f"), ...Array.from(__classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").values())];
     }
-    newPage(context, logLevel, indent) {
-        return __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f").newPage(context, logLevel, indent);
+    newPage({ context, logLevel, indent, pageIndex, }) {
+        return __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f").newPage({ context, logLevel, indent, pageIndex });
     }
-    async _createPageInContext(context, logLevel, indent) {
+    async _createPageInContext({ context, logLevel, indent, pageIndex, }) {
         const { value: { targetId }, } = await this.connection.send('Target.createTarget', {
             url: 'about:blank',
             browserContextId: undefined,
@@ -91,7 +91,12 @@ class HeadlessBrowser extends EventEmitter_1.EventEmitter {
         if (!initialized) {
             throw new Error(`Failed to create target for page (id = ${targetId})`);
         }
-        const page = await target.page(context, logLevel, indent);
+        const page = await target.page({
+            sourceMapGetter: context,
+            logLevel,
+            indent,
+            pageIndex,
+        });
         if (!page) {
             throw new Error(`Failed to create a page for context`);
         }
@@ -129,18 +134,18 @@ class HeadlessBrowser extends EventEmitter_1.EventEmitter {
             }
         }
     }
-    async pages(logLevel, indent) {
+    async pages() {
         const contextPages = await Promise.all(this.browserContexts().map((context) => {
-            return context.pages(logLevel, indent);
+            return context.pages();
         }));
         // Flatten array.
         return contextPages.reduce((acc, x) => {
             return acc.concat(x);
         }, []);
     }
-    async close(silent, logLevel, indent) {
+    async close({ silent }) {
         await this.runner.closeProcess();
-        (await this.pages(logLevel, indent)).forEach((page) => {
+        (await this.pages()).forEach((page) => {
             page.emit("disposed" /* PageEmittedEvents.Disposed */);
             page.closed = true;
         });
@@ -207,16 +212,21 @@ class BrowserContext extends EventEmitter_1.EventEmitter {
             return target.browserContext() === this && predicate(target);
         }, options);
     }
-    async pages(logLevel, indent) {
+    async pages() {
         const pages = await Promise.all(this.targets()
             .filter((target) => target.type() === 'page')
-            .map((target) => target.page(() => null, logLevel, indent)));
+            .map((target) => target.expectPage()));
         return pages.filter((page) => {
             return Boolean(page);
         });
     }
-    newPage(context, logLevel, indent) {
-        return __classPrivateFieldGet(this, _BrowserContext_browser, "f")._createPageInContext(context, logLevel, indent);
+    newPage({ context, logLevel, indent, pageIndex, }) {
+        return __classPrivateFieldGet(this, _BrowserContext_browser, "f")._createPageInContext({
+            context,
+            logLevel,
+            indent,
+            pageIndex,
+        });
     }
     browser() {
         return __classPrivateFieldGet(this, _BrowserContext_browser, "f");

package/dist/browser/BrowserConnector.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * 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 { Viewport } from './PuppeteerViewport';
+export interface BrowserConnectOptions {
+    defaultViewport: Viewport;
+}

package/dist/browser/BrowserConnector.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/browser/BrowserPage.d.ts

@@ -27,7 +27,7 @@ interface PageEventObject {
 export declare class Page extends EventEmitter {
     #private;
     id: string;
-    static _create({ client, target, defaultViewport, browser, sourceMapGetter, logLevel, indent, }: {
+    static _create({ client, target, defaultViewport, browser, sourceMapGetter, logLevel, indent, pageIndex, }: {
         client: CDPSession;
         target: Target;
         defaultViewport: Viewport;
@@ -35,19 +35,22 @@ export declare class Page extends EventEmitter {
         sourceMapGetter: SourceMapGetter;
         logLevel: LogLevel;
         indent: boolean;
+        pageIndex: number;
     }): Promise<Page>;
     closed: boolean;
     browser: HeadlessBrowser;
     screenshotTaskQueue: TaskQueue;
     sourceMapGetter: SourceMapGetter;
     logLevel: LogLevel;
-    constructor({ client, target, browser, sourceMapGetter, logLevel, indent, }: {
+    pageIndex: number;
+    constructor({ client, target, browser, sourceMapGetter, logLevel, indent, pageIndex, }: {
         client: CDPSession;
         target: Target;
         browser: HeadlessBrowser;
         sourceMapGetter: SourceMapGetter;
         logLevel: LogLevel;
         indent: boolean;
+        pageIndex: number;
     });
     /**
      * Listen to page events.

package/dist/browser/BrowserPage.js

@@ -49,7 +49,7 @@ const shouldHideWarning = (log) => {
     return false;
 };
 class Page extends EventEmitter_1.EventEmitter {
-    static async _create({ client, target, defaultViewport, browser, sourceMapGetter, logLevel, indent, }) {
+    static async _create({ client, target, defaultViewport, browser, sourceMapGetter, logLevel, indent, pageIndex, }) {
         const page = new Page({
             client,
             target,
@@ -57,12 +57,13 @@ class Page extends EventEmitter_1.EventEmitter {
             sourceMapGetter,
             logLevel,
             indent,
+            pageIndex,
         });
         await __classPrivateFieldGet(page, _Page_instances, "m", _Page_initialize).call(page);
         await page.setViewport(defaultViewport);
         return page;
     }
-    constructor({ client, target, browser, sourceMapGetter, logLevel, indent, }) {
+    constructor({ client, target, browser, sourceMapGetter, logLevel, indent, pageIndex, }) {
         super();
         _Page_instances.add(this);
         this.closed = false;
@@ -79,6 +80,7 @@ class Page extends EventEmitter_1.EventEmitter {
         this.id = String(Math.random());
         this.sourceMapGetter = sourceMapGetter;
         this.logLevel = logLevel;
+        this.pageIndex = pageIndex;
         client.on('Target.attachedToTarget', (event) => {
             switch (event.targetInfo.type) {
                 case 'iframe':

package/dist/browser/Launcher.js

@@ -34,7 +34,7 @@ const launchChrome = async ({ args, executablePath, defaultViewport, indent, log
         }, { timeout });
     }
     catch (error) {
-        await browser.close(false, logLevel, indent);
+        await browser.close({ silent: false });
         throw error;
     }
     return browser;

package/dist/browser/PuppeteerNode.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * 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 { HeadlessBrowser } from './Browser';
+import type { BrowserConnectOptions } from './BrowserConnector';
+import type { ProductLauncher } from './Launcher';
+import type { BrowserLaunchArgumentOptions, LaunchOptions } from './LaunchOptions';
+interface PuppeteerLaunchOptions extends LaunchOptions, BrowserLaunchArgumentOptions, BrowserConnectOptions {
+    extraPrefsFirefox?: Record<string, unknown>;
+}
+export declare class PuppeteerNode {
+    #private;
+    constructor();
+    launch(options: PuppeteerLaunchOptions): Promise<HeadlessBrowser>;
+    executablePath(channel?: string): string;
+    get _launcher(): ProductLauncher;
+}
+export {};

package/dist/browser/PuppeteerNode.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _PuppeteerNode_lazyLauncher;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerNode = void 0;
+const Launcher_1 = require("./Launcher");
+class PuppeteerNode {
+    constructor() {
+        _PuppeteerNode_lazyLauncher.set(this, void 0);
+        this.launch = this.launch.bind(this);
+        this.executablePath = this.executablePath.bind(this);
+    }
+    launch(options) {
+        return this._launcher.launch(options);
+    }
+    executablePath(channel) {
+        return this._launcher.executablePath(channel);
+    }
+    get _launcher() {
+        if (!__classPrivateFieldGet(this, _PuppeteerNode_lazyLauncher, "f")) {
+            __classPrivateFieldSet(this, _PuppeteerNode_lazyLauncher, new Launcher_1.ChromeLauncher(), "f");
+        }
+        return __classPrivateFieldGet(this, _PuppeteerNode_lazyLauncher, "f");
+    }
+}
+exports.PuppeteerNode = PuppeteerNode;
+_PuppeteerNode_lazyLauncher = new WeakMap();

package/dist/browser/Target.d.ts

@@ -37,7 +37,13 @@ export declare class Target {
     /**
      * If the target is not of type `"page"` or `"background_page"`, returns `null`.
      */
-    page(sourceMapGetter: SourceMapGetter, logLevel: LogLevel, indent: boolean): Promise<Page | null>;
+    page({ sourceMapGetter, logLevel, indent, pageIndex, }: {
+        sourceMapGetter: SourceMapGetter;
+        logLevel: LogLevel;
+        indent: boolean;
+        pageIndex: number;
+    }): Promise<Page | null>;
+    expectPage(): Promise<Page | null>;
     url(): string;
     /**
      * Identifies what kind of target this is.

package/dist/browser/Target.js

@@ -79,7 +79,7 @@ class Target {
     /**
      * If the target is not of type `"page"` or `"background_page"`, returns `null`.
      */
-    async page(sourceMapGetter, logLevel, indent) {
+    async page({ sourceMapGetter, logLevel, indent, pageIndex, }) {
         var _a;
         if (isPagetTarget(__classPrivateFieldGet(this, _Target_targetInfo, "f")) && !__classPrivateFieldGet(this, _Target_pagePromise, "f")) {
             __classPrivateFieldSet(this, _Target_pagePromise, __classPrivateFieldGet(this, _Target_sessionFactory, "f").call(this).then((client) => {
@@ -92,11 +92,16 @@ class Target {
                     sourceMapGetter,
                     logLevel,
                     indent,
+                    pageIndex,
                 });
             }), "f");
         }
         return (_a = (await __classPrivateFieldGet(this, _Target_pagePromise, "f"))) !== null && _a !== void 0 ? _a : null;
     }
+    async expectPage() {
+        var _a;
+        return (_a = (await __classPrivateFieldGet(this, _Target_pagePromise, "f"))) !== null && _a !== void 0 ? _a : null;
+    }
     url() {
         return __classPrivateFieldGet(this, _Target_targetInfo, "f").url;
     }

package/dist/browser/mitt/index.js

@@ -19,21 +19,21 @@ function mitt(all) {
          * @param {Function} handler Function to call in response to given event
          * @memberOf mitt
          */
-        on(type, handler) {
+        on: (type, handler) => {
             const handlers = all === null || all === void 0 ? void 0 : all.get(type);
             const added = handlers === null || handlers === void 0 ? void 0 : handlers.push(handler);
             if (!added) {
                 all === null || all === void 0 ? void 0 : all.set(type, [handler]);
             }
         },
-        off(type, handler) {
+        off: (type, handler) => {
             const handlers = all === null || all === void 0 ? void 0 : all.get(type);
             if (handlers) {
                 // eslint-disable-next-line no-bitwise
                 handlers.splice(handlers.indexOf(handler) >>> 0, 1);
             }
         },
-        emit(type, evt) {
+        emit: (type, evt) => {
             ((all === null || all === void 0 ? void 0 : all.get(type)) || [])
                 .slice()
                 .forEach((handler) => {

package/dist/browser/node.d.ts

@@ -0,0 +1,2 @@
+import { PuppeteerNode } from './PuppeteerNode';
+export declare const puppeteer: PuppeteerNode;

package/dist/browser/node.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.puppeteer = void 0;
+const PuppeteerNode_1 = require("./PuppeteerNode");
+exports.puppeteer = new PuppeteerNode_1.PuppeteerNode();

package/dist/browser-instances.js

@@ -5,7 +5,7 @@ const browserInstances = [];
 const killAllBrowsers = async () => {
     for (const browser of browserInstances) {
         try {
-            await browser.close(true, 'info', false);
+            await browser.close({ silent: true });
         }
         catch (_a) { }
     }

package/dist/can-use-parallel-encoding.d.ts

@@ -1,2 +1,3 @@
 import type { Codec } from './codec';
 export declare const canUseParallelEncoding: (codec: Codec) => boolean;
+export declare const getShouldUsePartitionedRendering: () => boolean;

package/dist/can-use-parallel-encoding.js

@@ -1,11 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.canUseParallelEncoding = void 0;
+exports.getShouldUsePartitionedRendering = exports.canUseParallelEncoding = void 0;
 const is_audio_codec_1 = require("./is-audio-codec");
 const canUseParallelEncoding = (codec) => {
+    if ((0, exports.getShouldUsePartitionedRendering)()) {
+        return false;
+    }
     if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
         return false;
     }
     return codec === 'h264' || codec === 'h264-mkv' || codec === 'h265';
 };
 exports.canUseParallelEncoding = canUseParallelEncoding;
+const getShouldUsePartitionedRendering = () => {
+    const shouldUsePartitionedRendering = process.env.REMOTION_PARTITIONED_RENDERING === 'true';
+    return shouldUsePartitionedRendering;
+};
+exports.getShouldUsePartitionedRendering = getShouldUsePartitionedRendering;

package/dist/client.d.ts

@@ -394,7 +394,7 @@ export declare const BrowserSafeApis: {
         webhookCustomDataOption: {
             name: string;
             cliFlag: "webhook-custom-data";
-            description: (type: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
+            description: (type: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
             ssrName: "customData";
             docLink: string;
             type: Record<string, unknown> | null;
@@ -807,7 +807,7 @@ export declare const BrowserSafeApis: {
         metadataOption: {
             name: string;
             cliFlag: "metadata";
-            description: (mode: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
+            description: (mode: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
             docLink: string;
             type: import("./options/metadata").Metadata;
             getValue: ({ commandLine }: {

package/dist/copy-to-clipboard.d.ts

@@ -0,0 +1,2 @@
+import type { LogLevel } from './log-level';
+export declare const copyImageToClipboard: (src: string, logLevel: LogLevel, binariesDirectory: string | null) => Promise<void>;

package/dist/copy-to-clipboard.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyImageToClipboard = void 0;
+const compositor_1 = require("./compositor/compositor");
+const copyImageToClipboard = async (src, logLevel, binariesDirectory) => {
+    const compositor = (0, compositor_1.startLongRunningCompositor)({
+        maximumFrameCacheItemsInBytes: null,
+        logLevel,
+        indent: false,
+        binariesDirectory,
+    });
+    await compositor.executeCommand('CopyImageToClipboard', {
+        src,
+    });
+    await compositor.finishCommands();
+    await compositor.waitForDone();
+};
+exports.copyImageToClipboard = copyImageToClipboard;

package/dist/cycle-browser-tabs.d.ts

@@ -1,5 +1,10 @@
 import type { LogLevel } from './log-level';
 import type { BrowserReplacer } from './replace-browser';
-export declare const cycleBrowserTabs: (puppeteerInstance: BrowserReplacer, concurrency: number, logLevel: LogLevel, indent: boolean) => {
+export declare const cycleBrowserTabs: ({ puppeteerInstance, concurrency, logLevel, indent, }: {
+    puppeteerInstance: BrowserReplacer;
+    concurrency: number;
+    logLevel: LogLevel;
+    indent: boolean;
+}) => {
     stopCycling: () => void;
 };

package/dist/cycle-browser-tabs.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cycleBrowserTabs = void 0;
 const logger_1 = require("./logger");
-const cycleBrowserTabs = (puppeteerInstance, concurrency, logLevel, indent) => {
+const cycleBrowserTabs = ({ puppeteerInstance, concurrency, logLevel, indent, }) => {
     if (concurrency <= 1) {
         return {
             stopCycling: () => undefined,
@@ -15,7 +15,7 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency, logLevel, indent) => {
         interval = setTimeout(() => {
             puppeteerInstance
                 .getBrowser()
-                .pages(logLevel, indent)
+                .pages()
                 .then((pages) => {
                 if (pages.length === 0) {
                     return;

package/dist/example-videos.d.ts

@@ -0,0 +1,34 @@
+export declare const exampleVideos: {
+    bigBuckBunny: string;
+    transparentWebm: string;
+    framerWithoutFileExtension: string;
+    corrupted: string;
+    customDar: string;
+    screenrecording: string;
+    nofps: string;
+    variablefps: string;
+    zerotimestamp: string;
+    webcam: string;
+    iphonevideo: string;
+    av1: string;
+    framer24fps: string;
+    music: string;
+    notavideo: string;
+    notafile: string;
+    transparentwithdar: string;
+    prores: string;
+    iphonehevc: string;
+    matroskaPcm16: string;
+    mp4withmp3: string;
+    av1bbb: string;
+    av1mp4: string;
+    av1mp4WithColr: string;
+    vp8Vorbis: string;
+    vp9: string;
+    stretchedVp8: string;
+    matroskaMp3: string;
+    matroskaH265Aac: string;
+    opusWebm: string;
+    avi: string;
+    opus51Webm: string;
+};

package/dist/example-videos.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exampleVideos = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const examplePackage = node_path_1.default.join(__dirname, '..', '..', 'example');
+const docsPackage = node_path_1.default.join(__dirname, '..', '..', 'docs');
+exports.exampleVideos = {
+    bigBuckBunny: node_path_1.default.join(examplePackage, 'public/bigbuckbunny.mp4'),
+    transparentWebm: node_path_1.default.join(docsPackage, '/static/img/transparent-video.webm'),
+    framerWithoutFileExtension: node_path_1.default.join(examplePackage, 'public', 'framermp4withoutfileextension'),
+    corrupted: node_path_1.default.join(examplePackage, 'public', 'corrupted.mp4'),
+    customDar: node_path_1.default.join(examplePackage, 'public', 'custom-dar.mp4'),
+    screenrecording: node_path_1.default.join(examplePackage, 'public', 'quick.mov'),
+    nofps: node_path_1.default.join(examplePackage, 'public', 'nofps.webm'),
+    variablefps: node_path_1.default.join(examplePackage, 'public', 'variablefps.webm'),
+    zerotimestamp: node_path_1.default.join(examplePackage, 'public', 'zero-timestamp.mp4'),
+    webcam: node_path_1.default.join(examplePackage, 'public', 'webcam.webm'),
+    iphonevideo: node_path_1.default.join(examplePackage, 'public', 'iphonevideo.mov'),
+    av1: node_path_1.default.join(examplePackage, 'public', 'av1.webm'),
+    framer24fps: node_path_1.default.join(examplePackage, 'src', 'resources', 'framer-24fps.mp4'),
+    music: node_path_1.default.join(examplePackage, 'public', 'music.mp3'),
+    notavideo: node_path_1.default.join(examplePackage, 'public', 'giphy.gif'),
+    notafile: node_path_1.default.join(examplePackage, 'public', 'doesnotexist'),
+    transparentwithdar: node_path_1.default.join(examplePackage, 'public', 'transparent-with-dar.webm'),
+    prores: node_path_1.default.join(examplePackage, 'public', 'prores.mov'),
+    iphonehevc: node_path_1.default.join(examplePackage, 'public', 'iphone-hevc.mov'),
+    matroskaPcm16: node_path_1.default.join(examplePackage, 'public', 'matroska-pcm16.mkv'),
+    mp4withmp3: node_path_1.default.join(examplePackage, 'public', 'mp4-mp3.mp4'),
+    av1bbb: node_path_1.default.join(examplePackage, 'public', 'av1-bbb.webm'),
+    av1mp4: node_path_1.default.join(examplePackage, 'public', 'av1-bbb.mp4'),
+    av1mp4WithColr: node_path_1.default.join(examplePackage, 'public', 'av1.mp4'),
+    vp8Vorbis: node_path_1.default.join(examplePackage, 'public', 'vp8-vorbis.webm'),
+    vp9: node_path_1.default.join(examplePackage, 'public', 'vp9.webm'),
+    stretchedVp8: node_path_1.default.join(examplePackage, 'public', 'stretched-vp8.webm'),
+    matroskaMp3: node_path_1.default.join(examplePackage, 'public', 'matroska-mp3.mkv'),
+    matroskaH265Aac: node_path_1.default.join(examplePackage, 'public', 'matroska-h265-aac.mkv'),
+    opusWebm: node_path_1.default.join(examplePackage, 'public', 'opus.webm'),
+    avi: node_path_1.default.join(examplePackage, 'public', 'example.avi'),
+    opus51Webm: node_path_1.default.join(examplePackage, 'public', 'vp8-opus-5-1-channels.webm'),
+};

package/dist/get-browser-instance.d.ts

@@ -5,7 +5,7 @@ import type { LogLevel } from './log-level';
 import type { ChromiumOptions } from './open-browser';
 import type { ChromeMode } from './options/chrome-mode';
 import type { OnBrowserDownload } from './options/on-browser-download';
-export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, }: {
+export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, pageIndex, }: {
     passedInInstance: HeadlessBrowser | undefined;
     browserExecutable: BrowserExecutable | null;
     chromiumOptions: ChromiumOptions;
@@ -14,6 +14,7 @@ export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable
     logLevel: LogLevel;
     onBrowserDownload: OnBrowserDownload;
     chromeMode: ChromeMode;
+    pageIndex: number;
 }) => Promise<{
     cleanupPage: () => Promise<void>;
     page: Page;

package/dist/get-browser-instance.js

@@ -4,9 +4,14 @@ exports.getPageAndCleanupFn = void 0;
 const browser_1 = require("./browser");
 const logger_1 = require("./logger");
 const open_browser_1 = require("./open-browser");
-const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, }) => {
+const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, pageIndex, }) => {
     if (passedInInstance) {
-        const page = await passedInInstance.newPage(() => null, logLevel, indent);
+        const page = await passedInInstance.newPage({
+            context: () => null,
+            logLevel,
+            indent,
+            pageIndex,
+        });
         return {
             page,
             cleanupPage: () => {
@@ -32,12 +37,17 @@ const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromi
         onBrowserDownload,
         chromeMode,
     });
-    const browserPage = await browserInstance.newPage(() => null, logLevel, indent);
+    const browserPage = await browserInstance.newPage({
+        context: () => null,
+        logLevel,
+        indent,
+        pageIndex,
+    });
     return {
         page: browserPage,
         cleanupPage: () => {
             // Close whole browser that was just created and don't wait for it to finish.
-            browserInstance.close(true, logLevel, indent).catch((err) => {
+            browserInstance.close({ silent: true }).catch((err) => {
                 if (!err.message.includes('Target closed')) {
                     logger_1.Log.error({ indent, logLevel }, 'Was not able to close puppeteer page', err);
                 }