@remotion/renderer 4.0.16 → 4.0.18

package/dist/assets/get-video-stream-duration.d.ts

@@ -0,0 +1,9 @@
+import type { FfmpegExecutable } from '../ffmpeg-executable';
+import type { DownloadMap, VideoDurationResult } from './download-map';
+export declare const parseVideoStreamDuration: (stdout: string) => VideoDurationResult;
+export declare function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<VideoDurationResult>;
+export declare const getVideoStreamDuration: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<VideoDurationResult>;

package/dist/assets/get-video-stream-duration.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoStreamDuration = exports.getVideoStreamDurationwithoutCache = exports.parseVideoStreamDuration = void 0;
+const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("../ffmpeg-flags");
+const p_limit_1 = require("../p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+const parseAlternativeDuration = (stdout) => {
+    const webmDuration = stdout.match(/TAG:DURATION=([0-9.]+):([0-9.]+):([0-9.]+)/);
+    if (!webmDuration) {
+        return null;
+    }
+    const [, hours, minutes, seconds] = webmDuration;
+    const hoursAsNumber = Number(hours);
+    if (Number.isNaN(hoursAsNumber)) {
+        return null;
+    }
+    const minutesAsNumber = Number(minutes);
+    if (Number.isNaN(minutesAsNumber)) {
+        return null;
+    }
+    const secondsAsNumber = Number(seconds);
+    if (Number.isNaN(secondsAsNumber)) {
+        return null;
+    }
+    return secondsAsNumber + minutesAsNumber * 60 + hoursAsNumber * 3600;
+};
+const parseVideoStreamDuration = (stdout) => {
+    const duration = stdout.match(/duration=([0-9.]+)/);
+    const alternativeDuration = parseAlternativeDuration(stdout);
+    const fps = stdout.match(/r_frame_rate=([0-9.]+)\/([0-9.]+)/);
+    const result = {
+        duration: duration ? parseFloat(duration[1]) : alternativeDuration,
+        fps: fps ? parseInt(fps[1], 10) / parseInt(fps[2], 10) : null,
+    };
+    return result;
+};
+exports.parseVideoStreamDuration = parseVideoStreamDuration;
+async function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }) {
+    const args = [
+        ['-v', 'error'],
+        ['-select_streams', 'v:0'],
+        ['-show_entries', 'stream'],
+        [src],
+    ]
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter(Boolean);
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), args);
+    const result = (0, exports.parseVideoStreamDuration)(task.stdout);
+    return result;
+}
+exports.getVideoStreamDurationwithoutCache = getVideoStreamDurationwithoutCache;
+async function getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (downloadMap.videoDurationResultCache[src]) {
+        return downloadMap.videoDurationResultCache[src];
+    }
+    const result = await getVideoStreamDurationwithoutCache({
+        src,
+        ffprobeExecutable,
+        remotionRoot,
+    });
+    downloadMap.videoDurationResultCache[src] = result;
+    return result;
+}
+const getVideoStreamDuration = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
+};
+exports.getVideoStreamDuration = getVideoStreamDuration;

package/dist/browser/BrowserFetcher.d.ts

@@ -13,29 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Product } from './Product';
-type Platform = 'linux' | 'mac' | 'mac_arm' | 'win32' | 'win64';
 interface BrowserFetcherRevisionInfo {
     folderPath: string;
     executablePath: string;
     url: string;
     local: boolean;
-    revision: string;
-    product: string;
 }
-export declare const getPlatform: (product: Product) => Platform;
-export declare const getDownloadsFolder: (product: Product) => string;
-export declare const getDownloadHost: (product: Product) => "https://storage.googleapis.com" | "https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central";
-export declare const download: ({ revision, progressCallback, product, platform, downloadHost, downloadsFolder, }: {
-    revision: string;
-    progressCallback: (x: number, y: number) => void;
-    product: Product;
-    platform: Platform;
-    downloadHost: string;
-    downloadsFolder: string;
-}) => Promise<BrowserFetcherRevisionInfo | undefined>;
-export declare const localRevisions: (downloadsFolder: string, product: Product, platform: Platform) => Promise<string[]>;
-export declare const removeBrowser: (revision: string, folderPath: string) => Promise<void>;
-export declare const getFolderPath: (revision: string, downloadsFolder: string, platform: Platform) => string;
-export declare const getRevisionInfo: (revision: string, product: Product) => BrowserFetcherRevisionInfo;
+export declare const downloadBrowser: () => Promise<BrowserFetcherRevisionInfo | undefined>;
+export declare const getRevisionInfo: () => BrowserFetcherRevisionInfo;
 export {};

package/dist/browser/BrowserFetcher.js

@@ -41,95 +41,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRevisionInfo = exports.getFolderPath = exports.removeBrowser = exports.localRevisions = exports.download = exports.getDownloadHost = exports.getDownloadsFolder = exports.getPlatform = void 0;
-const https = __importStar(require("https"));
+exports.getRevisionInfo = exports.downloadBrowser = void 0;
 const childProcess = __importStar(require("node:child_process"));
 const fs = __importStar(require("node:fs"));
-const http = __importStar(require("node:http"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
-const node_util_1 = __importDefault(require("node:util"));
 const extract_zip_1 = __importDefault(require("extract-zip"));
-const URL = __importStar(require("node:url"));
-const node_util_2 = require("node:util");
+const node_util_1 = require("node:util");
 const assert_1 = require("./assert");
-const delete_directory_1 = require("../delete-directory");
+const download_file_1 = require("../assets/download-file");
+const logger_1 = require("../logger");
 const get_download_destination_1 = require("./get-download-destination");
-const { PUPPETEER_EXPERIMENTAL_CHROMIUM_MAC_ARM } = process.env;
 const downloadURLs = {
-    chrome: {
-        linux: '%s/chromium-browser-snapshots/Linux_x64/%d/%s.zip',
-        mac: '%s/chromium-browser-snapshots/Mac/%d/%s.zip',
-        mac_arm: '%s/chromium-browser-snapshots/Mac_Arm/%d/%s.zip',
-        win32: '%s/chromium-browser-snapshots/Win/%d/%s.zip',
-        win64: '%s/chromium-browser-snapshots/Win_x64/%d/%s.zip',
-    },
-    firefox: {
-        linux: '%s/firefox-%s.en-US.%s-x86_64.tar.bz2',
-        mac: '%s/firefox-%s.en-US.%s.dmg',
-        win32: '%s/firefox-%s.en-US.%s.zip',
-        win64: '%s/firefox-%s.en-US.%s.zip',
-    },
+    linux: 'https://github.com/Alex313031/thorium/releases/download/M114.0.5735.205/thorium-browser_114.0.5735.205_amd64.zip',
+    mac: 'https://github.com/Alex313031/Thorium-Special/releases/download/M114.0.5735.205-1/Thorium_MacOS_X64.dmg',
+    mac_arm: 'https://github.com/Alex313031/Thorium-Special/releases/download/M114.0.5735.205-1/Thorium_MacOS_ARM.dmg',
+    win64: 'https://github.com/Alex313031/Thorium-Win/releases/download/M114.0.5735.205/Thorium_114.0.5735.205.zip',
 };
-const browserConfig = {
-    chrome: {
-        host: 'https://storage.googleapis.com',
-        destination: '.chromium',
-    },
-    firefox: {
-        host: 'https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central',
-        destination: '.firefox',
-    },
-};
-function archiveName(product, platform, revision) {
-    switch (product) {
-        case 'chrome':
-            switch (platform) {
-                case 'linux':
-                    return 'chrome-linux';
-                case 'mac_arm':
-                case 'mac':
-                    return 'chrome-mac';
-                case 'win32':
-                case 'win64':
-                    // Windows archive name changed at r591479.
-                    return parseInt(revision, 10) > 591479
-                        ? 'Thorium_107.0.5271.0\\BIN'
-                        : 'chrome-win32';
-                default:
-                    throw new Error('unknown browser');
-            }
-        case 'firefox':
-            return platform;
-        default:
-            throw new Error('unknown browser');
-    }
-}
-function _downloadURL(product, platform, host, revision) {
-    if (platform === 'win64' || platform === 'win32') {
-        return 'https://remotionchromium-binaries.s3.eu-central-1.amazonaws.com/thorium-107.zip';
-    }
-    return node_util_1.default.format(downloadURLs[product][platform], host, revision, archiveName(product, platform, revision));
+function getThoriumDownloadUrl(platform) {
+    return downloadURLs[platform];
 }
-function handleArm64() {
-    let exists = fs.existsSync('/usr/bin/chromium-browser');
-    if (exists) {
-        return;
-    }
-    exists = fs.existsSync('/usr/bin/chromium');
-    if (exists) {
-        return;
-    }
-    console.error('The chromium binary is not available for arm64.' +
-        '\nIf you are on Ubuntu, you can install with: ' +
-        '\n\n sudo apt install chromium\n' +
-        '\n\n sudo apt install chromium-browser\n');
-    throw new Error();
-}
-const readdirAsync = (0, node_util_2.promisify)(fs.readdir.bind(fs));
-const mkdirAsync = (0, node_util_2.promisify)(fs.mkdir.bind(fs));
-const unlinkAsync = (0, node_util_2.promisify)(fs.unlink.bind(fs));
-const chmodAsync = (0, node_util_2.promisify)(fs.chmod.bind(fs));
+const readdirAsync = fs.promises.readdir;
+const mkdirAsync = fs.promises.mkdir;
+const unlinkAsync = (0, node_util_1.promisify)(fs.unlink.bind(fs));
+const chmodAsync = (0, node_util_1.promisify)(fs.chmod.bind(fs));
 function existsAsync(filePath) {
     return new Promise((resolve) => {
         fs.access(filePath, (err) => {
@@ -137,46 +72,33 @@ function existsAsync(filePath) {
         });
     });
 }
-const getPlatform = (product) => {
+const getPlatform = () => {
     const platform = os.platform();
     switch (platform) {
         case 'darwin':
-            switch (product) {
-                case 'chrome':
-                    return os.arch() === 'arm64' &&
-                        PUPPETEER_EXPERIMENTAL_CHROMIUM_MAC_ARM
-                        ? 'mac_arm'
-                        : 'mac';
-                case 'firefox':
-                    return 'mac';
-                default:
-                    throw new Error('unknown browser');
-            }
+            return os.arch() === 'arm64' ? 'mac_arm' : 'mac';
         case 'linux':
             return 'linux';
         case 'win32':
-            return os.arch() === 'x64' ? 'win64' : 'win32';
+            return 'win64';
         default:
             (0, assert_1.assert)(false, 'Unsupported platform: ' + platform);
     }
 };
-exports.getPlatform = getPlatform;
-const getDownloadsFolder = (product) => {
-    return path.join((0, get_download_destination_1.getDownloadsCacheDir)(), browserConfig[product].destination);
-};
-exports.getDownloadsFolder = getDownloadsFolder;
-const getDownloadHost = (product) => {
-    return browserConfig[product].host;
+const destination = '.thorium';
+const getDownloadsFolder = () => {
+    return path.join((0, get_download_destination_1.getDownloadsCacheDir)(), destination);
 };
-exports.getDownloadHost = getDownloadHost;
-const download = async ({ revision, progressCallback, product, platform, downloadHost, downloadsFolder, }) => {
-    const url = _downloadURL(product, platform, downloadHost, revision);
-    const fileName = url.split('/').pop();
-    (0, assert_1.assert)(fileName, `A malformed download URL was found: ${url}.`);
+const downloadBrowser = async () => {
+    const platform = getPlatform();
+    const downloadURL = getThoriumDownloadUrl(platform);
+    const fileName = downloadURL.split('/').pop();
+    (0, assert_1.assert)(fileName, `A malformed download URL was found: ${downloadURL}.`);
+    const downloadsFolder = getDownloadsFolder();
     const archivePath = path.join(downloadsFolder, fileName);
-    const outputPath = (0, exports.getFolderPath)(revision, downloadsFolder, platform);
+    const outputPath = getFolderPath(downloadsFolder, platform);
     if (await existsAsync(outputPath)) {
-        return (0, exports.getRevisionInfo)(revision, product);
+        return (0, exports.getRevisionInfo)();
     }
     if (!(await existsAsync(downloadsFolder))) {
         await mkdirAsync(downloadsFolder, {
@@ -185,163 +107,75 @@ const download = async ({ revision, progressCallback, product, platform, downloa
     }
     // Use system Chromium builds on Linux ARM devices
     if (os.platform() !== 'darwin' && os.arch() === 'arm64') {
-        handleArm64();
-        return;
+        throw new Error('The chromium binary is not available for arm64.' +
+            '\nIf you are on Ubuntu, you can install with: ' +
+            '\n\n sudo apt install chromium\n' +
+            '\n\n sudo apt install chromium-browser\n');
     }
     try {
-        await _downloadFile(url, archivePath, progressCallback);
-        await install(archivePath, outputPath);
+        let lastProgress = 0;
+        await (0, download_file_1.downloadFile)({
+            url: downloadURL,
+            to: () => archivePath,
+            onProgress: (progress) => {
+                if (progress.downloaded > lastProgress + 10000000) {
+                    lastProgress = progress.downloaded;
+                    logger_1.Log.info(`Downloading Thorium - ${toMegabytes(progress.downloaded)}/${toMegabytes(progress.totalSize)}`);
+                }
+            },
+        });
+        await install({ archivePath, folderPath: outputPath });
     }
     finally {
         if (await existsAsync(archivePath)) {
             await unlinkAsync(archivePath);
         }
     }
-    const revisionInfo = (0, exports.getRevisionInfo)(revision, product);
-    if (revisionInfo) {
-        await chmodAsync(revisionInfo.executablePath, 0o755);
-    }
+    const revisionInfo = (0, exports.getRevisionInfo)();
+    await chmodAsync(revisionInfo.executablePath, 0o755);
     return revisionInfo;
 };
-exports.download = download;
-const localRevisions = async (downloadsFolder, product, platform) => {
-    if (!(await existsAsync(downloadsFolder))) {
-        return [];
-    }
-    const fileNames = await readdirAsync(downloadsFolder);
-    return fileNames
-        .map((fileName) => {
-        return parseFolderPath(product, fileName);
-    })
-        .filter((entry) => {
-        var _a;
-        return (_a = (entry && entry.platform === platform)) !== null && _a !== void 0 ? _a : false;
-    })
-        .map((entry) => {
-        return entry.revision;
-    });
-};
-exports.localRevisions = localRevisions;
-const removeBrowser = async (revision, folderPath) => {
-    (0, assert_1.assert)(await existsAsync(folderPath), `Failed to remove: revision ${revision} is not downloaded`);
-    (0, delete_directory_1.deleteDirectory)(folderPath);
-};
-exports.removeBrowser = removeBrowser;
-const getFolderPath = (revision, downloadsFolder, platform) => {
-    return path.resolve(downloadsFolder, `${platform}-${revision}`);
+exports.downloadBrowser = downloadBrowser;
+const getFolderPath = (downloadsFolder, platform) => {
+    return path.resolve(downloadsFolder, platform);
 };
-exports.getFolderPath = getFolderPath;
-const getExecutablePath = (product, revision) => {
-    const downloadsFolder = (0, exports.getDownloadsFolder)(product);
-    const platform = (0, exports.getPlatform)(product);
-    const folderPath = (0, exports.getFolderPath)(revision, downloadsFolder, platform);
-    if (product === 'chrome') {
-        if (platform === 'mac' || platform === 'mac_arm') {
-            return path.join(folderPath, archiveName(product, platform, revision), 'Chromium.app', 'Contents', 'MacOS', 'Chromium');
-        }
-        if (platform === 'linux') {
-            return path.join(folderPath, archiveName(product, platform, revision), 'chrome');
-        }
-        if (platform === 'win32' || platform === 'win64') {
-            return path.join(folderPath, archiveName(product, platform, revision), 'thorium.exe');
-        }
-        throw new Error('Unsupported platform: ' + platform);
+const getExecutablePath = () => {
+    const downloadsFolder = getDownloadsFolder();
+    const platform = getPlatform();
+    const folderPath = getFolderPath(downloadsFolder, platform);
+    if (platform === 'mac' || platform === 'mac_arm') {
+        return path.join(folderPath, 'Thorium.app', 'Contents', 'MacOS', 'Thorium');
     }
-    if (product === 'firefox') {
-        if (platform === 'mac' || platform === 'mac_arm') {
-            return path.join(folderPath, 'Firefox Nightly.app', 'Contents', 'MacOS', 'firefox');
-        }
-        if (platform === 'linux') {
-            return path.join(folderPath, 'firefox', 'firefox');
-        }
-        if (platform === 'win32' || platform === 'win64') {
-            return path.join(folderPath, 'firefox', 'firefox.exe');
-        }
-        throw new Error('Unsupported platform: ' + platform);
+    if (platform === 'linux') {
+        return path.join(folderPath, 'thorium');
     }
-    throw new Error('Unsupported product: ' + product);
+    if (platform === 'win64') {
+        return path.join(folderPath, 'BIN', 'thorium.exe');
+    }
+    throw new Error('Can not download browser for platform: ' + platform);
 };
-const getRevisionInfo = (revision, product) => {
-    const executablePath = getExecutablePath(product, revision);
-    const downloadsFolder = (0, exports.getDownloadsFolder)(product);
-    const platform = (0, exports.getPlatform)(product);
-    const folderPath = (0, exports.getFolderPath)(revision, downloadsFolder, platform);
-    const url = _downloadURL(product, platform, (0, exports.getDownloadHost)(product), revision);
+const getRevisionInfo = () => {
+    const executablePath = getExecutablePath();
+    const downloadsFolder = getDownloadsFolder();
+    const platform = getPlatform();
+    const folderPath = getFolderPath(downloadsFolder, platform);
+    const url = getThoriumDownloadUrl(platform);
     const local = fs.existsSync(folderPath);
     return {
-        revision,
         executablePath,
         folderPath,
         local,
         url,
-        product,
     };
 };
 exports.getRevisionInfo = getRevisionInfo;
-function parseFolderPath(product, folderPath) {
-    const name = path.basename(folderPath);
-    const splits = name.split('-');
-    if (splits.length !== 2) {
-        return;
-    }
-    const [platform, revision] = splits;
-    if (!revision || !platform || !(platform in downloadURLs[product])) {
-        return;
-    }
-    return { product, platform, revision };
-}
-function _downloadFile(url, destinationPath, progressCallback) {
-    let fulfill;
-    let reject;
-    const promise = new Promise((x, y) => {
-        fulfill = x;
-        reject = y;
-    });
-    let downloadedBytes = 0;
-    let totalBytes = 0;
-    let lastProgress = Date.now();
-    function onData(chunk) {
-        downloadedBytes += chunk.length;
-        if (Date.now() - lastProgress > 1000) {
-            progressCallback(downloadedBytes, totalBytes);
-            lastProgress = Date.now();
-        }
-    }
-    const request = httpRequest(url, 'GET', (response) => {
-        if (response.statusCode !== 200) {
-            const error = new Error(`Download failed: server returned code ${response.statusCode}. URL: ${url}`);
-            // consume response data to free up memory
-            response.resume();
-            reject(error);
-            return;
-        }
-        const file = fs.createWriteStream(destinationPath);
-        file.on('close', () => {
-            return fulfill(totalBytes);
-        });
-        file.on('error', (error) => {
-            return reject(error);
-        });
-        response.pipe(file);
-        totalBytes = parseInt(response.headers['content-length'], 10);
-        response.on('data', onData);
-    });
-    request.on('error', (error) => {
-        return reject(error);
-    });
-    return promise;
-}
-function install(archivePath, folderPath) {
+async function install({ archivePath, folderPath, }) {
     if (archivePath.endsWith('.zip')) {
         return (0, extract_zip_1.default)(archivePath, { dir: folderPath });
     }
-    if (archivePath.endsWith('.tar.bz2')) {
-        throw new Error('bz2 currently not implemented');
-    }
     if (archivePath.endsWith('.dmg')) {
-        return mkdirAsync(folderPath).then(() => {
-            return _installDMG(archivePath, folderPath);
-        });
+        await mkdirAsync(folderPath);
+        return _installDMG(archivePath, folderPath);
     }
     throw new Error(`Unsupported archive format: ${archivePath}`);
 }
@@ -394,31 +228,7 @@ function _installDMG(dmgPath, folderPath) {
         });
     });
 }
-function httpRequest(url, method, response, keepAlive = true) {
-    const urlParsed = URL.parse(url);
-    const options = {
-        ...urlParsed,
-        method,
-        headers: keepAlive
-            ? {
-                Connection: 'keep-alive',
-            }
-            : undefined,
-    };
-    const requestCallback = (res) => {
-        if (res.statusCode &&
-            res.statusCode >= 300 &&
-            res.statusCode < 400 &&
-            res.headers.location) {
-            httpRequest(res.headers.location, method, response);
-        }
-        else {
-            response(res);
-        }
-    };
-    const request = options.protocol === 'https:'
-        ? https.request(options, requestCallback)
-        : http.request(options, requestCallback);
-    request.end();
-    return request;
+function toMegabytes(bytes) {
+    const mb = bytes / 1024 / 1024;
+    return `${Math.round(mb * 10) / 10} Mb`;
 }

package/dist/browser/LaunchOptions.d.ts

@@ -15,7 +15,6 @@
  */
 import type { LogLevel } from '../log-level';
 import type { BrowserConnectOptions } from './BrowserConnector';
-import type { Product } from './Product';
 export interface BrowserLaunchArgumentOptions {
     headless?: boolean | 'chrome';
     userDataDir?: string;
@@ -29,7 +28,6 @@ export interface LaunchOptions {
     dumpio?: boolean;
     logLevel: LogLevel;
     env?: Record<string, string | undefined>;
-    product?: Product;
     indent: boolean;
 }
 export type PuppeteerNodeLaunchOptions = BrowserLaunchArgumentOptions & LaunchOptions & BrowserConnectOptions;

package/dist/browser/Launcher.d.ts

@@ -1,15 +1,10 @@
 import { HeadlessBrowser } from './Browser';
 import type { PuppeteerNodeLaunchOptions } from './LaunchOptions';
-import type { Product } from './Product';
 export interface ProductLauncher {
     launch(object: PuppeteerNodeLaunchOptions): Promise<HeadlessBrowser>;
     executablePath: (path?: any) => string;
-    product: Product;
 }
 export declare class ChromeLauncher implements ProductLauncher {
-    _preferredRevision: string;
-    constructor(preferredRevision: string);
     launch(options: PuppeteerNodeLaunchOptions): Promise<HeadlessBrowser>;
     executablePath(): string;
-    get product(): Product;
 }

package/dist/browser/Launcher.js

@@ -52,9 +52,6 @@ const tmpDir = () => {
     return process.env.PUPPETEER_TMP_DIR || os.tmpdir();
 };
 class ChromeLauncher {
-    constructor(preferredRevision) {
-        this._preferredRevision = preferredRevision;
-    }
     async launch(options) {
         const { args = [], dumpio = false, executablePath, env = process.env, defaultViewport, timeout = 60000, debuggingPort, indent, } = options;
         const chromeArguments = args;
@@ -69,7 +66,7 @@ class ChromeLauncher {
         chromeArguments.push(`--user-data-dir=${userDataDir}`);
         let chromeExecutable = executablePath;
         if (!chromeExecutable) {
-            const { missingText, executablePath: exPath } = resolveExecutablePath(this);
+            const { missingText, executablePath: exPath } = resolveExecutablePath();
             if (missingText) {
                 throw new Error(missingText);
             }
@@ -113,21 +110,15 @@ class ChromeLauncher {
         return browser;
     }
     executablePath() {
-        const results = resolveExecutablePath(this);
+        const results = resolveExecutablePath();
         return results.executablePath;
     }
-    get product() {
-        return 'chrome';
-    }
 }
 exports.ChromeLauncher = ChromeLauncher;
-function resolveExecutablePath(launcher) {
-    const { product, _preferredRevision } = launcher;
-    const revisionInfo = (0, BrowserFetcher_1.getRevisionInfo)(_preferredRevision, 'chrome');
-    const firefoxHelp = `Run \`PUPPETEER_PRODUCT=firefox npm install\` to download a supported Firefox browser binary.`;
-    const chromeHelp = `Run \`npm install\` to download the correct Chromium revision.`;
+function resolveExecutablePath() {
+    const revisionInfo = (0, BrowserFetcher_1.getRevisionInfo)();
     const missingText = revisionInfo.local
         ? undefined
-        : `Could not find expected browser (${product}) locally. ${product === 'chrome' ? chromeHelp : firefoxHelp}`;
+        : `Could not find expected browser locally.`;
     return { executablePath: revisionInfo.executablePath, missingText };
 }

package/dist/browser/PuppeteerNode.d.ts

@@ -17,21 +17,14 @@ import type { HeadlessBrowser } from './Browser';
 import type { BrowserConnectOptions } from './BrowserConnector';
 import type { ProductLauncher } from './Launcher';
 import type { BrowserLaunchArgumentOptions, LaunchOptions } from './LaunchOptions';
-import type { Product } from './Product';
 interface PuppeteerLaunchOptions extends LaunchOptions, BrowserLaunchArgumentOptions, BrowserConnectOptions {
-    product?: Product;
     extraPrefsFirefox?: Record<string, unknown>;
 }
 export declare class PuppeteerNode {
     #private;
-    _preferredRevision: string;
-    constructor(settings: {
-        preferredRevision: string;
-        productName?: Product;
-    });
+    constructor();
     launch(options: PuppeteerLaunchOptions): Promise<HeadlessBrowser>;
     executablePath(channel?: string): string;
     get _launcher(): ProductLauncher;
-    get product(): string;
 }
 export {};