@remotion/renderer 3.0.28 → 3.0.29

package/dist/browser/Browser.d.ts

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { Page } from './BrowserPage';
 import type { Connection } from './Connection';
 import { EventEmitter } from './EventEmitter';
-import type { Page } from './Page';
 import type { Viewport } from './PuppeteerViewport';
 import { Target } from './Target';
 declare type BrowserCloseCallback = () => Promise<void> | void;

package/dist/browser/BrowserPage.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Copyright 2017 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 { Browser } from './Browser';
+import type { CDPSession } from './Connection';
+import { ConsoleMessage } from './ConsoleMessage';
+import type { EvaluateFn, EvaluateFnReturnType, EvaluateHandleFn, SerializableOrJSHandle, UnwrapPromiseLike } from './EvalTypes';
+import { EventEmitter } from './EventEmitter';
+import type { Frame } from './FrameManager';
+import type { HTTPResponse } from './HTTPResponse';
+import type { JSHandle } from './JSHandle';
+import type { Viewport } from './PuppeteerViewport';
+import type { Target } from './Target';
+import { TaskQueue } from './TaskQueue';
+interface WaitForOptions {
+    timeout?: number;
+}
+interface PageEventObject {
+    console: ConsoleMessage;
+    error: Error;
+}
+export declare class Page extends EventEmitter {
+    #private;
+    static _create(client: CDPSession, target: Target, defaultViewport: Viewport, browser: Browser): Promise<Page>;
+    browser: Browser;
+    screenshotTaskQueue: TaskQueue;
+    constructor(client: CDPSession, target: Target, browser: Browser);
+    /**
+     * Listen to page events.
+     */
+    on<K extends keyof PageEventObject>(eventName: K, handler: (event: PageEventObject[K]) => void): EventEmitter;
+    once<K extends keyof PageEventObject>(eventName: K, handler: (event: PageEventObject[K]) => void): EventEmitter;
+    off<K extends keyof PageEventObject>(eventName: K, handler: (event: PageEventObject[K]) => void): EventEmitter;
+    /**
+     * @returns A target this page was created from.
+     */
+    target(): Target;
+    _client(): CDPSession;
+    /**
+     * @returns The page's main frame.
+     * @remarks
+     * Page is guaranteed to have a main frame which persists during navigations.
+     */
+    mainFrame(): Frame;
+    setViewport(viewport: Viewport): Promise<void>;
+    setDefaultNavigationTimeout(timeout: number): void;
+    setDefaultTimeout(timeout: number): void;
+    evaluateHandle<HandlerType extends JSHandle = JSHandle>(pageFunction: EvaluateHandleFn, ...args: SerializableOrJSHandle[]): Promise<HandlerType>;
+    url(): string;
+    goto(url: string, options?: WaitForOptions & {
+        referer?: string;
+    }): Promise<HTTPResponse | null>;
+    bringToFront(): Promise<void>;
+    evaluate<T extends EvaluateFn>(pageFunction: T, ...args: SerializableOrJSHandle[]): Promise<UnwrapPromiseLike<EvaluateFnReturnType<T>>>;
+    evaluateOnNewDocument(pageFunction: Function | string, ...args: unknown[]): Promise<void>;
+    close(options?: {
+        runBeforeUnload?: boolean;
+    }): Promise<void>;
+    isClosed(): boolean;
+    waitForFunction(browser: Browser, pageFunction: Function | string, ...args: SerializableOrJSHandle[]): Promise<JSHandle>;
+}
+export {};

package/dist/browser/BrowserPage.js

@@ -0,0 +1,283 @@
+"use strict";
+/**
+ * Copyright 2017 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 __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 __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 _Page_instances, _Page_closed, _Page_client, _Page_target, _Page_timeoutSettings, _Page_frameManager, _Page_pageBindings, _Page_initialize, _Page_onTargetCrashed, _Page_onLogEntryAdded, _Page_onConsoleAPI, _Page_onBindingCalled, _Page_addConsoleMessage;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+const assert_1 = require("./assert");
+const ConsoleMessage_1 = require("./ConsoleMessage");
+const EventEmitter_1 = require("./EventEmitter");
+const FrameManager_1 = require("./FrameManager");
+const JSHandle_1 = require("./JSHandle");
+const TaskQueue_1 = require("./TaskQueue");
+const TimeoutSettings_1 = require("./TimeoutSettings");
+const util_1 = require("./util");
+class Page extends EventEmitter_1.EventEmitter {
+    constructor(client, target, browser) {
+        super();
+        _Page_instances.add(this);
+        _Page_closed.set(this, false);
+        _Page_client.set(this, void 0);
+        _Page_target.set(this, void 0);
+        _Page_timeoutSettings.set(this, new TimeoutSettings_1.TimeoutSettings());
+        _Page_frameManager.set(this, void 0);
+        _Page_pageBindings.set(this, new Map());
+        __classPrivateFieldSet(this, _Page_client, client, "f");
+        __classPrivateFieldSet(this, _Page_target, target, "f");
+        __classPrivateFieldSet(this, _Page_frameManager, new FrameManager_1.FrameManager(client, this, __classPrivateFieldGet(this, _Page_timeoutSettings, "f")), "f");
+        this.screenshotTaskQueue = new TaskQueue_1.TaskQueue();
+        this.browser = browser;
+        client.on('Target.attachedToTarget', (event) => {
+            switch (event.targetInfo.type) {
+                case 'iframe':
+                    break;
+                case 'worker':
+                    break;
+                default:
+                    // If we don't detach from service workers, they will never die.
+                    // We still want to attach to workers for emitting events.
+                    // We still want to attach to iframes so sessions may interact with them.
+                    // We detach from all other types out of an abundance of caution.
+                    // See https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/devtools_agent_host_impl.cc?ss=chromium&q=f:devtools%20-f:out%20%22::kTypePage%5B%5D%22
+                    // for the complete list of available types.
+                    client
+                        .send('Target.detachFromTarget', {
+                        sessionId: event.sessionId,
+                    })
+                        .catch((err) => console.log(err));
+            }
+        });
+        client.on('Runtime.consoleAPICalled', (event) => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onConsoleAPI).call(this, event);
+        });
+        client.on('Runtime.bindingCalled', (event) => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onBindingCalled).call(this, event);
+        });
+        client.on('Inspector.targetCrashed', () => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onTargetCrashed).call(this);
+        });
+        client.on('Log.entryAdded', (event) => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onLogEntryAdded).call(this, event);
+        });
+    }
+    static async _create(client, target, defaultViewport, browser) {
+        const page = new Page(client, target, browser);
+        await __classPrivateFieldGet(page, _Page_instances, "m", _Page_initialize).call(page);
+        await page.setViewport(defaultViewport);
+        return page;
+    }
+    /**
+     * Listen to page events.
+     */
+    // Note: this method exists to define event typings and handle
+    // proper wireup of cooperative request interception. Actual event listening and
+    // dispatching is delegated to EventEmitter.
+    on(eventName, handler) {
+        return super.on(eventName, handler);
+    }
+    once(eventName, handler) {
+        // Note: this method only exists to define the types; we delegate the impl
+        // to EventEmitter.
+        return super.once(eventName, handler);
+    }
+    off(eventName, handler) {
+        return super.off(eventName, handler);
+    }
+    /**
+     * @returns A target this page was created from.
+     */
+    target() {
+        return __classPrivateFieldGet(this, _Page_target, "f");
+    }
+    _client() {
+        return __classPrivateFieldGet(this, _Page_client, "f");
+    }
+    /**
+     * @returns The page's main frame.
+     * @remarks
+     * Page is guaranteed to have a main frame which persists during navigations.
+     */
+    mainFrame() {
+        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame();
+    }
+    setViewport(viewport) {
+        return __classPrivateFieldGet(this, _Page_client, "f").send('Emulation.setDeviceMetricsOverride', {
+            mobile: false,
+            width: viewport.width,
+            height: viewport.height,
+            deviceScaleFactor: viewport.deviceScaleFactor,
+            screenOrientation: {
+                angle: 0,
+                type: 'portraitPrimary',
+            },
+        });
+    }
+    setDefaultNavigationTimeout(timeout) {
+        __classPrivateFieldGet(this, _Page_timeoutSettings, "f").setDefaultNavigationTimeout(timeout);
+    }
+    setDefaultTimeout(timeout) {
+        __classPrivateFieldGet(this, _Page_timeoutSettings, "f").setDefaultTimeout(timeout);
+    }
+    async evaluateHandle(pageFunction, ...args) {
+        const context = await this.mainFrame().executionContext();
+        return context.evaluateHandle(pageFunction, ...args);
+    }
+    url() {
+        return this.mainFrame().url();
+    }
+    goto(url, options = {}) {
+        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame().goto(url, options);
+    }
+    async bringToFront() {
+        await __classPrivateFieldGet(this, _Page_client, "f").send('Page.bringToFront');
+    }
+    evaluate(pageFunction, ...args) {
+        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame().evaluate(pageFunction, ...args);
+    }
+    async evaluateOnNewDocument(pageFunction, ...args) {
+        const source = (0, util_1.evaluationString)(pageFunction, ...args);
+        await __classPrivateFieldGet(this, _Page_client, "f").send('Page.addScriptToEvaluateOnNewDocument', {
+            source,
+        });
+    }
+    async close(options = { runBeforeUnload: undefined }) {
+        const connection = __classPrivateFieldGet(this, _Page_client, "f").connection();
+        (0, assert_1.assert)(connection, 'Protocol error: Connection closed. Most likely the page has been closed.');
+        const runBeforeUnload = Boolean(options.runBeforeUnload);
+        if (runBeforeUnload) {
+            await __classPrivateFieldGet(this, _Page_client, "f").send('Page.close');
+        }
+        else {
+            await connection.send('Target.closeTarget', {
+                targetId: __classPrivateFieldGet(this, _Page_target, "f")._targetId,
+            });
+            await __classPrivateFieldGet(this, _Page_target, "f")._isClosedPromise;
+        }
+    }
+    isClosed() {
+        return __classPrivateFieldGet(this, _Page_closed, "f");
+    }
+    waitForFunction(browser, pageFunction, ...args) {
+        return this.mainFrame().waitForFunction(browser, pageFunction, ...args);
+    }
+}
+exports.Page = Page;
+_Page_closed = new WeakMap(), _Page_client = new WeakMap(), _Page_target = new WeakMap(), _Page_timeoutSettings = new WeakMap(), _Page_frameManager = new WeakMap(), _Page_pageBindings = new WeakMap(), _Page_instances = new WeakSet(), _Page_initialize = async function _Page_initialize() {
+    await Promise.all([
+        __classPrivateFieldGet(this, _Page_frameManager, "f").initialize(),
+        __classPrivateFieldGet(this, _Page_client, "f").send('Target.setAutoAttach', {
+            autoAttach: true,
+            waitForDebuggerOnStart: false,
+            flatten: true,
+        }),
+        __classPrivateFieldGet(this, _Page_client, "f").send('Performance.enable'),
+        __classPrivateFieldGet(this, _Page_client, "f").send('Log.enable'),
+    ]);
+}, _Page_onTargetCrashed = function _Page_onTargetCrashed() {
+    this.emit('error', new Error('Page crashed!'));
+}, _Page_onLogEntryAdded = function _Page_onLogEntryAdded(event) {
+    const { level, text, args, source, url, lineNumber } = event.entry;
+    if (args) {
+        args.map((arg) => {
+            return (0, util_1.releaseObject)(__classPrivateFieldGet(this, _Page_client, "f"), arg);
+        });
+    }
+    if (source !== 'worker') {
+        this.emit("console" /* PageEmittedEvents.Console */, new ConsoleMessage_1.ConsoleMessage(level, text, [], [{ url, lineNumber }]));
+    }
+}, _Page_onConsoleAPI = function _Page_onConsoleAPI(event) {
+    if (event.executionContextId === 0) {
+        return;
+    }
+    const context = __classPrivateFieldGet(this, _Page_frameManager, "f").executionContextById(event.executionContextId, __classPrivateFieldGet(this, _Page_client, "f"));
+    const values = event.args.map((arg) => {
+        return (0, JSHandle_1._createJSHandle)(context, arg);
+    });
+    __classPrivateFieldGet(this, _Page_instances, "m", _Page_addConsoleMessage).call(this, event.type, values, event.stackTrace);
+}, _Page_onBindingCalled = async function _Page_onBindingCalled(event) {
+    let payload;
+    try {
+        payload = JSON.parse(event.payload);
+    }
+    catch (_a) {
+        // The binding was either called by something in the page or it was
+        // called before our wrapper was initialized.
+        return;
+    }
+    const { type, name, seq, args } = payload;
+    if (type !== 'exposedFun' || !__classPrivateFieldGet(this, _Page_pageBindings, "f").has(name)) {
+        return;
+    }
+    let expression = null;
+    try {
+        const pageBinding = __classPrivateFieldGet(this, _Page_pageBindings, "f").get(name);
+        (0, assert_1.assert)(pageBinding);
+        const result = await pageBinding(...args);
+        expression = (0, util_1.pageBindingDeliverResultString)(name, seq, result);
+    }
+    catch (_error) {
+        if ((0, util_1.isErrorLike)(_error)) {
+            expression = (0, util_1.pageBindingDeliverErrorString)(name, seq, _error.message, _error.stack);
+        }
+        else {
+            expression = (0, util_1.pageBindingDeliverErrorValueString)(name, seq, _error);
+        }
+    }
+    __classPrivateFieldGet(this, _Page_client, "f").send('Runtime.evaluate', {
+        expression,
+        contextId: event.executionContextId,
+    });
+}, _Page_addConsoleMessage = function _Page_addConsoleMessage(eventType, args, stackTrace) {
+    if (!this.listenerCount("console" /* PageEmittedEvents.Console */)) {
+        args.forEach((arg) => {
+            return arg.dispose();
+        });
+        return;
+    }
+    const textTokens = [];
+    for (const arg of args) {
+        const remoteObject = arg._remoteObject;
+        if (remoteObject.objectId) {
+            textTokens.push(arg.toString());
+        }
+        else {
+            textTokens.push((0, util_1.valueFromRemoteObject)(remoteObject));
+        }
+    }
+    const stackTraceLocations = [];
+    if (stackTrace) {
+        for (const callFrame of stackTrace.callFrames) {
+            stackTraceLocations.push({
+                url: callFrame.url,
+                lineNumber: callFrame.lineNumber,
+                columnNumber: callFrame.columnNumber,
+            });
+        }
+    }
+    const message = new ConsoleMessage_1.ConsoleMessage(eventType, textTokens.join(' '), args, stackTraceLocations);
+    this.emit("console" /* PageEmittedEvents.Console */, message);
+};

package/dist/browser/FrameManager.d.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import type { Browser } from './Browser';
+import type { Page } from './BrowserPage';
 import type { CDPSession } from './Connection';
 import type { Frame as TFrame } from './devtools-types';
 import { DOMWorld } from './DOMWorld';
@@ -24,7 +25,6 @@ import type { HTTPResponse } from './HTTPResponse';
 import type { JSHandle } from './JSHandle';
 import type { PuppeteerLifeCycleEvent } from './LifecycleWatcher';
 import { NetworkManager } from './NetworkManager';
-import type { Page } from './Page';
 import type { TimeoutSettings } from './TimeoutSettings';
 export declare const FrameManagerEmittedEvents: {
     FrameNavigated: symbol;

package/dist/browser/Target.d.ts

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 import type { Browser, BrowserContext } from './Browser';
+import { Page } from './BrowserPage';
 import type { CDPSession } from './Connection';
 import type { TargetInfo } from './devtools-types';
-import { Page } from './Page';
 import type { Viewport } from './PuppeteerViewport';
 export declare class Target {
     #private;

package/dist/browser/Target.js

@@ -28,7 +28,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _Target_browserContext, _Target_targetInfo, _Target_sessionFactory, _Target_defaultViewport, _Target_pagePromise;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Target = void 0;
-const Page_1 = require("./Page");
+const BrowserPage_1 = require("./BrowserPage");
 const isPagetTarget = (target) => {
     return (target.type === 'page' ||
         target.type === 'background_page' ||
@@ -84,7 +84,7 @@ class Target {
         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) => {
                 var _a;
-                return Page_1.Page._create(client, this, (_a = __classPrivateFieldGet(this, _Target_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null, this.browser());
+                return BrowserPage_1.Page._create(client, this, (_a = __classPrivateFieldGet(this, _Target_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null, this.browser());
             }), "f");
         }
         return (_a = (await __classPrivateFieldGet(this, _Target_pagePromise, "f"))) !== null && _a !== void 0 ? _a : null;

package/dist/error-handling/handle-javascript-exception.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from '../browser/Page';
+import type { Page } from '../browser/BrowserPage';
 import type { SymbolicatedStackFrame } from '../symbolicate-stacktrace';
 export declare class ErrorWithStackFrame extends Error {
     symbolicatedStackFrames: SymbolicatedStackFrame[] | null;

package/dist/extract-frame-from-video.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { FfmpegExecutable, OffthreadVideoImageFormat } from 'remotion';
 import type { LastFrameOptions } from './last-frame-from-video-cache';
 export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;

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

@@ -1,6 +1,6 @@
 import type { BrowserExecutable } from 'remotion';
 import type { Browser } from './browser/Browser';
-import type { Page } from './browser/Page';
+import type { Page } from './browser/BrowserPage';
 import type { ChromiumOptions } from './open-browser';
 export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, }: {
     passedInInstance: Browser | undefined;

package/dist/get-extension-from-codec.d.ts

@@ -1,2 +1,2 @@
 import type { Codec } from 'remotion';
-export declare const getFileExtensionFromCodec: (codec: Codec, type: 'chunk' | 'final') => "mp3" | "aac" | "wav" | "mp4" | "mkv" | "mov" | "webm";
+export declare const getFileExtensionFromCodec: (codec: Codec, type: 'chunk' | 'final') => "mp3" | "aac" | "wav" | "mp4" | "mov" | "webm" | "mkv";

package/dist/guess-extension-for-media.d.ts

@@ -0,0 +1 @@
+export declare const guessExtensionForVideo: (src: string) => Promise<"mp4" | "mp3" | "webm" | "wav">;

package/dist/guess-extension-for-media.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessExtensionForVideo = void 0;
+const execa_1 = __importDefault(require("execa"));
+const guessExtensionForVideo = async (src) => {
+    const { stderr } = await (0, execa_1.default)('ffprobe', [src]);
+    if (stderr.includes('h264')) {
+        return 'mp4';
+    }
+    if (stderr.includes('mp3,')) {
+        return 'mp3';
+    }
+    if (stderr.includes('Video: vp9')) {
+        return 'webm';
+    }
+    if (stderr.includes('Video: vp8')) {
+        return 'webm';
+    }
+    if (stderr.includes('wav, ')) {
+        return 'wav';
+    }
+    throw new Error(`A media file ${src} which has no file extension and whose format could not be guessed. Is this a valid media file?`);
+};
+exports.guessExtensionForVideo = guessExtensionForVideo;

package/dist/index.d.ts

@@ -55,7 +55,7 @@ export declare const RenderInternals: {
         task: Promise<Buffer | null>;
         getLogs: () => string;
     }>;
-    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "mp4" | "mkv" | "mov" | "webm";
+    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "mp4" | "mov" | "webm" | "mkv";
     tmpDir: (str: string) => string;
     deleteDirectory: (directory: string) => Promise<void>;
     isServeUrl: (potentialUrl: string) => boolean;

package/dist/last-frame-from-video-cache.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { FfmpegExecutable, OffthreadVideoImageFormat } from 'remotion';
 import type { SpecialVCodecForTransparency } from './get-video-info';
 export declare type LastFrameOptions = {

package/dist/provide-screenshot.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="node" />
 import type { ImageFormat } from 'remotion';
-import type { Page } from './browser/Page';
+import type { Page } from './browser/BrowserPage';
 export declare const provideScreenshot: ({ page, imageFormat, options, quality, }: {
     page: Page;
     imageFormat: ImageFormat;

package/dist/puppeteer-evaluate.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from './browser/Page';
+import type { Page } from './browser/BrowserPage';
 export declare function puppeteerEvaluateWithCatch<ReturnType>({ page, pageFunction, frame, args, }: {
     page: Page;
     pageFunction: Function | string;

package/dist/puppeteer-screenshot.d.ts

@@ -1,3 +1,4 @@
-import type { Page } from './browser/Page';
+/// <reference types="node" />
+import type { Page } from './browser/BrowserPage';
 import type { ScreenshotOptions } from './browser/ScreenshotOptions';
 export declare const screenshot: (page: Page, options: ScreenshotOptions) => Promise<Buffer | string | void>;

package/dist/render-media.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { BrowserExecutable, Codec, FfmpegExecutable, FrameRange, PixelFormat, ProResProfile, SmallTCompMetadata } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { BrowserLog } from './browser-log';

package/dist/screenshot-dom-element.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="node" />
 import type { ImageFormat } from 'remotion';
-import type { Page } from './browser/Page';
+import type { Page } from './browser/BrowserPage';
 export declare const screenshotDOMElement: ({ page, imageFormat, quality, opts, }: {
     page: Page;
     imageFormat: ImageFormat;

package/dist/screenshot-task.d.ts

@@ -1,4 +1,5 @@
+/// <reference types="node" />
 import type { StillImageFormat } from 'remotion';
-import type { Page } from './browser/Page';
+import type { Page } from './browser/BrowserPage';
 import type { ScreenshotOptions } from './browser/ScreenshotOptions';
 export declare const _screenshotTask: (page: Page, format: StillImageFormat, options: ScreenshotOptions) => Promise<Buffer | string>;

package/dist/seek-to-frame.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from './browser/Page';
+import type { Page } from './browser/BrowserPage';
 export declare const seekToFrame: ({ frame, page, }: {
     frame: number;
     page: Page;

package/dist/set-props-and-env.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from './browser/Page';
+import type { Page } from './browser/BrowserPage';
 export declare const setPropsAndEnv: ({ inputProps, envVariables, page, serveUrl, initialFrame, timeoutInMilliseconds, proxyPort, retriesRemaining, }: {
     inputProps: unknown;
     envVariables: Record<string, string> | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/renderer",
-	"version": "3.0.28",
+	"version": "3.0.29",
 	"description": "Renderer for Remotion",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
 	"dependencies": {
 		"execa": "5.1.1",
 		"extract-zip": "2.0.1",
-		"remotion": "3.0.28",
+		"remotion": "3.0.29",
 		"source-map": "^0.8.0-beta.0",
 		"ws": "8.7.0"
 	},
@@ -59,5 +59,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "2692339a361f379daab34e12b34562bdcf277d05"
+	"gitHead": "da2e8a33766bf01b21dfd3c2d0c944356d156722"
 }