@remotion/renderer 4.0.0-webhook.27 → 4.1.0-alpha2

package/dist/assets/read-file.js

@@ -4,16 +4,17 @@ 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://');
+    throw new Error(`Can only download URLs starting with http:// or https://, got "${url}"`);
 };
 const readFileWithoutRedirect = (url) => {
     return new Promise((resolve, reject) => {
@@ -29,10 +30,7 @@ const readFile = async (url, redirectsSoFar = 0) => {
         throw new Error(`Too many redirects while downloading ${url}`);
     }
     const file = await readFileWithoutRedirect(url);
-    if (file.statusCode === 302 ||
-        file.statusCode === 301 ||
-        file.statusCode === 307 ||
-        file.statusCode === 308) {
+    if (redirect_status_codes_1.redirectStatusCodes.includes(file.statusCode)) {
         if (!file.headers.location) {
             throw new Error(`Received a status code ${file.statusCode} but no "Location" header while calling ${file.headers.location}`);
         }

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/assets/types.d.ts

@@ -1,16 +1,17 @@
 import type { TAsset } from 'remotion';
-export declare type UnsafeAsset = Omit<TAsset, 'frame' | 'id' | 'volume' | 'mediaFrame'> & {
+export type UnsafeAsset = Omit<TAsset, 'frame' | 'id' | 'volume' | 'mediaFrame'> & {
     startInVideo: number;
     duration: number | null;
     trimLeft: number;
     volume: number[];
     id: string;
     playbackRate: number;
+    allowAmplificationDuringRender: boolean;
 };
-export declare type AssetVolume = number | number[];
-export declare type MediaAsset = Omit<UnsafeAsset, 'duration' | 'volume'> & {
+export type AssetVolume = number | number[];
+export type MediaAsset = Omit<UnsafeAsset, 'duration' | 'volume'> & {
     duration: number;
     volume: AssetVolume;
 };
 export declare const uncompressMediaAsset: (allAssets: TAsset[], assetToUncompress: TAsset) => TAsset;
-export declare type Assets = MediaAsset[];
+export type Assets = MediaAsset[];

package/dist/audio-codec.d.ts

@@ -0,0 +1,28 @@
+import type { Codec } from './codec';
+export declare const validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+export type AudioCodec = typeof validAudioCodecs[number];
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16"];
+    readonly 'h264-mkv': readonly ["pcm-16"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly gif: const[];
+    readonly h265: readonly ["aac", "pcm-16"];
+    readonly mp3: readonly ["mp3", "pcm-16"];
+    readonly prores: readonly ["aac", "pcm-16"];
+    readonly vp8: readonly ["opus", "pcm-16"];
+    readonly vp9: readonly ["opus", "pcm-16"];
+    readonly wav: readonly ["pcm-16"];
+};
+declare const audioCodecNames: readonly ["pcm_s16le", "aac", "libmp3lame", "libopus"];
+type FfmpegAudioCodecName = typeof audioCodecNames[number];
+export declare const mapAudioCodecToFfmpegAudioCodecName: (audioCodec: AudioCodec) => FfmpegAudioCodecName;
+export declare const defaultAudioCodecs: {
+    [key in Codec]: {
+        [k in 'compressed' | 'lossless']: typeof supportedAudioCodecs[key][number] | null;
+    };
+};
+export declare const getDefaultAudioCodec: ({ codec, preferLossless, }: {
+    codec: Codec;
+    preferLossless: boolean;
+}) => AudioCodec | null;
+export {};

package/dist/audio-codec.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultAudioCodec = exports.defaultAudioCodecs = exports.mapAudioCodecToFfmpegAudioCodecName = exports.supportedAudioCodecs = exports.validAudioCodecs = void 0;
+exports.validAudioCodecs = ['pcm-16', 'aac', 'mp3', 'opus'];
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16'],
+    'h264-mkv': ['pcm-16'],
+    aac: ['aac', 'pcm-16'],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['aac', 'pcm-16'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
+const _satisfies = exports.supportedAudioCodecs;
+if (_satisfies) {
+    // Just for type checking
+}
+const audioCodecNames = ['pcm_s16le', 'aac', 'libmp3lame', 'libopus'];
+const mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
+    if (audioCodec === 'aac') {
+        return 'aac';
+    }
+    if (audioCodec === 'mp3') {
+        return 'libmp3lame';
+    }
+    if (audioCodec === 'opus') {
+        return 'libopus';
+    }
+    if (audioCodec === 'pcm-16') {
+        return 'pcm_s16le';
+    }
+    throw new Error('unknown audio codec: ' + audioCodec);
+};
+exports.mapAudioCodecToFfmpegAudioCodecName = mapAudioCodecToFfmpegAudioCodecName;
+exports.defaultAudioCodecs = {
+    'h264-mkv': {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    aac: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    gif: {
+        lossless: null,
+        compressed: null,
+    },
+    h264: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    h265: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    mp3: {
+        lossless: 'pcm-16',
+        compressed: 'mp3',
+    },
+    prores: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    vp8: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    vp9: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    wav: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+};
+const getDefaultAudioCodec = ({ codec, preferLossless, }) => {
+    return exports.defaultAudioCodecs[codec][preferLossless ? 'lossless' : 'compressed'];
+};
+exports.getDefaultAudioCodec = getDefaultAudioCodec;

package/dist/browser/Browser.d.ts

@@ -13,48 +13,50 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { AnySourceMapConsumer } from '../symbolicate-stacktrace';
 import type { Page } from './BrowserPage';
 import type { Connection } from './Connection';
 import { EventEmitter } from './EventEmitter';
 import type { Viewport } from './PuppeteerViewport';
 import { Target } from './Target';
-declare type BrowserCloseCallback = () => Promise<void> | void;
+type BrowserCloseCallback = () => Promise<void> | void;
 interface WaitForTargetOptions {
     timeout?: number;
 }
 export declare const enum BrowserEmittedEvents {
     TargetChanged = "targetchanged",
     TargetCreated = "targetcreated",
-    Closed = "closed"
+    Closed = "closed",
+    ClosedSilent = "closed-silent"
 }
-export declare class Browser extends EventEmitter {
+export declare class HeadlessBrowser extends EventEmitter {
     #private;
-    static _create({ connection, contextIds, defaultViewport, closeCallback, }: {
+    static _create({ connection, defaultViewport, closeCallback, }: {
         connection: Connection;
-        contextIds: string[];
         defaultViewport: Viewport;
-        closeCallback?: BrowserCloseCallback;
-    }): Promise<Browser>;
+        closeCallback: BrowserCloseCallback;
+    }): Promise<HeadlessBrowser>;
+    connection: Connection;
     get _targets(): Map<string, Target>;
-    constructor(connection: Connection, contextIds: string[], defaultViewport: Viewport, closeCallback?: BrowserCloseCallback);
+    constructor(connection: Connection, defaultViewport: Viewport, closeCallback?: BrowserCloseCallback);
     browserContexts(): BrowserContext[];
-    newPage(): Promise<Page>;
-    _createPageInContext(contextId?: string): Promise<Page>;
+    newPage(context: AnySourceMapConsumer | null): Promise<Page>;
+    _createPageInContext(context: AnySourceMapConsumer | null): Promise<Page>;
     targets(): Target[];
     waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: WaitForTargetOptions): Promise<Target>;
     pages(): Promise<Page[]>;
-    close(): Promise<void>;
+    close(silent: boolean): Promise<void>;
     disconnect(): void;
 }
 export declare class BrowserContext extends EventEmitter {
     #private;
-    constructor(browser: Browser, contextId?: string);
+    constructor(browser: HeadlessBrowser);
     targets(): Target[];
     waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: {
         timeout?: number;
     }): Promise<Target>;
     pages(): Promise<Page[]>;
-    newPage(): Promise<Page>;
-    browser(): Browser;
+    newPage(context: AnySourceMapConsumer | null): Promise<Page>;
+    browser(): HeadlessBrowser;
 }
 export {};

package/dist/browser/Browser.js

@@ -14,71 +14,66 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Browser_instances, _Browser_defaultViewport, _Browser_connection, _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;
 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 {
-    // eslint-disable-next-line max-params
-    constructor(connection, contextIds, defaultViewport, closeCallback) {
-        super();
-        _Browser_instances.add(this);
-        _Browser_defaultViewport.set(this, void 0);
-        _Browser_connection.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");
-        __classPrivateFieldSet(this, _Browser_connection, connection, "f");
-        __classPrivateFieldSet(this, _Browser_closeCallback, closeCallback ||
-            function () {
-                return undefined;
-            }, "f");
-        __classPrivateFieldSet(this, _Browser_defaultContext, new BrowserContext(this), "f");
-        __classPrivateFieldSet(this, _Browser_contexts, new Map(), "f");
-        for (const contextId of contextIds) {
-            __classPrivateFieldGet(this, _Browser_contexts, "f").set(contextId, new BrowserContext(this, contextId));
-        }
-        __classPrivateFieldSet(this, _Browser_targets, new Map(), "f");
-        __classPrivateFieldGet(this, _Browser_connection, "f").on('Target.targetCreated', __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_targetCreated).bind(this));
-        __classPrivateFieldGet(this, _Browser_connection, "f").on('Target.targetDestroyed', __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_targetDestroyed).bind(this));
-        __classPrivateFieldGet(this, _Browser_connection, "f").on('Target.targetInfoChanged', __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_targetInfoChanged).bind(this));
-    }
-    static async _create({ connection, contextIds, defaultViewport, closeCallback, }) {
-        const browser = new Browser(connection, contextIds, defaultViewport, closeCallback);
+class HeadlessBrowser extends EventEmitter_1.EventEmitter {
+    static async _create({ connection, defaultViewport, closeCallback, }) {
+        const browser = new HeadlessBrowser(connection, 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");
+    }
+    constructor(connection, defaultViewport, closeCallback) {
+        super();
+        _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, _HeadlessBrowser_closeCallback, closeCallback ||
+            function () {
+                return undefined;
+            }, "f");
+        __classPrivateFieldSet(this, _HeadlessBrowser_defaultContext, new BrowserContext(this), "f");
+        __classPrivateFieldSet(this, _HeadlessBrowser_contexts, new Map(), "f");
+        __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));
     }
     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();
+    newPage(context) {
+        return __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f").newPage(context);
     }
-    async _createPageInContext(contextId) {
-        const { targetId } = await __classPrivateFieldGet(this, _Browser_connection, "f").send('Target.createTarget', {
+    async _createPageInContext(context) {
+        const { targetId } = await this.connection.send('Target.createTarget', {
             url: 'about:blank',
-            browserContextId: contextId || undefined,
+            browserContextId: 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})`);
         }
@@ -86,14 +81,14 @@ class Browser extends EventEmitter_1.EventEmitter {
         if (!initialized) {
             throw new Error(`Failed to create target for page (id = ${targetId})`);
         }
-        const page = await target.page();
+        const page = await target.page(context);
         if (!page) {
-            throw new Error(`Failed to create a page for context (id = ${contextId})`);
+            throw new Error(`Failed to create a page for context`);
         }
         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,44 +128,48 @@ class Browser extends EventEmitter_1.EventEmitter {
             return acc.concat(x);
         }, []);
     }
-    async close() {
-        await __classPrivateFieldGet(this, _Browser_closeCallback, "f").call(null);
+    async close(silent) {
+        await __classPrivateFieldGet(this, _HeadlessBrowser_closeCallback, "f").call(null);
+        (await this.pages()).forEach((page) => {
+            page.emit("disposed" /* PageEmittedEvents.Disposed */);
+            page.closed = true;
+        });
         this.disconnect();
-        this.emit("closed" /* BrowserEmittedEvents.Closed */);
+        this.emit(silent ? "closed-silent" /* BrowserEmittedEvents.ClosedSilent */ : "closed" /* BrowserEmittedEvents.Closed */);
     }
     disconnect() {
-        __classPrivateFieldGet(this, _Browser_connection, "f").dispose();
+        this.connection.dispose();
     }
 }
-exports.Browser = Browser;
-_Browser_defaultViewport = new WeakMap(), _Browser_connection = 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 __classPrivateFieldGet(this, _Browser_connection, "f").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);
+        return this.connection.createSession(targetInfo);
+    }, (_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})`);
     }
@@ -182,12 +181,10 @@ _Browser_defaultViewport = new WeakMap(), _Browser_connection = new WeakMap(), _
     }
 };
 class BrowserContext extends EventEmitter_1.EventEmitter {
-    constructor(browser, contextId) {
+    constructor(browser) {
         super();
         _BrowserContext_browser.set(this, void 0);
-        _BrowserContext_id.set(this, void 0);
         __classPrivateFieldSet(this, _BrowserContext_browser, browser, "f");
-        __classPrivateFieldSet(this, _BrowserContext_id, contextId, "f");
     }
     targets() {
         return __classPrivateFieldGet(this, _BrowserContext_browser, "f").targets().filter((target) => {
@@ -202,17 +199,17 @@ class BrowserContext extends EventEmitter_1.EventEmitter {
     async pages() {
         const pages = await Promise.all(this.targets()
             .filter((target) => target.type() === 'page')
-            .map((target) => target.page()));
+            .map((target) => target.page(null)));
         return pages.filter((page) => {
             return Boolean(page);
         });
     }
-    newPage() {
-        return __classPrivateFieldGet(this, _BrowserContext_browser, "f")._createPageInContext(__classPrivateFieldGet(this, _BrowserContext_id, "f"));
+    newPage(context) {
+        return __classPrivateFieldGet(this, _BrowserContext_browser, "f")._createPageInContext(context);
     }
     browser() {
         return __classPrivateFieldGet(this, _BrowserContext_browser, "f");
     }
 }
 exports.BrowserContext = BrowserContext;
-_BrowserContext_browser = new WeakMap(), _BrowserContext_id = new WeakMap();
+_BrowserContext_browser = new WeakMap();

package/dist/browser/BrowserFetcher.d.ts

@@ -14,12 +14,7 @@
  * limitations under the License.
  */
 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;
-}
+type Platform = 'linux' | 'mac' | 'mac_arm' | 'win32' | 'win64';
 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 {};