pupeteer-capture 0.0.1-security → 1.1.1

package/lib/PuppeteerCaptureFormat.js

@@ -0,0 +1,21 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MP4 = void 0;
+function MP4(preset = 'ultrafast', videoCodec = 'libx264') {
+    return (ffmpeg) => __awaiter(this, void 0, void 0, function* () {
+        ffmpeg
+            .outputFormat('mp4').withVideoCodec(videoCodec)
+            .outputOption(`-preset ${preset}`)
+            .outputOption('-movflags +frag_keyframe+separate_moof+omit_tfhd_offset+empty_moov');
+    });
+}
+exports.MP4 = MP4;

package/lib/PuppeteerCaptureOptions.d.ts

@@ -0,0 +1,8 @@
+import { FfmpegCommand } from 'fluent-ffmpeg';
+export interface PuppeteerCaptureOptions {
+    fps?: number;
+    size?: string;
+    format?: (ffmpeg: FfmpegCommand) => Promise<void>;
+    ffmpeg?: string;
+    customFfmpegConfig?: (ffmpeg: FfmpegCommand) => Promise<void>;
+}

package/lib/PuppeteerCaptureOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/PuppeteerCaptureStartOptions.d.ts

@@ -0,0 +1,4 @@
+export interface PuppeteerCaptureStartOptions {
+    waitForFirstFrame?: boolean;
+    dropCapturedFrames?: boolean;
+}

package/lib/PuppeteerCaptureStartOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/PuppeteerCaptureViaHeadlessExperimental.d.ts

@@ -0,0 +1,27 @@
+import type { Browser as PuppeteerBrowser, CDPSession as PuppeteerCDPSession, Page as PuppeteerPage } from 'puppeteer';
+import { Protocol } from 'devtools-protocol';
+import { PuppeteerCaptureBase } from './PuppeteerCaptureBase';
+import { PuppeteerCaptureOptions } from './PuppeteerCaptureOptions';
+export declare class PuppeteerCaptureViaHeadlessExperimental extends PuppeteerCaptureBase {
+    static readonly REQUIRED_ARGS: string[];
+    protected static readonly INJECTED = "__PuppeteerCaptureViaHeadlessExperimental";
+    protected static readonly EJECTOR: string;
+    protected readonly _injected: string;
+    protected readonly _injector: string;
+    protected readonly _ejector: string;
+    protected readonly _requestFrameCapture: () => void;
+    protected readonly _onSessionDisconnected: () => void;
+    protected _session: PuppeteerCDPSession | null;
+    protected _onNewDocumentScript: Protocol.Page.ScriptIdentifier | null;
+    constructor(options?: PuppeteerCaptureOptions);
+    protected getPageClient(page: PuppeteerPage): PuppeteerCDPSession;
+    protected _attach(page: PuppeteerPage): Promise<void>;
+    protected _detach(page: PuppeteerPage): Promise<void>;
+    protected requestFrameCapture(): void;
+    protected doRequestFrameCapture(page: PuppeteerPage, session: PuppeteerCDPSession): void;
+    protected onPostCaptureStarted(): Promise<void>;
+    protected onPostCaptureStopped(): Promise<void>;
+    protected onSessionDisconnected(): void;
+    protected static validateBrowserArgs(browser: PuppeteerBrowser): void;
+    protected static generateInjector(fps: number): string;
+}

package/lib/PuppeteerCaptureViaHeadlessExperimental.js

@@ -0,0 +1,440 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerCaptureViaHeadlessExperimental = void 0;
+const MissingHeadlessExperimentalRequiredArgs_1 = require("./MissingHeadlessExperimentalRequiredArgs");
+const PuppeteerCaptureBase_1 = require("./PuppeteerCaptureBase");
+class PuppeteerCaptureViaHeadlessExperimental extends PuppeteerCaptureBase_1.PuppeteerCaptureBase {
+    constructor(options) {
+        super(options);
+        this._injected = PuppeteerCaptureViaHeadlessExperimental.INJECTED;
+        this._injector = PuppeteerCaptureViaHeadlessExperimental.generateInjector(this._options.fps); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+        this._ejector = PuppeteerCaptureViaHeadlessExperimental.EJECTOR;
+        this._requestFrameCapture = this.requestFrameCapture.bind(this);
+        this._onSessionDisconnected = this.onSessionDisconnected.bind(this);
+        this._session = null;
+        this._onNewDocumentScript = null;
+        if (process.platform === 'darwin') {
+            throw new Error('MacOS is not supported by HeadlessExperimental.BeginFrame');
+        }
+    }
+    getPageClient(page) {
+        // Before puppeteer 14.4.0, the internal method was client()
+        if ('client' in page) {
+            // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+            // @ts-ignore
+            return page.client();
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+        // @ts-ignore
+        return page._client();
+    }
+    _attach(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            PuppeteerCaptureViaHeadlessExperimental.validateBrowserArgs(page.browser());
+            const session = yield page.target().createCDPSession();
+            // NOTE: For some reason, page.client() has to be used instead of newly created session
+            const onNewDocumentScript = (yield this.getPageClient(page).send('Page.addScriptToEvaluateOnNewDocument', {
+                source: this._injector
+            })).identifier;
+            session.on('CDPSession.Disconnected', this._onSessionDisconnected);
+            this._session = session;
+            this._onNewDocumentScript = onNewDocumentScript;
+        });
+    }
+    _detach(page) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._onNewDocumentScript != null) {
+                // NOTE: For details, see send('Page.addScriptToEvaluateOnNewDocument') code
+                yield this.getPageClient(page).send('Page.removeScriptToEvaluateOnNewDocument', {
+                    identifier: this._onNewDocumentScript
+                });
+                this._onNewDocumentScript = null;
+            }
+            if (((_a = this._session) === null || _a === void 0 ? void 0 : _a.connection()) != null) {
+                this._session.off('CDPSession.Disconnected', this._onSessionDisconnected);
+                yield this._session.detach();
+                this._session = null;
+            }
+        });
+    }
+    requestFrameCapture() {
+        if (!this._isCapturing || this._error != null) {
+            return;
+        }
+        if (this._page == null) {
+            throw new Error('Not attached to a page');
+        }
+        if (this._session == null) {
+            throw new Error('No session available');
+        }
+        if (this._session.connection() == null) {
+            throw new Error('Session disconnected');
+        }
+        this.doRequestFrameCapture(this._page, this._session);
+    }
+    doRequestFrameCapture(page, session) {
+        const captureTimestamp = this._captureTimestamp;
+        const frameInterval = this._frameInterval;
+        this._frameBeingCaptured = Promise.all(page.frames().map((frame) => __awaiter(this, void 0, void 0, function* () {
+            yield frame.evaluate(`${this._injected}.process(${captureTimestamp})`);
+        }))).then(() => __awaiter(this, void 0, void 0, function* () {
+            return yield session.send('HeadlessExperimental.beginFrame', {
+                frameTimeTicks: captureTimestamp,
+                interval: frameInterval,
+                noDisplayUpdates: false,
+                screenshot: { format: 'png' }
+            });
+        })).then(({ screenshotData: dataBase64 }) => __awaiter(this, void 0, void 0, function* () {
+            this._frameBeingCaptured = null;
+            if (!this._isCapturing) {
+                return;
+            }
+            if (dataBase64 == null) {
+                setTimeout(this._requestFrameCapture, 0);
+                return;
+            }
+            const data = Buffer.from(dataBase64, 'base64');
+            yield this.onFrameCaptured(captureTimestamp, data);
+            if (this._isCapturing) {
+                this._captureTimestamp = captureTimestamp + frameInterval;
+                setTimeout(this._requestFrameCapture, 0);
+            }
+        }), (reason) => __awaiter(this, void 0, void 0, function* () {
+            this._frameBeingCaptured = null;
+            if (!this._isCapturing) {
+                return;
+            }
+            yield this.onFrameCaptureFailed(reason);
+        }));
+    }
+    onPostCaptureStarted() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const page = this._page;
+            const session = this._session;
+            if (page == null || ((_a = this.getPageClient(page)) === null || _a === void 0 ? void 0 : _a.connection()) == null || (session === null || session === void 0 ? void 0 : session.connection()) == null) {
+                return;
+            }
+            for (const frame of page.frames()) {
+                yield frame.evaluate(this._injector);
+                yield frame.evaluate(`${this._injected}.activate()`);
+            }
+            yield session.send('HeadlessExperimental.enable');
+            this.doRequestFrameCapture(page, session);
+        });
+    }
+    onPostCaptureStopped() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const page = this._page;
+            const session = this._session;
+            if (page == null || ((_a = this.getPageClient(page)) === null || _a === void 0 ? void 0 : _a.connection()) == null || (session === null || session === void 0 ? void 0 : session.connection()) == null) {
+                return;
+            }
+            for (const frame of page.frames()) {
+                yield frame.evaluate(`${this._injected}.deactivate()`);
+                yield frame.evaluate(this._ejector);
+            }
+            yield session.send('HeadlessExperimental.disable');
+        });
+    }
+    onSessionDisconnected() {
+        this._error = new Error('Session was disconnected');
+        this._startStopMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () {
+            if (this._isCapturing) {
+                yield this._stop();
+            }
+            yield this.detach();
+        }))
+            .then(() => { })
+            .catch(() => { });
+    }
+    static validateBrowserArgs(browser) {
+        var _a;
+        const spawnargs = (_a = browser.process()) === null || _a === void 0 ? void 0 : _a.spawnargs;
+        if (spawnargs == null || !PuppeteerCaptureViaHeadlessExperimental.REQUIRED_ARGS.every(arg => spawnargs.includes(arg))) {
+            throw new MissingHeadlessExperimentalRequiredArgs_1.MissingHeadlessExperimentalRequiredArgs();
+        }
+    }
+    static generateInjector(fps) {
+        return (`
+      if (typeof ${PuppeteerCaptureViaHeadlessExperimental.INJECTED} === 'undefined') {
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED} = {
+          active: false,
+          scheduledSimulatedProcessing: null,
+          previousSimulatedProcessingTimestamp: null,
+          simulatedProcessFPS: ${fps},
+          original: {},
+          dateOrigin: new Date(),
+          performanceNowOrigin: performance.now(),
+          timestampOffsetFromOrigin: 0,
+          animationFrameRequests: [],
+          intervalTimers: [],
+          timeoutTimers: [],
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.activate = function () {
+          if (${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.active) {
+            return;
+          }
+
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.dateOrigin = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.newDate();
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.performanceNowOrigin = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.previousSimulatedProcessingTimestamp;
+          if (${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.performanceNowOrigin === null) {
+            ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.performanceNowOrigin = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.performanceNow();
+          }
+
+          if (${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.scheduledSimulatedProcessing) {
+            ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_clearTimeout(${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.scheduledSimulatedProcessing);
+            ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.scheduledSimulatedProcessing = null;
+          }
+
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.active = true;
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.deactivate = function () {
+          if (!${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.active) {
+            return;
+          }
+
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.dateOrigin = null;
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.performanceNowOrigin = null;
+
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.previousSimulatedProcessingTimestamp = -${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timestampOffsetFromOrigin;
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.scheduledSimulatedProcessing = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_setTimeout(
+            ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.simulatedProcess,
+            1000 / ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.simulatedProcessFPS,
+          );
+
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.active = false;
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.getTimestamp = function () {
+          return ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.performanceNowOrigin + ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timestampOffsetFromOrigin;
+        }
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.Date = Date;
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.newDate = function () {
+          return new ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.Date();
+        }
+        Date = function () {
+          var OriginalDate = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.Date;
+          // NOTE: ECMA-262 says that using apply() is not possible: The function call Date(…) is not equivalent to the object creation expression new Date(…) with the same arguments.
+          switch (arguments.length) {
+            case 0:
+              return new OriginalDate(
+                ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.dateOrigin.getTime() + ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timestampOffsetFromOrigin
+              );
+            case 1:
+              return new OriginalDate(
+                arguments[0],
+              );
+            case 2:
+              return new OriginalDate(
+                arguments[0],
+                arguments[1],
+              );
+            case 3:
+              return new OriginalDate(
+                arguments[0],
+                arguments[1],
+                arguments[2],
+              );
+            case 4:
+              return new OriginalDate(
+                arguments[0],
+                arguments[1],
+                arguments[2],
+                arguments[3],
+              );
+            case 5:
+              return new OriginalDate(
+                arguments[0],
+                arguments[1],
+                arguments[2],
+                arguments[3],
+                arguments[4],
+              );
+            case 6:
+              return new OriginalDate(
+                arguments[0],
+                arguments[1],
+                arguments[2],
+                arguments[3],
+                arguments[4],
+                arguments[5],
+              );
+            case 7:
+              return new OriginalDate(
+                arguments[0],
+                arguments[1],
+                arguments[2],
+                arguments[3],
+                arguments[4],
+                arguments[5],
+                arguments[6],
+              );
+          };
+        };
+        Date.now = function () {
+          return ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.dateOrigin.getTime() + ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timestampOffsetFromOrigin;
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.performance_now = performance.now;
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.performanceNow = performance.now.bind(performance);
+        performance.now = function () {
+          return ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.performanceNowOrigin + ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timestampOffsetFromOrigin;
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_setInterval = window.setInterval;
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_setInterval = window.setInterval.bind(window);
+        window.setInterval = function (callback, interval, ...parameters) {
+          return ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.intervalTimers.push({
+            interval,
+            executionTimestamp: ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.getTimestamp(),
+            callback,
+            parameters,
+          });
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_clearInterval = window.clearInterval;
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_clearInterval = window.clearInterval.bind(window);
+        window.clearInterval = function (timer) {
+          delete ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.intervalTimers[timer - 1];
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_setTimeout = window.setTimeout;
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_setTimeout = window.setTimeout.bind(window);
+        window.setTimeout = function (callback, timeout, ...parameters) {
+          return ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timeoutTimers.push({
+            timeout,
+            enqueuedTimestamp: ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.getTimestamp(),
+            callback,
+            parameters,
+          });
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_clearTimeout = window.clearTimeout;
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_clearTimeout = window.clearTimeout.bind(window);
+        window.clearTimeout = function (timer) {
+          delete ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timeoutTimers[timer - 1];
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_requestAnimationFrame = window.requestAnimationFrame;
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_requestAnimationFrame = window.requestAnimationFrame.bind(window);
+        window.requestAnimationFrame = function (callback) {
+          return ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.animationFrameRequests.push({
+            callback,
+          });
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_cancelAnimationFrame = window.cancelAnimationFrame;
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_cancelAnimationFrame = window.cancelAnimationFrame.bind(window);
+        window.cancelAnimationFrame = function (request) {
+          delete ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.animationFrameRequests[request - 1];
+        };
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.process = function (timestampOffsetFromOrigin) {
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timestampOffsetFromOrigin = timestampOffsetFromOrigin;
+          var timestamp = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.getTimestamp();
+
+          var intervalTimers = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.intervalTimers.slice();
+          var timeoutTimers = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timeoutTimers.slice();
+          var animationFrameRequests = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.animationFrameRequests.slice();
+
+          intervalTimers.forEach(function (intervalTimer) {
+            while (intervalTimer.executionTimestamp + intervalTimer.interval <= timestamp) {
+              if (intervalTimer.callback) {
+                intervalTimer.callback.apply(undefined, intervalTimer.parameters);
+              }
+              intervalTimer.executionTimestamp += intervalTimer.interval;
+            }
+          });
+
+          timeoutTimers.forEach(function (timeoutTimer, timeoutTimerIndex) {
+            if (timeoutTimer.enqueuedTimestamp + timeoutTimer.timeout <= timestamp) {
+              if (timeoutTimer.callback) {
+                timeoutTimer.callback.apply(undefined, timeoutTimer.parameters);
+              }
+              delete ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timeoutTimers[timeoutTimerIndex];
+            }
+          });
+
+          animationFrameRequests.forEach(function (animationFrameRequest, animationFrameRequestIndex) {
+            if (animationFrameRequest.callback) {
+              animationFrameRequest.callback.apply(undefined, [timestamp]);
+            }
+            delete ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.animationFrameRequests[animationFrameRequestIndex];
+          });
+        }
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.simulatedProcess = function () {
+          if (${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.active) {
+            return;
+          }
+
+          var timestamp = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.performanceNow();
+
+          if (${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.previousSimulatedProcessingTimestamp === null) {
+            ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.previousSimulatedProcessingTimestamp = timestamp;
+          } else if (${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.previousSimulatedProcessingTimestamp < 0) {
+            ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.previousSimulatedProcessingTimestamp += timestamp;
+          }
+
+          var timestampDelta = timestamp - ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.previousSimulatedProcessingTimestamp;
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.process(
+            ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.timestampOffsetFromOrigin + timestampDelta
+          );
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.previousSimulatedProcessingTimestamp = timestamp;
+
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.scheduledSimulatedProcessing = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_setTimeout(
+            ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.simulatedProcess,
+            1000 / ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.simulatedProcessFPS,
+          );
+        }
+
+        ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.scheduledSimulatedProcessing = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.window_setTimeout(
+          ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.simulatedProcess,
+          1000 / ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.simulatedProcessFPS,
+        );
+      }
+      `);
+    }
+}
+exports.PuppeteerCaptureViaHeadlessExperimental = PuppeteerCaptureViaHeadlessExperimental;
+PuppeteerCaptureViaHeadlessExperimental.REQUIRED_ARGS = [
+    '--deterministic-mode',
+    '--enable-begin-frame-control',
+    '--disable-new-content-rendering-timeout',
+    '--run-all-compositor-stages-before-draw',
+    '--disable-threaded-animation',
+    '--disable-threaded-scrolling',
+    '--disable-checker-imaging',
+    '--disable-image-animation-resync',
+    '--enable-surface-synchronization'
+];
+PuppeteerCaptureViaHeadlessExperimental.INJECTED = '__PuppeteerCaptureViaHeadlessExperimental';
+PuppeteerCaptureViaHeadlessExperimental.EJECTOR = `
+    if (typeof ${PuppeteerCaptureViaHeadlessExperimental.INJECTED} !== 'undefined') {
+      Date = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.Date;
+      performance.now = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.performance_now;
+      window.setInterval = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_setInterval;
+      window.clearInterval = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_clearInterval;
+      window.setTimeout = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_setTimeout;
+      window.clearTimeout = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_clearTimeout;
+      window.requestAnimationFrame = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_requestAnimationFrame;
+      window.cancelAnimationFrame = ${PuppeteerCaptureViaHeadlessExperimental.INJECTED}.original.window_cancelAnimationFrame;
+
+      delete ${PuppeteerCaptureViaHeadlessExperimental.INJECTED};
+    }
+    `;

package/lib/capture.d.ts

@@ -0,0 +1,6 @@
+import type { Page as PuppeteerPage } from 'puppeteer';
+import { PuppeteerCapture } from './PuppeteerCapture';
+import { PuppeteerCaptureOptions } from './PuppeteerCaptureOptions';
+export declare function capture(page: PuppeteerPage, options?: PuppeteerCaptureOptions & {
+    attach?: boolean;
+}): Promise<PuppeteerCapture>;

package/lib/capture.js

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capture = void 0;
+const PuppeteerCaptureViaHeadlessExperimental_1 = require("./PuppeteerCaptureViaHeadlessExperimental");
+function capture(page, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const puppeteerCapture = new PuppeteerCaptureViaHeadlessExperimental_1.PuppeteerCaptureViaHeadlessExperimental(options);
+        if ((options === null || options === void 0 ? void 0 : options.attach) !== false) {
+            yield puppeteerCapture.attach(page);
+        }
+        return puppeteerCapture;
+    });
+}
+exports.capture = capture;

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export { capture } from './capture';
+export { launch } from './launch';
+export { MissingHeadlessExperimentalRequiredArgs as MissingRequiredArgs } from './MissingHeadlessExperimentalRequiredArgs';
+export { PuppeteerCapture } from './PuppeteerCapture';
+export { PuppeteerCaptureBase } from './PuppeteerCaptureBase';
+export { PuppeteerCaptureEvents } from './PuppeteerCaptureEvents';
+export * as PuppeteerCaptureFormat from './PuppeteerCaptureFormat';
+export { PuppeteerCaptureOptions } from './PuppeteerCaptureOptions';
+export { PuppeteerCaptureViaHeadlessExperimental } from './PuppeteerCaptureViaHeadlessExperimental';

package/lib/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerCaptureViaHeadlessExperimental = exports.PuppeteerCaptureFormat = exports.PuppeteerCaptureBase = exports.MissingRequiredArgs = exports.launch = exports.capture = void 0;
+var capture_1 = require("./capture");
+Object.defineProperty(exports, "capture", { enumerable: true, get: function () { return capture_1.capture; } });
+var launch_1 = require("./launch");
+Object.defineProperty(exports, "launch", { enumerable: true, get: function () { return launch_1.launch; } });
+var MissingHeadlessExperimentalRequiredArgs_1 = require("./MissingHeadlessExperimentalRequiredArgs");
+Object.defineProperty(exports, "MissingRequiredArgs", { enumerable: true, get: function () { return MissingHeadlessExperimentalRequiredArgs_1.MissingHeadlessExperimentalRequiredArgs; } });
+var PuppeteerCaptureBase_1 = require("./PuppeteerCaptureBase");
+Object.defineProperty(exports, "PuppeteerCaptureBase", { enumerable: true, get: function () { return PuppeteerCaptureBase_1.PuppeteerCaptureBase; } });
+exports.PuppeteerCaptureFormat = __importStar(require("./PuppeteerCaptureFormat"));
+var PuppeteerCaptureViaHeadlessExperimental_1 = require("./PuppeteerCaptureViaHeadlessExperimental");
+Object.defineProperty(exports, "PuppeteerCaptureViaHeadlessExperimental", { enumerable: true, get: function () { return PuppeteerCaptureViaHeadlessExperimental_1.PuppeteerCaptureViaHeadlessExperimental; } });

package/lib/launch.d.ts

@@ -0,0 +1,5 @@
+import type { Browser as PuppeteerBrowser, BrowserConnectOptions as PuppeteerBrowserConnectOptions, BrowserLaunchArgumentOptions as PuppeteerBrowserLaunchArgumentOptions, LaunchOptions as PuppeteerLaunchOptions, Product as PuppeteerProduct } from 'puppeteer';
+export declare function launch(options?: PuppeteerLaunchOptions & PuppeteerBrowserLaunchArgumentOptions & PuppeteerBrowserConnectOptions & {
+    product?: PuppeteerProduct;
+    extraPrefsFirefox?: Record<string, unknown>;
+}): Promise<PuppeteerBrowser>;

package/lib/launch.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launch = void 0;
+const PuppeteerCaptureViaHeadlessExperimental_1 = require("./PuppeteerCaptureViaHeadlessExperimental");
+/* eslint-disable-next-line @typescript-eslint/no-var-requires */
+const puppeteer = require(`puppeteer${(_a = process.env.PUPPETEER_CAPTURE__PUPPETEER_VERSION) !== null && _a !== void 0 ? _a : ''}`);
+function launch(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        options = Object.assign(Object.assign({}, (options != null ? options : {})), { args: [
+                ...((options === null || options === void 0 ? void 0 : options.args) != null ? options === null || options === void 0 ? void 0 : options.args : []),
+                ...PuppeteerCaptureViaHeadlessExperimental_1.PuppeteerCaptureViaHeadlessExperimental.REQUIRED_ARGS
+            ] });
+        return yield puppeteer.launch(options);
+    });
+}
+exports.launch = launch;