@remotion/renderer 4.0.0-preload.17 → 4.0.0-reorg.27

package/dist/assets/calculate-asset-positions.d.ts

@@ -1,3 +1,3 @@
-import { TAsset } from 'remotion';
-import { Assets } from './types';
+import type { TAsset } from 'remotion';
+import type { Assets } from './types';
 export declare const calculateAssetPositions: (frames: TAsset[][]) => Assets;

package/dist/assets/convert-assets-to-file-urls.d.ts

@@ -1,5 +1,5 @@
-import { TAsset } from 'remotion';
-import { RenderMediaOnDownload } from './download-and-map-assets-to-file';
+import type { TAsset } from 'remotion';
+import type { RenderMediaOnDownload } from './download-and-map-assets-to-file';
 export declare const convertAssetsToFileUrls: ({ assets, downloadDir, onDownload, }: {
     assets: TAsset[][];
     downloadDir: string;

package/dist/assets/download-and-map-assets-to-file.d.ts

@@ -1,20 +1,22 @@
-import { TAsset } from 'remotion';
+import type { TAsset } from 'remotion';
 export declare type RenderMediaOnDownload = (src: string) => ((progress: {
-    percent: number;
+    percent: number | null;
+    downloaded: number;
+    totalSize: number | null;
 }) => void) | undefined | void;
-export declare const waitForAssetToBeDownloaded: (src: string) => Promise<string>;
+export declare const downloadAsset: ({ src, onDownload, downloadDir, }: {
+    src: string;
+    onDownload: RenderMediaOnDownload;
+    downloadDir: string;
+}) => Promise<string>;
 export declare const markAllAssetsAsDownloaded: () => void;
-export declare const getSanitizedFilenameForAssetUrl: ({ src, downloadDir, }: {
+export declare const getSanitizedFilenameForAssetUrl: ({ src, downloadDir, contentDisposition, }: {
     src: string;
     downloadDir: string;
+    contentDisposition: string | null;
 }) => string;
 export declare const downloadAndMapAssetsToFileUrl: ({ asset, downloadDir, onDownload, }: {
     asset: TAsset;
     downloadDir: string;
     onDownload: RenderMediaOnDownload;
 }) => Promise<TAsset>;
-export declare const startDownloadForSrc: ({ src, downloadDir, onDownload, }: {
-    src: string;
-    downloadDir: string;
-    onDownload: RenderMediaOnDownload;
-}) => Promise<string>;

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

@@ -3,35 +3,54 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startDownloadForSrc = exports.downloadAndMapAssetsToFileUrl = exports.getSanitizedFilenameForAssetUrl = exports.markAllAssetsAsDownloaded = exports.waitForAssetToBeDownloaded = void 0;
+exports.downloadAndMapAssetsToFileUrl = exports.getSanitizedFilenameForAssetUrl = exports.markAllAssetsAsDownloaded = exports.downloadAsset = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const remotion_1 = require("remotion");
+const compress_assets_1 = require("../compress-assets");
 const ensure_output_directory_1 = require("../ensure-output-directory");
 const download_file_1 = require("./download-file");
 const sanitize_filepath_1 = require("./sanitize-filepath");
 const isDownloadingMap = {};
 const hasBeenDownloadedMap = {};
 const listeners = {};
-const waitForAssetToBeDownloaded = (src) => {
-    if (hasBeenDownloadedMap[src]) {
-        return Promise.resolve(hasBeenDownloadedMap[src]);
+const waitForAssetToBeDownloaded = ({ src, downloadDir, }) => {
+    var _a, _b;
+    if ((_a = hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[downloadDir]) {
+        return Promise.resolve((_b = hasBeenDownloadedMap[src]) === null || _b === void 0 ? void 0 : _b[downloadDir]);
     }
     if (!listeners[src]) {
-        listeners[src] = [];
+        listeners[src] = {};
+    }
+    if (!listeners[src][downloadDir]) {
+        listeners[src][downloadDir] = [];
     }
     return new Promise((resolve) => {
-        listeners[src].push((to) => resolve(to));
+        listeners[src][downloadDir].push(() => {
+            const srcMap = hasBeenDownloadedMap[src];
+            if (!srcMap || !srcMap[downloadDir]) {
+                throw new Error('Expected file for ' + src + 'to be available in ' + downloadDir);
+            }
+            resolve(srcMap[downloadDir]);
+        });
     });
 };
-exports.waitForAssetToBeDownloaded = waitForAssetToBeDownloaded;
-const notifyAssetIsDownloaded = (src, to) => {
+const notifyAssetIsDownloaded = ({ src, downloadDir, to, }) => {
     if (!listeners[src]) {
-        listeners[src] = [];
+        listeners[src] = {};
+    }
+    if (!listeners[src][downloadDir]) {
+        listeners[src][downloadDir] = [];
+    }
+    if (!isDownloadingMap[src]) {
+        isDownloadingMap[src] = {};
+    }
+    isDownloadingMap[src][downloadDir] = true;
+    if (!hasBeenDownloadedMap[src]) {
+        hasBeenDownloadedMap[src] = {};
     }
-    listeners[src].forEach((fn) => fn(to));
-    isDownloadingMap[src] = false;
-    hasBeenDownloadedMap[src] = to;
+    hasBeenDownloadedMap[src][downloadDir] = to;
+    listeners[src][downloadDir].forEach((fn) => fn());
 };
 const validateMimeType = (mimeType, src) => {
     if (!mimeType.includes('/')) {
@@ -72,17 +91,40 @@ function validateBufferEncoding(potentialEncoding, dataUrl) {
         throw new TypeError(errMessage);
     }
 }
-const downloadAsset = async (src, to, onDownload) => {
-    if (hasBeenDownloadedMap[src]) {
-        return;
+const downloadAsset = async ({ src, onDownload, downloadDir, }) => {
+    var _a, _b, _c;
+    if ((0, compress_assets_1.isAssetCompressed)(src)) {
+        return src;
+    }
+    if ((_a = hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[downloadDir]) {
+        const claimedDownloadLocation = (_b = 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)) {
+            return claimedDownloadLocation;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        hasBeenDownloadedMap[src][downloadDir] = null;
+        if (!isDownloadingMap[src]) {
+            isDownloadingMap[src] = {};
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        isDownloadingMap[src][downloadDir] = false;
+    }
+    if ((_c = isDownloadingMap[src]) === null || _c === void 0 ? void 0 : _c[downloadDir]) {
+        return waitForAssetToBeDownloaded({ src, downloadDir });
     }
-    if (isDownloadingMap[src]) {
-        return (0, exports.waitForAssetToBeDownloaded)(src);
+    if (!isDownloadingMap[src]) {
+        isDownloadingMap[src] = {};
     }
-    isDownloadingMap[src] = true;
+    isDownloadingMap[src][downloadDir] = true;
     const onProgress = onDownload(src);
-    (0, ensure_output_directory_1.ensureOutputDirectory)(to);
     if (src.startsWith('data:')) {
+        const output = (0, exports.getSanitizedFilenameForAssetUrl)({
+            contentDisposition: null,
+            downloadDir,
+            src,
+        });
+        (0, ensure_output_directory_1.ensureOutputDirectory)(output);
         const [assetDetails, assetData] = src.substring('data:'.length).split(',');
         if (!assetDetails.includes(';')) {
             const errMessage = [
@@ -97,17 +139,21 @@ const downloadAsset = async (src, to, onDownload) => {
         validateMimeType(mimeType, src);
         validateBufferEncoding(encoding, src);
         const buff = Buffer.from(assetData, encoding);
-        await fs_1.default.promises.writeFile(to, buff);
-        notifyAssetIsDownloaded(src, to);
-        return;
+        await fs_1.default.promises.writeFile(output, buff);
+        notifyAssetIsDownloaded({ src, downloadDir, to: output });
+        return output;
     }
-    await (0, download_file_1.downloadFile)(src, to, ({ progress }) => {
-        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
-            percent: progress,
-        });
+    const { to } = await (0, download_file_1.downloadFile)({
+        url: src,
+        onProgress: (progress) => {
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress(progress);
+        },
+        to: (contentDisposition) => (0, exports.getSanitizedFilenameForAssetUrl)({ contentDisposition, downloadDir, src }),
     });
-    notifyAssetIsDownloaded(src, to);
+    notifyAssetIsDownloaded({ src, downloadDir, to });
+    return to;
 };
+exports.downloadAsset = downloadAsset;
 const markAllAssetsAsDownloaded = () => {
     Object.keys(hasBeenDownloadedMap).forEach((key) => {
         delete hasBeenDownloadedMap[key];
@@ -117,21 +163,39 @@ const markAllAssetsAsDownloaded = () => {
     });
 };
 exports.markAllAssetsAsDownloaded = markAllAssetsAsDownloaded;
-const getSanitizedFilenameForAssetUrl = ({ src, downloadDir, }) => {
-    if (remotion_1.Internals.AssetCompression.isAssetCompressed(src)) {
-        return src;
+const getFilename = ({ contentDisposition, src, }) => {
+    const filenameProbe = 'filename=';
+    if (contentDisposition === null || contentDisposition === void 0 ? void 0 : contentDisposition.includes(filenameProbe)) {
+        const start = contentDisposition.indexOf(filenameProbe);
+        const onlyFromFileName = contentDisposition.substring(start + filenameProbe.length);
+        const hasSemi = onlyFromFileName.indexOf(';');
+        if (hasSemi === -1) {
+            return { pathname: onlyFromFileName.trim(), search: '' };
+        }
+        return {
+            search: '',
+            pathname: onlyFromFileName.substring(0, hasSemi).trim(),
+        };
     }
     const { pathname, search } = new URL(src);
+    return { pathname, search };
+};
+const getSanitizedFilenameForAssetUrl = ({ src, downloadDir, contentDisposition, }) => {
+    if ((0, compress_assets_1.isAssetCompressed)(src)) {
+        return src;
+    }
+    const { pathname, search } = getFilename({ contentDisposition, src });
     const split = pathname.split('.');
     const fileExtension = split.length > 1 && split[split.length - 1]
         ? `.${split[split.length - 1]}`
         : '';
     const hashedFileName = String((0, remotion_1.random)(`${pathname}${search}`)).replace('0.', '');
-    return path_1.default.join(downloadDir, (0, sanitize_filepath_1.sanitizeFilePath)(hashedFileName + fileExtension));
+    const filename = hashedFileName + fileExtension;
+    return path_1.default.join(downloadDir, (0, sanitize_filepath_1.sanitizeFilePath)(filename));
 };
 exports.getSanitizedFilenameForAssetUrl = getSanitizedFilenameForAssetUrl;
 const downloadAndMapAssetsToFileUrl = async ({ asset, downloadDir, onDownload, }) => {
-    const newSrc = await (0, exports.startDownloadForSrc)({
+    const newSrc = await (0, exports.downloadAsset)({
         src: asset.src,
         downloadDir,
         onDownload,
@@ -142,11 +206,3 @@ const downloadAndMapAssetsToFileUrl = async ({ asset, downloadDir, onDownload, }
     };
 };
 exports.downloadAndMapAssetsToFileUrl = downloadAndMapAssetsToFileUrl;
-const startDownloadForSrc = async ({ src, downloadDir, onDownload, }) => {
-    const newSrc = (0, exports.getSanitizedFilenameForAssetUrl)({ downloadDir, src });
-    if (!remotion_1.Internals.AssetCompression.isAssetCompressed(newSrc)) {
-        await downloadAsset(src, newSrc, onDownload);
-    }
-    return newSrc;
-};
-exports.startDownloadForSrc = startDownloadForSrc;

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

@@ -1,7 +1,12 @@
-export declare const downloadFile: (url: string, to: string, onProgress: ((progress: {
-    progress: number;
-    downloaded: number;
-    totalSize: number;
-}) => void) | undefined) => Promise<{
+export declare const downloadFile: ({ onProgress, url, to: toFn, }: {
+    url: string;
+    to: (contentDisposition: string | null) => string;
+    onProgress: ((progress: {
+        percent: number | null;
+        downloaded: number;
+        totalSize: number | null;
+    }) => void) | undefined;
+}) => Promise<{
     sizeInBytes: number;
+    to: string;
 }>;

package/dist/assets/download-file.js

@@ -2,25 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadFile = void 0;
 const fs_1 = require("fs");
+const ensure_output_directory_1 = require("../ensure-output-directory");
 const read_file_1 = require("./read-file");
-const downloadFile = (url, to, onProgress) => {
+const downloadFile = ({ onProgress, url, to: toFn, }) => {
     return new Promise((resolve, reject) => {
         (0, read_file_1.readFile)(url)
             .then((res) => {
-            const totalSize = Number(res.headers['content-length']);
+            var _a;
+            const contentDisposition = (_a = res.headers['content-disposition']) !== null && _a !== void 0 ? _a : null;
+            const to = toFn(contentDisposition);
+            (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);
+            let downloaded = 0;
             // Listen to 'close' event instead of more
             // concise method to avoid this problem
             // https://github.com/remotion-dev/remotion/issues/384#issuecomment-844398183
-            writeStream.on('close', () => resolve({ sizeInBytes: totalSize }));
+            writeStream.on('close', () => {
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    downloaded,
+                    percent: 1,
+                    totalSize: downloaded,
+                });
+                return resolve({ sizeInBytes: downloaded, to });
+            });
             writeStream.on('error', (err) => reject(err));
-            let downloaded = 0;
             res.pipe(writeStream).on('error', (err) => reject(err));
             res.on('data', (d) => {
                 downloaded += d.length;
                 onProgress === null || onProgress === void 0 ? void 0 : onProgress({
                     downloaded,
-                    progress: downloaded / totalSize,
+                    percent: totalSize === null ? null : downloaded / totalSize,
                     totalSize,
                 });
             });

package/dist/assets/ffmpeg-volume-expression.d.ts

@@ -1,12 +1,11 @@
-import { AssetVolume } from './types';
+import type { AssetVolume } from './types';
 declare type FfmpegEval = 'once' | 'frame';
 declare type FfmpegVolumeExpression = {
     eval: FfmpegEval;
     value: string;
 };
-export declare const ffmpegVolumeExpression: ({ volume, startInVideo, fps, trimLeft, }: {
+export declare const ffmpegVolumeExpression: ({ volume, fps, trimLeft, }: {
     volume: AssetVolume;
-    startInVideo: number;
     trimLeft: number;
     fps: number;
 }) => FfmpegVolumeExpression;

package/dist/assets/ffmpeg-volume-expression.js

@@ -43,7 +43,7 @@ const ffmpegBuildVolumeExpression = (arr, delay, fps) => {
     const [volume, frames] = first;
     return ffmpegIfOrElse(ffmpegIsOneOfFrames({ frames, trimLeft: delay, fps }), String(volume), ffmpegBuildVolumeExpression(rest, delay, fps));
 };
-const ffmpegVolumeExpression = ({ volume, startInVideo, fps, trimLeft, }) => {
+const ffmpegVolumeExpression = ({ volume, fps, trimLeft, }) => {
     // If it's a static volume, we return it and tell
     // FFMPEG it only has to evaluate it once
     if (typeof volume === 'number') {
@@ -55,7 +55,6 @@ const ffmpegVolumeExpression = ({ volume, startInVideo, fps, trimLeft, }) => {
     if ([...new Set(volume)].length === 1) {
         return (0, exports.ffmpegVolumeExpression)({
             volume: volume[0],
-            startInVideo,
             fps,
             trimLeft,
         });
@@ -76,7 +75,7 @@ const ffmpegVolumeExpression = ({ volume, startInVideo, fps, trimLeft, }) => {
         if (!volumeMap[actualVolume]) {
             volumeMap[actualVolume] = [];
         }
-        volumeMap[actualVolume].push(frame + startInVideo);
+        volumeMap[actualVolume].push(frame);
     });
     // Sort the map so that the most common volume is last
     // this is going to be the else statement so the expression is short

package/dist/assets/flatten-volume-array.d.ts

@@ -1,3 +1,3 @@
-import { AssetVolume, MediaAsset } from './types';
+import type { AssetVolume, MediaAsset } from './types';
 export declare const flattenVolumeArray: (volume: AssetVolume) => AssetVolume;
 export declare const convertAssetToFlattenedVolume: (asset: MediaAsset) => MediaAsset;

package/dist/assets/get-audio-channels.d.ts

@@ -1,4 +1,7 @@
-export declare function getAudioChannelsAndDuration(path: string): Promise<{
+import type { FfmpegExecutable } from '../ffmpeg-executable';
+declare type Result = {
     channels: number;
     duration: number | null;
-}>;
+};
+export declare const getAudioChannelsAndDuration: (src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Result>;
+export {};

package/dist/assets/get-audio-channels.js

@@ -5,21 +5,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioChannelsAndDuration = void 0;
 const execa_1 = __importDefault(require("execa"));
-async function getAudioChannelsAndDuration(path) {
+const p_limit_1 = require("../p-limit");
+const durationOfAssetCache = {};
+const limit = (0, p_limit_1.pLimit)(1);
+async function getAudioChannelsAndDurationUnlimited(src, ffprobeExecutable) {
+    if (durationOfAssetCache[src]) {
+        return durationOfAssetCache[src];
+    }
     const args = [
         ['-v', 'error'],
         ['-show_entries', 'stream=channels:format=duration'],
         ['-of', 'default=nw=1'],
-        [path],
+        [src],
     ]
         .reduce((acc, val) => acc.concat(val), [])
         .filter(Boolean);
-    const task = await (0, execa_1.default)('ffprobe', args);
+    const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', args);
     const channels = task.stdout.match(/channels=([0-9]+)/);
     const duration = task.stdout.match(/duration=([0-9.]+)/);
-    return {
+    const result = {
         channels: channels ? parseInt(channels[1], 10) : 0,
         duration: duration ? parseFloat(duration[1]) : null,
     };
+    durationOfAssetCache[src] = result;
+    return result;
 }
+const getAudioChannelsAndDuration = (src, ffprobeExecutable) => {
+    return limit(() => getAudioChannelsAndDurationUnlimited(src, ffprobeExecutable));
+};
 exports.getAudioChannelsAndDuration = getAudioChannelsAndDuration;

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

@@ -0,0 +1,6 @@
+import type { FfmpegExecutable } from 'remotion';
+declare type Result = {
+    duration: number | null;
+};
+export declare const getVideoStreamDuration: (src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Result>;
+export {};

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

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoStreamDuration = void 0;
+const execa_1 = __importDefault(require("execa"));
+const p_limit_1 = require("../p-limit");
+const durationOfAssetCache = {};
+const limit = (0, p_limit_1.pLimit)(1);
+async function getVideoStreamDurationUnlimited(src, ffprobeExecutable) {
+    if (durationOfAssetCache[src]) {
+        return durationOfAssetCache[src];
+    }
+    const args = [
+        ['-v', 'error'],
+        ['-select_streams', 'v:0'],
+        ['-show_entries', 'stream=duration'],
+        [src],
+    ]
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter(Boolean);
+    const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', args);
+    const duration = task.stdout.match(/duration=([0-9.]+)/);
+    const result = {
+        duration: duration ? parseFloat(duration[1]) : null,
+    };
+    durationOfAssetCache[src] = result;
+    return result;
+}
+const getVideoStreamDuration = (src, ffprobeExecutable) => {
+    return limit(() => getVideoStreamDurationUnlimited(src, ffprobeExecutable));
+};
+exports.getVideoStreamDuration = getVideoStreamDuration;

package/dist/assets/read-file.js

@@ -29,7 +29,10 @@ 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) {
+    if (file.statusCode === 302 ||
+        file.statusCode === 301 ||
+        file.statusCode === 307 ||
+        file.statusCode === 308) {
         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/types.d.ts

@@ -1,4 +1,4 @@
-import { TAsset } from 'remotion';
+import type { TAsset } from 'remotion';
 export declare type UnsafeAsset = Omit<TAsset, 'frame' | 'id' | 'volume' | 'mediaFrame'> & {
     startInVideo: number;
     duration: number | null;

package/dist/browser/Browser.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { 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;
+interface WaitForTargetOptions {
+    timeout?: number;
+}
+export declare const enum BrowserEmittedEvents {
+    TargetChanged = "targetchanged",
+    TargetCreated = "targetcreated",
+    Closed = "closed"
+}
+export declare class Browser extends EventEmitter {
+    #private;
+    static _create({ connection, contextIds, defaultViewport, closeCallback, }: {
+        connection: Connection;
+        contextIds: string[];
+        defaultViewport: Viewport;
+        closeCallback?: BrowserCloseCallback;
+    }): Promise<Browser>;
+    get _targets(): Map<string, Target>;
+    constructor(connection: Connection, contextIds: string[], defaultViewport: Viewport, closeCallback?: BrowserCloseCallback);
+    browserContexts(): BrowserContext[];
+    newPage(): Promise<Page>;
+    _createPageInContext(contextId?: string): Promise<Page>;
+    targets(): Target[];
+    waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: WaitForTargetOptions): Promise<Target>;
+    pages(): Promise<Page[]>;
+    close(): Promise<void>;
+    disconnect(): void;
+}
+export declare class BrowserContext extends EventEmitter {
+    #private;
+    constructor(browser: Browser, contextId?: string);
+    targets(): Target[];
+    waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: {
+        timeout?: number;
+    }): Promise<Target>;
+    pages(): Promise<Page[]>;
+    newPage(): Promise<Page>;
+    browser(): Browser;
+}
+export {};