@remotion/renderer 4.0.0-alpha.217 → 4.0.0-alpha10

package/README.md

@@ -1,41 +1,9 @@
-# Rust development
+# Renderer
 
-To participate in the development of the Rust parts of Remotion, you need to do additional steps. If you don't want to change the Rust code, you don't have to set anything up.
+Contains TypeScript + Rust code for rendering a Remotion video.
 
-## Setup
+See the public APIs here: https://remotion.dev/docs/renderer
 
-These are instructions for macOS. Contributions for other platforms are appreciated.
+## Development
 
-First, install Cargo, if you don't have it, or upgrade to a version that supports `edition-2021`:
-
-```
-curl https://sh.rustup.rs -sSf | sh
-```
-
-> This will take a few minutes.
-
-## Building
-
-To build the Rust parts for your operating system, run:
-
-```
-node build.mjs
-```
-
-## Building for all platforms
-
-These instructions currently are for macOS. Contributions for other platforms are appreciated.
-
-To build the Rust binaries for all supported platforms, you need to install some dependencies:
-
-```sh
-node install-toolchains.mjs
-```
-
-You can then build all binaries with:
-
-```
-pnpm build-all
-```
-
-The resulting artifacts should be checked into Git.
+For developing the Rust parts, see https://remotion.dev/docs/contributing/rust.

package/dist/assets/download-and-map-assets-to-file.js

@@ -27,8 +27,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadAndMapAssetsToFileUrl = exports.getSanitizedFilenameForAssetUrl = exports.markAllAssetsAsDownloaded = exports.downloadAsset = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importStar(require("path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importStar(require("node:path"));
 const remotion_1 = require("remotion");
 const compress_assets_1 = require("../compress-assets");
 const ensure_output_directory_1 = require("../ensure-output-directory");
@@ -124,7 +124,7 @@ const downloadAsset = async ({ src, onDownload, downloadMap, }) => {
     if ((_a = downloadMap.hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[downloadDir]) {
         const claimedDownloadLocation = (_b = downloadMap.hasBeenDownloadedMap[src]) === null || _b === void 0 ? void 0 : _b[downloadDir];
         // The OS might have deleted the file since even though we marked it as downloaded. In that case we reset the state and download it again
-        if (fs_1.default.existsSync(claimedDownloadLocation)) {
+        if (node_fs_1.default.existsSync(claimedDownloadLocation)) {
             return claimedDownloadLocation;
         }
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -168,7 +168,7 @@ const downloadAsset = async ({ src, onDownload, downloadMap, }) => {
         });
         (0, ensure_output_directory_1.ensureOutputDirectory)(output);
         const buff = Buffer.from(assetData, encoding);
-        await fs_1.default.promises.writeFile(output, buff);
+        await node_fs_1.default.promises.writeFile(output, buff);
         notifyAssetIsDownloaded({ src, downloadMap, downloadDir, to: output });
         return output;
     }
@@ -212,7 +212,7 @@ const getFilename = ({ contentDisposition, src, contentType, }) => {
         };
     }
     const { pathname, search } = new URL(src);
-    const ext = (0, path_1.extname)(pathname);
+    const ext = (0, node_path_1.extname)(pathname);
     // Has no file extension, check if we can derive it from contentType
     if (!ext && contentType) {
         const matchedExt = (0, mime_types_1.getExt)(contentType);
@@ -238,7 +238,7 @@ const getSanitizedFilenameForAssetUrl = ({ src, downloadDir, contentDisposition,
         : '';
     const hashedFileName = String((0, remotion_1.random)(`${pathname}${search}`)).replace('0.', '');
     const filename = hashedFileName + fileExtension;
-    return path_1.default.join(downloadDir, (0, sanitize_filepath_1.sanitizeFilePath)(filename));
+    return node_path_1.default.join(downloadDir, (0, sanitize_filepath_1.sanitizeFilePath)(filename));
 };
 exports.getSanitizedFilenameForAssetUrl = getSanitizedFilenameForAssetUrl;
 const downloadAndMapAssetsToFileUrl = async ({ asset, onDownload, downloadMap, }) => {

package/dist/assets/download-file.d.ts

@@ -2,7 +2,7 @@ declare type Response = {
     sizeInBytes: number;
     to: string;
 };
-export declare const downloadFile: ({ onProgress, url, to: toFn, }: {
+declare type Options = {
     url: string;
     to: (contentDisposition: string | null, contentType: string | null) => string;
     onProgress: ((progress: {
@@ -10,5 +10,6 @@ export declare const downloadFile: ({ onProgress, url, to: toFn, }: {
         downloaded: number;
         totalSize: number | null;
     }) => void) | undefined;
-}) => Promise<Response>;
+};
+export declare const downloadFile: (options: Options, retries?: number) => Promise<Response>;
 export {};

package/dist/assets/download-file.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadFile = void 0;
-const fs_1 = require("fs");
+const node_fs_1 = require("node:fs");
 const ensure_output_directory_1 = require("../ensure-output-directory");
 const read_file_1 = require("./read-file");
-const downloadFile = ({ onProgress, url, to: toFn, }) => {
+const downloadFileWithoutRetries = ({ onProgress, url, to: toFn }) => {
     return new Promise((resolve, reject) => {
         let rejected = false;
         let resolved = false;
@@ -44,7 +44,7 @@ const downloadFile = ({ onProgress, url, to: toFn, }) => {
             (0, ensure_output_directory_1.ensureOutputDirectory)(to);
             const sizeHeader = res.headers['content-length'];
             const totalSize = typeof sizeHeader === 'undefined' ? null : Number(sizeHeader);
-            const writeStream = (0, fs_1.createWriteStream)(to);
+            const writeStream = (0, node_fs_1.createWriteStream)(to);
             let downloaded = 0;
             // Listen to 'close' event instead of more
             // concise method to avoid this problem
@@ -86,4 +86,19 @@ const downloadFile = ({ onProgress, url, to: toFn, }) => {
         });
     });
 };
+const downloadFile = async (options, retries = 2) => {
+    try {
+        const res = await downloadFileWithoutRetries(options);
+        return res;
+    }
+    catch (err) {
+        if (err.message === 'aborted') {
+            if (retries === 0) {
+                throw err;
+            }
+            return (0, exports.downloadFile)(options, retries - 1);
+        }
+        throw err;
+    }
+};
 exports.downloadFile = downloadFile;

package/dist/assets/download-map.d.ts

@@ -1,21 +1,4 @@
-/// <reference types="node" />
 import type { TAsset } from 'remotion';
-declare type EncodingStatus = {
-    type: 'encoding';
-} | {
-    type: 'done';
-    src: string;
-} | undefined;
-export declare type SpecialVCodecForTransparency = 'vp9' | 'vp8' | 'none';
-export declare type NeedsResize = [number, number] | null;
-export declare type Vp9Result = {
-    specialVcodecForTransparency: SpecialVCodecForTransparency;
-    needsResize: NeedsResize;
-};
-export declare type VideoDurationResult = {
-    duration: number | null;
-    fps: number | null;
-};
 export declare type AudioChannelsAndDurationResultCache = {
     channels: number;
     duration: number | null;
@@ -37,14 +20,6 @@ export declare type DownloadMap = {
             [downloadDir: string]: (() => void)[];
         };
     };
-    lastFrameMap: Record<string, {
-        lastAccessed: number;
-        data: Buffer;
-    }>;
-    isBeyondLastFrameMap: Record<string, number>;
-    isVp9VideoCache: Record<string, Vp9Result>;
-    ensureFileHasPresentationTimestamp: Record<string, EncodingStatus>;
-    videoDurationResultCache: Record<string, VideoDurationResult>;
     durationOfAssetCache: Record<string, AudioChannelsAndDurationResultCache>;
     downloadDir: string;
     preEncode: string;
@@ -66,4 +41,3 @@ export declare type RenderAssetInfo = {
 };
 export declare const makeDownloadMap: () => DownloadMap;
 export declare const cleanDownloadMap: (downloadMap: DownloadMap) => void;
-export {};

package/dist/assets/download-map.js

@@ -27,18 +27,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cleanDownloadMap = exports.makeDownloadMap = void 0;
-const fs_1 = __importStar(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importStar(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const delete_directory_1 = require("../delete-directory");
 const tmp_dir_1 = require("../tmp-dir");
 const makeAndReturn = (dir, name) => {
-    const p = path_1.default.join(dir, name);
-    (0, fs_1.mkdirSync)(p);
+    const p = node_path_1.default.join(dir, name);
+    (0, node_fs_1.mkdirSync)(p);
     return p;
 };
-const packageJsonPath = path_1.default.join(__dirname, '..', '..', 'package.json');
-const packageJson = fs_1.default.existsSync(packageJsonPath)
-    ? JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'))
+const packageJsonPath = node_path_1.default.join(__dirname, '..', '..', 'package.json');
+const packageJson = node_fs_1.default.existsSync(packageJsonPath)
+    ? JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, 'utf-8'))
     : null;
 const makeDownloadMap = () => {
     const dir = (0, tmp_dir_1.tmpDir)(packageJson
@@ -48,11 +48,6 @@ const makeDownloadMap = () => {
         isDownloadingMap: {},
         hasBeenDownloadedMap: {},
         listeners: {},
-        lastFrameMap: {},
-        isBeyondLastFrameMap: {},
-        ensureFileHasPresentationTimestamp: {},
-        isVp9VideoCache: {},
-        videoDurationResultCache: {},
         durationOfAssetCache: {},
         id: String(Math.random()),
         assetDir: dir,

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

@@ -1,6 +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 }: {
+export declare function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }: {
     src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
 }): Promise<VideoDurationResult>;
-export declare const getVideoStreamDuration: (downloadMap: DownloadMap, src: 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

@@ -1,7 +1,11 @@
 "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 call_ffmpeg_1 = require("../call-ffmpeg");
+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) => {
@@ -35,7 +39,7 @@ const parseVideoStreamDuration = (stdout) => {
     return result;
 };
 exports.parseVideoStreamDuration = parseVideoStreamDuration;
-async function getVideoStreamDurationwithoutCache({ src }) {
+async function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }) {
     const args = [
         ['-v', 'error'],
         ['-select_streams', 'v:0'],
@@ -44,22 +48,24 @@ async function getVideoStreamDurationwithoutCache({ src }) {
     ]
         .reduce((acc, val) => acc.concat(val), [])
         .filter(Boolean);
-    const task = await (0, call_ffmpeg_1.callFf)('ffprobe', args);
+    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) {
+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) => {
-    return limit(() => getVideoStreamDurationUnlimited(downloadMap, src));
+const getVideoStreamDuration = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
 };
 exports.getVideoStreamDuration = getVideoStreamDuration;

package/dist/assets/read-file.d.ts

@@ -1,2 +1,2 @@
-import http from 'http';
+import http from 'node:http';
 export declare const readFile: (url: string, redirectsSoFar?: number) => Promise<http.IncomingMessage>;

package/dist/assets/read-file.js

@@ -4,15 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readFile = void 0;
-const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
+const node_http_1 = __importDefault(require("node:http"));
 const redirect_status_codes_1 = require("../redirect-status-codes");
 const getClient = (url) => {
     if (url.startsWith('https://')) {
         return https_1.default.get;
     }
     if (url.startsWith('http://')) {
-        return http_1.default.get;
+        return node_http_1.default.get;
     }
     throw new Error('Can only download URLs starting with http:// or https://');
 };

package/dist/assets/sanitize-filepath.js

@@ -4,13 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanitizeFilePath = void 0;
-const path_1 = __importDefault(require("path"));
+const node_path_1 = __importDefault(require("node:path"));
 const sanitize_filename_1 = require("./sanitize-filename");
 const pathSeparators = /[/\\]/;
 const sanitizeFilePath = (pathToSanitize) => {
     return pathToSanitize
         .split(pathSeparators)
         .map((s) => (0, sanitize_filename_1.sanitizeFilename)(s))
-        .join(path_1.default.sep);
+        .join(node_path_1.default.sep);
 };
 exports.sanitizeFilePath = sanitizeFilePath;

package/dist/browser/Browser.d.ts

@@ -28,14 +28,14 @@ export declare const enum BrowserEmittedEvents {
     Closed = "closed",
     ClosedSilent = "closed-silent"
 }
-export declare class Browser extends EventEmitter {
+export declare class HeadlessBrowser extends EventEmitter {
     #private;
     static _create({ connection, contextIds, defaultViewport, closeCallback, }: {
         connection: Connection;
         contextIds: string[];
         defaultViewport: Viewport;
         closeCallback?: BrowserCloseCallback;
-    }): Promise<Browser>;
+    }): Promise<HeadlessBrowser>;
     connection: Connection;
     get _targets(): Map<string, Target>;
     constructor(connection: Connection, contextIds: string[], defaultViewport: Viewport, closeCallback?: BrowserCloseCallback);
@@ -50,13 +50,13 @@ export declare class Browser extends EventEmitter {
 }
 export declare class BrowserContext extends EventEmitter {
     #private;
-    constructor(browser: Browser, contextId?: string);
+    constructor(browser: HeadlessBrowser, contextId?: string);
     targets(): Target[];
     waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: {
         timeout?: number;
     }): Promise<Target>;
     pages(): Promise<Page[]>;
     newPage(): Promise<Page>;
-    browser(): Browser;
+    browser(): HeadlessBrowser;
 }
 export {};

package/dist/browser/Browser.js

@@ -25,59 +25,59 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _Browser_instances, _Browser_defaultViewport, _Browser_closeCallback, _Browser_defaultContext, _Browser_contexts, _Browser_targets, _Browser_targetCreated, _Browser_targetDestroyed, _Browser_targetInfoChanged, _BrowserContext_browser, _BrowserContext_id;
+var _HeadlessBrowser_instances, _HeadlessBrowser_defaultViewport, _HeadlessBrowser_closeCallback, _HeadlessBrowser_defaultContext, _HeadlessBrowser_contexts, _HeadlessBrowser_targets, _HeadlessBrowser_targetCreated, _HeadlessBrowser_targetDestroyed, _HeadlessBrowser_targetInfoChanged, _BrowserContext_browser, _BrowserContext_id;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrowserContext = exports.Browser = void 0;
+exports.BrowserContext = exports.HeadlessBrowser = void 0;
 const assert_1 = require("./assert");
 const EventEmitter_1 = require("./EventEmitter");
 const Target_1 = require("./Target");
 const util_1 = require("./util");
-class Browser extends EventEmitter_1.EventEmitter {
+class HeadlessBrowser extends EventEmitter_1.EventEmitter {
     // eslint-disable-next-line max-params
     constructor(connection, contextIds, defaultViewport, closeCallback) {
         super();
-        _Browser_instances.add(this);
-        _Browser_defaultViewport.set(this, void 0);
-        _Browser_closeCallback.set(this, void 0);
-        _Browser_defaultContext.set(this, void 0);
-        _Browser_contexts.set(this, void 0);
-        _Browser_targets.set(this, void 0);
-        __classPrivateFieldSet(this, _Browser_defaultViewport, defaultViewport, "f");
+        _HeadlessBrowser_instances.add(this);
+        _HeadlessBrowser_defaultViewport.set(this, void 0);
+        _HeadlessBrowser_closeCallback.set(this, void 0);
+        _HeadlessBrowser_defaultContext.set(this, void 0);
+        _HeadlessBrowser_contexts.set(this, void 0);
+        _HeadlessBrowser_targets.set(this, void 0);
+        __classPrivateFieldSet(this, _HeadlessBrowser_defaultViewport, defaultViewport, "f");
         this.connection = connection;
-        __classPrivateFieldSet(this, _Browser_closeCallback, closeCallback ||
+        __classPrivateFieldSet(this, _HeadlessBrowser_closeCallback, closeCallback ||
             function () {
                 return undefined;
             }, "f");
-        __classPrivateFieldSet(this, _Browser_defaultContext, new BrowserContext(this), "f");
-        __classPrivateFieldSet(this, _Browser_contexts, new Map(), "f");
+        __classPrivateFieldSet(this, _HeadlessBrowser_defaultContext, new BrowserContext(this), "f");
+        __classPrivateFieldSet(this, _HeadlessBrowser_contexts, new Map(), "f");
         for (const contextId of contextIds) {
-            __classPrivateFieldGet(this, _Browser_contexts, "f").set(contextId, new BrowserContext(this, contextId));
+            __classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").set(contextId, new BrowserContext(this, contextId));
         }
-        __classPrivateFieldSet(this, _Browser_targets, new Map(), "f");
-        this.connection.on('Target.targetCreated', __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_targetCreated).bind(this));
-        this.connection.on('Target.targetDestroyed', __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_targetDestroyed).bind(this));
-        this.connection.on('Target.targetInfoChanged', __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_targetInfoChanged).bind(this));
+        __classPrivateFieldSet(this, _HeadlessBrowser_targets, new Map(), "f");
+        this.connection.on('Target.targetCreated', __classPrivateFieldGet(this, _HeadlessBrowser_instances, "m", _HeadlessBrowser_targetCreated).bind(this));
+        this.connection.on('Target.targetDestroyed', __classPrivateFieldGet(this, _HeadlessBrowser_instances, "m", _HeadlessBrowser_targetDestroyed).bind(this));
+        this.connection.on('Target.targetInfoChanged', __classPrivateFieldGet(this, _HeadlessBrowser_instances, "m", _HeadlessBrowser_targetInfoChanged).bind(this));
     }
     static async _create({ connection, contextIds, defaultViewport, closeCallback, }) {
-        const browser = new Browser(connection, contextIds, defaultViewport, closeCallback);
+        const browser = new HeadlessBrowser(connection, contextIds, defaultViewport, closeCallback);
         await connection.send('Target.setDiscoverTargets', { discover: true });
         return browser;
     }
     get _targets() {
-        return __classPrivateFieldGet(this, _Browser_targets, "f");
+        return __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f");
     }
     browserContexts() {
-        return [__classPrivateFieldGet(this, _Browser_defaultContext, "f"), ...Array.from(__classPrivateFieldGet(this, _Browser_contexts, "f").values())];
+        return [__classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f"), ...Array.from(__classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").values())];
     }
     newPage() {
-        return __classPrivateFieldGet(this, _Browser_defaultContext, "f").newPage();
+        return __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f").newPage();
     }
     async _createPageInContext(contextId) {
         const { targetId } = await this.connection.send('Target.createTarget', {
             url: 'about:blank',
             browserContextId: contextId || undefined,
         });
-        const target = __classPrivateFieldGet(this, _Browser_targets, "f").get(targetId);
+        const target = __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").get(targetId);
         if (!target) {
             throw new Error(`Missing target for page (id = ${targetId})`);
         }
@@ -92,7 +92,7 @@ class Browser extends EventEmitter_1.EventEmitter {
         return page;
     }
     targets() {
-        return Array.from(__classPrivateFieldGet(this, _Browser_targets, "f").values()).filter((target) => {
+        return Array.from(__classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").values()).filter((target) => {
             return target._isInitialized;
         });
     }
@@ -133,7 +133,7 @@ class Browser extends EventEmitter_1.EventEmitter {
         }, []);
     }
     async close(silent) {
-        await __classPrivateFieldGet(this, _Browser_closeCallback, "f").call(null);
+        await __classPrivateFieldGet(this, _HeadlessBrowser_closeCallback, "f").call(null);
         (await this.pages()).forEach((page) => {
             page.emit("disposed" /* PageEmittedEvents.Disposed */);
             page.closed = true;
@@ -145,35 +145,35 @@ class Browser extends EventEmitter_1.EventEmitter {
         this.connection.dispose();
     }
 }
-exports.Browser = Browser;
-_Browser_defaultViewport = new WeakMap(), _Browser_closeCallback = new WeakMap(), _Browser_defaultContext = new WeakMap(), _Browser_contexts = new WeakMap(), _Browser_targets = new WeakMap(), _Browser_instances = new WeakSet(), _Browser_targetCreated = async function _Browser_targetCreated(event) {
+exports.HeadlessBrowser = HeadlessBrowser;
+_HeadlessBrowser_defaultViewport = new WeakMap(), _HeadlessBrowser_closeCallback = new WeakMap(), _HeadlessBrowser_defaultContext = new WeakMap(), _HeadlessBrowser_contexts = new WeakMap(), _HeadlessBrowser_targets = new WeakMap(), _HeadlessBrowser_instances = new WeakSet(), _HeadlessBrowser_targetCreated = async function _HeadlessBrowser_targetCreated(event) {
     var _a;
     const { targetInfo } = event;
     const { browserContextId } = targetInfo;
-    const context = browserContextId && __classPrivateFieldGet(this, _Browser_contexts, "f").has(browserContextId)
-        ? __classPrivateFieldGet(this, _Browser_contexts, "f").get(browserContextId)
-        : __classPrivateFieldGet(this, _Browser_defaultContext, "f");
+    const context = browserContextId && __classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").has(browserContextId)
+        ? __classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").get(browserContextId)
+        : __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f");
     if (!context) {
         throw new Error('Missing browser context');
     }
     const target = new Target_1.Target(targetInfo, context, () => {
         return this.connection.createSession(targetInfo);
-    }, (_a = __classPrivateFieldGet(this, _Browser_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null);
-    (0, assert_1.assert)(!__classPrivateFieldGet(this, _Browser_targets, "f").has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
-    __classPrivateFieldGet(this, _Browser_targets, "f").set(event.targetInfo.targetId, target);
+    }, (_a = __classPrivateFieldGet(this, _HeadlessBrowser_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null);
+    (0, assert_1.assert)(!__classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
+    __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").set(event.targetInfo.targetId, target);
     if (await target._initializedPromise) {
         this.emit("targetcreated" /* BrowserEmittedEvents.TargetCreated */, target);
     }
-}, _Browser_targetDestroyed = function _Browser_targetDestroyed(event) {
-    const target = __classPrivateFieldGet(this, _Browser_targets, "f").get(event.targetId);
+}, _HeadlessBrowser_targetDestroyed = function _HeadlessBrowser_targetDestroyed(event) {
+    const target = __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").get(event.targetId);
     if (!target) {
         throw new Error(`Missing target in _targetDestroyed (id = ${event.targetId})`);
     }
     target._initializedCallback(false);
-    __classPrivateFieldGet(this, _Browser_targets, "f").delete(event.targetId);
+    __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").delete(event.targetId);
     target._closedCallback();
-}, _Browser_targetInfoChanged = function _Browser_targetInfoChanged(event) {
-    const target = __classPrivateFieldGet(this, _Browser_targets, "f").get(event.targetInfo.targetId);
+}, _HeadlessBrowser_targetInfoChanged = function _HeadlessBrowser_targetInfoChanged(event) {
+    const target = __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").get(event.targetInfo.targetId);
     if (!target) {
         throw new Error(`Missing target in targetInfoChanged (id = ${event.targetInfo.targetId})`);
     }

package/dist/browser/BrowserFetcher.d.ts

@@ -15,11 +15,6 @@
  */
 import type { Product } from './Product';
 declare type Platform = 'linux' | 'mac' | 'mac_arm' | 'win32' | 'win64';
-export interface BrowserFetcherOptions {
-    platform: Platform | null;
-    product: Product;
-    path: string | null;
-}
 interface BrowserFetcherRevisionInfo {
     folderPath: string;
     executablePath: string;
@@ -28,62 +23,19 @@ interface BrowserFetcherRevisionInfo {
     revision: string;
     product: string;
 }
-export declare class BrowserFetcher {
-    #private;
-    constructor(options: BrowserFetcherOptions);
-    /**
-     * @returns Returns the current `Platform`, which is one of `mac`, `linux`,
-     * `win32` or `win64`.
-     */
-    platform(): Platform;
-    /**
-     * @returns Returns the current `Product`, which is one of `chrome` or
-     * `firefox`.
-     */
-    product(): Product;
-    /**
-     * @returns The download host being used.
-     */
-    host(): string;
-    /**
-     * Initiates a HEAD request to check if the revision is available.
-     * @remarks
-     * This method is affected by the current `product`.
-     * @param revision - The revision to check availability for.
-     * @returns A promise that resolves to `true` if the revision could be downloaded
-     * from the host.
-     */
-    canDownload(revision: string): Promise<boolean>;
-    /**
-     * Initiates a GET request to download the revision from the host.
-     * @remarks
-     * This method is affected by the current `product`.
-     * @param revision - The revision to download.
-     * @param progressCallback - A function that will be called with two arguments:
-     * How many bytes have been downloaded and the total number of bytes of the download.
-     * @returns A promise with revision information when the revision is downloaded
-     * and extracted.
-     */
-    download(revision: string, progressCallback?: (x: number, y: number) => void): Promise<BrowserFetcherRevisionInfo | undefined>;
-    /**
-     * @remarks
-     * This method is affected by the current `product`.
-     * @returns A promise with a list of all revision strings (for the current `product`)
-     * available locally on disk.
-     */
-    localRevisions(): Promise<string[]>;
-    /**
-     * @remarks
-     * This method is affected by the current `product`.
-     * @param revision - A revision to remove for the current `product`.
-     * @returns A promise that resolves when the revision has been removes or
-     * throws if the revision has not been downloaded.
-     */
-    remove(revision: string): Promise<void>;
-    /**
-     * @param revision - The revision to get info for.
-     * @returns The revision info for the given revision.
-     */
-    revisionInfo(revision: string): BrowserFetcherRevisionInfo;
-}
+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 {};