@hieutran094/camoufox-js 0.6.2

package/dist/locale.js

@@ -0,0 +1,252 @@
+import { GitHubDownloader, webdl, INSTALL_DIR } from './pkgman.js';
+import { LeakWarning } from './warnings.js';
+import { InvalidLocale, MissingRelease, NotInstalledGeoIPExtra, UnknownIPLocation, UnknownLanguage, UnknownTerritory, } from './exceptions.js';
+import { validateIP } from './ip.js';
+import tags from 'language-tags';
+import * as fs from 'fs';
+import * as path from 'path';
+import maxmind from 'maxmind';
+import xml2js from 'xml2js';
+import { getAsBooleanFromENV } from './utils.js';
+export const ALLOW_GEOIP = true;
+class Locale {
+    language;
+    region;
+    script;
+    constructor(language, region, script) {
+        this.language = language;
+        this.region = region;
+        this.script = script;
+    }
+    asString() {
+        if (this.region) {
+            return `${this.language}-${this.region}`;
+        }
+        return this.language;
+    }
+    asConfig() {
+        if (!this.region) {
+            throw new Error("Region is required for config");
+        }
+        const data = {
+            'locale:region': this.region,
+            'locale:language': this.language,
+        };
+        if (this.script) {
+            data['locale:script'] = this.script;
+        }
+        return data;
+    }
+}
+class Geolocation {
+    locale;
+    longitude;
+    latitude;
+    timezone;
+    accuracy;
+    constructor(locale, longitude, latitude, timezone, accuracy) {
+        this.locale = locale;
+        this.longitude = longitude;
+        this.latitude = latitude;
+        this.timezone = timezone;
+        this.accuracy = accuracy;
+    }
+    asConfig() {
+        const data = {
+            'geolocation:longitude': this.longitude,
+            'geolocation:latitude': this.latitude,
+            'timezone': this.timezone,
+            ...this.locale.asConfig(),
+        };
+        if (this.accuracy !== undefined) {
+            data['geolocation:accuracy'] = this.accuracy;
+        }
+        return data;
+    }
+}
+function verifyLocale(loc) {
+    if (tags.check(loc)) {
+        return;
+    }
+    throw InvalidLocale.invalidInput(loc);
+}
+export function normalizeLocale(locale) {
+    verifyLocale(locale);
+    const parser = tags(locale);
+    if (!parser.region) {
+        throw InvalidLocale.invalidInput(locale);
+    }
+    return new Locale(parser.language()?.format() ?? 'en', parser.region()?.format(), parser.language()?.script()?.format());
+}
+export function handleLocale(locale, ignoreRegion = false) {
+    if (locale.length > 3) {
+        return normalizeLocale(locale);
+    }
+    try {
+        return SELECTOR.fromRegion(locale);
+    }
+    catch (e) {
+        if (e instanceof UnknownTerritory) {
+        }
+        else {
+            throw e;
+        }
+    }
+    if (ignoreRegion) {
+        verifyLocale(locale);
+        return new Locale(locale);
+    }
+    try {
+        const language = SELECTOR.fromLanguage(locale);
+        LeakWarning.warn('no_region');
+        return language;
+    }
+    catch (e) {
+        if (e instanceof UnknownLanguage) {
+        }
+        else {
+            throw e;
+        }
+    }
+    throw InvalidLocale.invalidInput(locale);
+}
+export function handleLocales(locales, config) {
+    if (typeof locales === 'string') {
+        locales = locales.split(',').map(loc => loc.trim());
+    }
+    const intlLocale = handleLocale(locales[0]).asConfig();
+    for (const key in intlLocale) {
+        config[key] = intlLocale[key];
+    }
+    if (locales.length < 2) {
+        return;
+    }
+    config['locale:all'] = joinUnique(locales.map(locale => handleLocale(locale, true).asString()));
+}
+function joinUnique(seq) {
+    const seen = new Set();
+    return seq.filter(x => !seen.has(x) && seen.add(x)).join(', ');
+}
+const MMDB_FILE = path.join(INSTALL_DIR.toString(), 'GeoLite2-City.mmdb');
+const MMDB_REPO = "P3TERX/GeoLite.mmdb";
+class MaxMindDownloader extends GitHubDownloader {
+    checkAsset(asset) {
+        if (asset['name'].endsWith('-City.mmdb')) {
+            return asset['browser_download_url'];
+        }
+        return null;
+    }
+    missingAssetError() {
+        throw new MissingRelease('Failed to find GeoIP database release asset');
+    }
+}
+export function geoipAllowed() {
+    if (!ALLOW_GEOIP) {
+        throw new NotInstalledGeoIPExtra('Please install the geoip extra to use this feature: pip install camoufox[geoip]');
+    }
+}
+export async function downloadMMDB() {
+    geoipAllowed();
+    if (getAsBooleanFromENV('PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD', false)) {
+        console.log("Skipping GeoIP database download due to PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD set!");
+        return;
+    }
+    const assetUrl = await (new MaxMindDownloader(MMDB_REPO).getAsset());
+    const fileStream = fs.createWriteStream(MMDB_FILE);
+    await webdl(assetUrl, 'Downloading GeoIP database', true, fileStream);
+}
+export function removeMMDB() {
+    if (!fs.existsSync(MMDB_FILE)) {
+        console.log("GeoIP database not found.");
+        return;
+    }
+    fs.unlinkSync(MMDB_FILE);
+    console.log("GeoIP database removed.");
+}
+export async function getGeolocation(ip) {
+    if (!fs.existsSync(MMDB_FILE)) {
+        await downloadMMDB();
+    }
+    validateIP(ip);
+    const reader = await maxmind.open(MMDB_FILE);
+    const resp = reader.get(ip);
+    const isoCode = resp.country?.iso_code.toUpperCase();
+    const location = resp.location;
+    if (!location?.longitude || !location?.latitude || !location?.time_zone || !isoCode) {
+        throw new UnknownIPLocation(`Unknown IP location: ${ip}`);
+    }
+    const locale = SELECTOR.fromRegion(isoCode);
+    return new Geolocation(locale, location.longitude, location.latitude, location.time_zone);
+}
+async function getUnicodeInfo() {
+    const data = await fs.promises.readFile(path.join(import.meta.dirname, 'data-files', 'territoryInfo.xml'));
+    const parser = new xml2js.Parser();
+    return parser.parseStringPromise(data);
+}
+function asFloat(element, attr) {
+    return parseFloat(element[attr] || '0');
+}
+class StatisticalLocaleSelector {
+    root;
+    constructor() {
+        this.loadUnicodeInfo();
+    }
+    async loadUnicodeInfo() {
+        this.root = await getUnicodeInfo();
+    }
+    loadTerritoryData(isoCode) {
+        const territory = this.root.territoryInfo.territory.find((t) => t.$.type === isoCode);
+        if (!territory) {
+            throw new UnknownTerritory(`Unknown territory: ${isoCode}`);
+        }
+        const langPopulations = territory.languagePopulation;
+        if (!langPopulations) {
+            throw new Error(`No language data found for region: ${isoCode}`);
+        }
+        const languages = langPopulations.map((lang) => lang.$.type);
+        const percentages = langPopulations.map((lang) => asFloat(lang.$, 'populationPercent'));
+        return this.normalizeProbabilities(languages, percentages);
+    }
+    loadLanguageData(language) {
+        const territories = this.root.territory.filter((t) => t.languagePopulation.some((lp) => lp.$.type === language));
+        if (!territories.length) {
+            throw new UnknownLanguage(`No region data found for language: ${language}`);
+        }
+        const regions = [];
+        const percentages = [];
+        for (const terr of territories) {
+            const region = terr.$.type;
+            const langPop = terr.languagePopulation.find((lp) => lp.$.type === language);
+            if (region && langPop) {
+                regions.push(region);
+                percentages.push(asFloat(langPop.$, 'populationPercent') *
+                    asFloat(terr.$, 'literacyPercent') / 10000 *
+                    asFloat(terr.$, 'population'));
+            }
+        }
+        if (!regions.length) {
+            throw new Error(`No valid region data found for language: ${language}`);
+        }
+        return this.normalizeProbabilities(regions, percentages);
+    }
+    normalizeProbabilities(languages, freq) {
+        const total = freq.reduce((a, b) => a + b, 0);
+        return [languages, freq.map(f => f / total)];
+    }
+    weightedRandomChoice(items, weights) {
+        const cumulativeWeights = weights.map((sum => (value) => sum += value)(0));
+        const random = Math.random() * cumulativeWeights[cumulativeWeights.length - 1];
+        return items[cumulativeWeights.findIndex(weight => weight > random)];
+    }
+    fromRegion(region) {
+        const [languages, probabilities] = this.loadTerritoryData(region);
+        const language = this.weightedRandomChoice(languages, probabilities).replace('_', '-');
+        return normalizeLocale(`${language}-${region}`);
+    }
+    fromLanguage(language) {
+        const [regions, probabilities] = this.loadLanguageData(language);
+        const region = this.weightedRandomChoice(regions, probabilities);
+        return normalizeLocale(`${language}-${region}`);
+    }
+}
+const SELECTOR = new StatisticalLocaleSelector();

package/dist/pkgman.d.ts

@@ -0,0 +1,65 @@
+import { PathLike } from 'fs';
+import { Writable } from 'stream';
+export declare const OS_NAME: 'mac' | 'win' | 'lin';
+export declare const INSTALL_DIR: PathLike;
+export declare const LOCAL_DATA: PathLike;
+export declare const OS_ARCH_MATRIX: {
+    [key: string]: string[];
+};
+declare class Version {
+    release: string;
+    version?: string;
+    sorted_rel: number[];
+    constructor(release: string, version?: string);
+    private buildSortedRel;
+    get fullString(): string;
+    equals(other: Version): boolean;
+    lessThan(other: Version): boolean;
+    isSupported(): boolean;
+    static fromPath(filePath?: PathLike): Version;
+    static isSupportedPath(path: PathLike): boolean;
+    static buildMinMax(): [Version, Version];
+}
+export declare class GitHubDownloader {
+    githubRepo: string;
+    apiUrl: string;
+    constructor(githubRepo: string);
+    checkAsset(asset: any): any;
+    missingAssetError(): void;
+    getAsset({ retries }?: {
+        retries: number;
+    }): Promise<any>;
+}
+export declare class CamoufoxFetcher extends GitHubDownloader {
+    arch: string;
+    _version_obj?: Version;
+    pattern: RegExp;
+    _url?: string;
+    constructor();
+    init(): Promise<void>;
+    checkAsset(asset: any): [Version, string] | null;
+    missingAssetError(): void;
+    static getPlatformArch(): string;
+    fetchLatest(): Promise<void>;
+    static downloadFile(url: string): Promise<Buffer>;
+    extractZip(zipFile: string | Buffer): Promise<void>;
+    static cleanup(): boolean;
+    setVersion(): void;
+    install(): Promise<void>;
+    get url(): string;
+    get version(): string;
+    get release(): string;
+    get verstr(): string;
+}
+export declare function installedVerStr(): string;
+export declare function camoufoxPath(downloadIfMissing?: boolean): PathLike;
+export declare function getPath(file: string): string;
+export declare function launchPath(): string;
+export declare function webdl(url: string, desc?: string, bar?: boolean, buffer?: Writable | null, { retries }?: {
+    retries: number;
+}): Promise<Buffer>;
+export declare function unzip(zipFile: Buffer, extractPath: string, desc?: string, bar?: boolean): Promise<void>;
+export declare function loadYaml(file: string): {
+    [key: string]: any;
+};
+export {};

package/dist/pkgman.js

@@ -0,0 +1,348 @@
+import { CONSTRAINTS } from './__version__.js';
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { CamoufoxNotInstalled, FileNotFoundError, MissingRelease, UnsupportedArchitecture, UnsupportedOS, UnsupportedVersion, } from './exceptions.js';
+import AdmZip from 'adm-zip';
+import * as yaml from 'js-yaml';
+import ProgressBar from 'progress';
+import { setTimeout } from 'timers/promises';
+const ARCH_MAP = {
+    'x64': 'x86_64',
+    'ia32': 'i686',
+    'arm64': 'arm64',
+    'arm': 'arm64',
+};
+const OS_MAP = {
+    'darwin': 'mac',
+    'linux': 'lin',
+    'win32': 'win',
+};
+if (!(process.platform in OS_MAP)) {
+    throw new UnsupportedOS(`OS ${process.platform} is not supported`);
+}
+export const OS_NAME = OS_MAP[process.platform];
+export const INSTALL_DIR = userCacheDir('camoufox');
+export const LOCAL_DATA = path.join(import.meta.dirname, 'data-files');
+export const OS_ARCH_MATRIX = {
+    'win': ['x86_64', 'i686'],
+    'mac': ['x86_64', 'arm64'],
+    'lin': ['x86_64', 'arm64', 'i686'],
+};
+const LAUNCH_FILE = {
+    'win': 'camoufox.exe',
+    'mac': '../MacOS/camoufox',
+    'lin': 'camoufox-bin',
+};
+class Version {
+    release;
+    version;
+    sorted_rel;
+    constructor(release, version) {
+        this.release = release;
+        this.version = version;
+        this.sorted_rel = this.buildSortedRel();
+    }
+    buildSortedRel() {
+        const parts = this.release.split('.').map(x => (isNaN(Number(x)) ? x.charCodeAt(0) - 1024 : Number(x)));
+        while (parts.length < 5) {
+            parts.push(0);
+        }
+        return parts;
+    }
+    get fullString() {
+        return `${this.version}-${this.release}`;
+    }
+    equals(other) {
+        return this.sorted_rel.join('.') === other.sorted_rel.join('.');
+    }
+    lessThan(other) {
+        for (let i = 0; i < this.sorted_rel.length; i++) {
+            if (this.sorted_rel[i] < other.sorted_rel[i])
+                return true;
+            if (this.sorted_rel[i] > other.sorted_rel[i])
+                return false;
+        }
+        return false;
+    }
+    isSupported() {
+        return VERSION_MIN.lessThan(this) && this.lessThan(VERSION_MAX);
+    }
+    static fromPath(filePath = INSTALL_DIR) {
+        const versionPath = path.join(filePath.toString(), 'version.json');
+        if (!fs.existsSync(versionPath)) {
+            throw new FileNotFoundError(`Version information not found at ${versionPath}. Please run \`camoufox fetch\` to install.`);
+        }
+        const versionData = JSON.parse(fs.readFileSync(versionPath, 'utf-8'));
+        return new Version(versionData.release, versionData.version);
+    }
+    static isSupportedPath(path) {
+        return Version.fromPath(path).isSupported();
+    }
+    static buildMinMax() {
+        return [new Version(CONSTRAINTS.MIN_VERSION), new Version(CONSTRAINTS.MAX_VERSION)];
+    }
+}
+const [VERSION_MIN, VERSION_MAX] = Version.buildMinMax();
+export class GitHubDownloader {
+    githubRepo;
+    apiUrl;
+    constructor(githubRepo) {
+        this.githubRepo = githubRepo;
+        this.apiUrl = `https://api.github.com/repos/${githubRepo}/releases`;
+    }
+    checkAsset(asset) {
+        return asset.browser_download_url;
+    }
+    missingAssetError() {
+        throw new MissingRelease(`Could not find a release asset in ${this.githubRepo}.`);
+    }
+    async getAsset({ retries } = { retries: 5 }) {
+        let attempts = 0;
+        let response;
+        while (attempts < retries) {
+            try {
+                response = await fetch(this.apiUrl);
+                if (response.ok)
+                    break;
+            }
+            catch (e) {
+                console.error(e, `retrying (${attempts + 1}/${retries})...`);
+                await setTimeout(5e3);
+            }
+            attempts++;
+        }
+        if (!response || !response.ok) {
+            throw new Error(`Failed to fetch releases from ${this.apiUrl} after ${retries} attempts`);
+        }
+        const releases = await response.json();
+        for (const release of releases) {
+            for (const asset of release.assets) {
+                const data = this.checkAsset(asset);
+                if (data) {
+                    return data;
+                }
+            }
+        }
+        this.missingAssetError();
+    }
+}
+export class CamoufoxFetcher extends GitHubDownloader {
+    arch;
+    _version_obj;
+    pattern;
+    _url;
+    constructor() {
+        super("daijro/camoufox");
+        this.arch = CamoufoxFetcher.getPlatformArch();
+        this.pattern = new RegExp(`camoufox-(.+)-(.+)-${OS_NAME}\\.${this.arch}\\.zip`);
+    }
+    async init() {
+        await this.fetchLatest();
+    }
+    checkAsset(asset) {
+        const match = asset.name.match(this.pattern);
+        if (!match)
+            return null;
+        const version = new Version(match[2], match[1]);
+        if (!version.isSupported())
+            return null;
+        return [version, asset.browser_download_url];
+    }
+    missingAssetError() {
+        throw new MissingRelease(`No matching release found for ${OS_NAME} ${this.arch} in the supported range: (${CONSTRAINTS.asRange()}). Please update the library.`);
+    }
+    static getPlatformArch() {
+        const platArch = os.arch().toLowerCase();
+        if (!(platArch in ARCH_MAP)) {
+            throw new UnsupportedArchitecture(`Architecture ${platArch} is not supported`);
+        }
+        const arch = ARCH_MAP[platArch];
+        if (!OS_ARCH_MATRIX[OS_NAME].includes(arch)) {
+            throw new UnsupportedArchitecture(`Architecture ${arch} is not supported for ${OS_NAME}`);
+        }
+        return arch;
+    }
+    async fetchLatest() {
+        if (this._version_obj)
+            return;
+        const releaseData = await this.getAsset();
+        this._version_obj = releaseData[0];
+        this._url = releaseData[1];
+    }
+    static async downloadFile(url) {
+        const response = await fetch(url);
+        return Buffer.from(await response.arrayBuffer());
+    }
+    async extractZip(zipFile) {
+        const zip = new AdmZip(zipFile);
+        zip.extractAllTo(INSTALL_DIR.toString(), true);
+    }
+    static cleanup() {
+        if (fs.existsSync(INSTALL_DIR)) {
+            fs.rmSync(INSTALL_DIR, { recursive: true });
+            return true;
+        }
+        return false;
+    }
+    setVersion() {
+        fs.writeFileSync(path.join(INSTALL_DIR.toString(), 'version.json'), JSON.stringify({ version: this.version, release: this.release }));
+    }
+    async install() {
+        await this.init();
+        await CamoufoxFetcher.cleanup();
+        try {
+            fs.mkdirSync(INSTALL_DIR, { recursive: true });
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'camoufox-'));
+            const tempFilePath = path.join(tempDir, 'camoufox.zip');
+            const tempFileStream = fs.createWriteStream(tempFilePath);
+            await webdl(this.url, 'Downloading Camoufox...', true, tempFileStream);
+            await new Promise(r => tempFileStream.close(r));
+            await this.extractZip(tempFilePath);
+            this.setVersion();
+            if (OS_NAME !== 'win') {
+                execSync(`chmod -R 755 ${INSTALL_DIR}`);
+            }
+            console.log('Camoufox successfully installed.');
+        }
+        catch (e) {
+            console.error(`Error installing Camoufox: ${e}`);
+            await CamoufoxFetcher.cleanup();
+            throw e;
+        }
+    }
+    get url() {
+        if (!this._url) {
+            throw new Error("Url is not available. Make sure to run fetchLatest first.");
+        }
+        return this._url;
+    }
+    get version() {
+        if (!this._version_obj || !this._version_obj.version) {
+            throw new Error("Version is not available. Make sure to run fetchLatest first.");
+        }
+        return this._version_obj.version;
+    }
+    get release() {
+        if (!this._version_obj) {
+            throw new Error("Release information is not available. Make sure to run the installation first.");
+        }
+        return this._version_obj.release;
+    }
+    get verstr() {
+        if (!this._version_obj) {
+            throw new Error("Version is not available. Make sure to run the installation first.");
+        }
+        return this._version_obj.fullString;
+    }
+}
+function userCacheDir(appName) {
+    if (OS_NAME === 'win') {
+        return path.join(os.homedir(), 'AppData', 'Local', appName, appName, 'Cache');
+    }
+    else if (OS_NAME === 'mac') {
+        return path.join(os.homedir(), 'Library', 'Caches', appName);
+    }
+    else {
+        return path.join(os.homedir(), '.cache', appName);
+    }
+}
+export function installedVerStr() {
+    return Version.fromPath().fullString;
+}
+export function camoufoxPath(downloadIfMissing = true) {
+    // Ensure the directory exists and is not empty
+    if (!fs.existsSync(INSTALL_DIR) || fs.readdirSync(INSTALL_DIR).length === 0) {
+        if (!downloadIfMissing) {
+            throw new Error(`Camoufox executable not found at ${INSTALL_DIR}`);
+        }
+    }
+    else if (fs.existsSync(INSTALL_DIR) && Version.isSupportedPath(INSTALL_DIR)) {
+        return INSTALL_DIR;
+    }
+    else {
+        if (!downloadIfMissing) {
+            throw new UnsupportedVersion("Camoufox executable is outdated.");
+        }
+    }
+    // Install and recheck
+    const fetcher = new CamoufoxFetcher();
+    fetcher.install().then(() => camoufoxPath());
+    return INSTALL_DIR;
+}
+export function getPath(file) {
+    if (OS_NAME === 'mac') {
+        return path.resolve(camoufoxPath().toString(), 'Camoufox.app', 'Contents', 'Resources', file);
+    }
+    return path.join(camoufoxPath().toString(), file);
+}
+export function launchPath() {
+    const launchPath = getPath(LAUNCH_FILE[OS_NAME]);
+    if (!fs.existsSync(launchPath)) {
+        throw new CamoufoxNotInstalled(`Camoufox is not installed at ${camoufoxPath()}. Please run \`camoufox fetch\` to install.`);
+    }
+    return launchPath;
+}
+export async function webdl(url, desc = '', bar = true, buffer = null, { retries } = { retries: 5 }) {
+    let attempts = 0;
+    let response;
+    while (attempts < retries) {
+        try {
+            response = await fetch(url);
+            if (response.ok)
+                break;
+        }
+        catch (e) {
+            console.error(e, `retrying (${attempts + 1}/${retries})...`);
+            await setTimeout(5e3);
+        }
+        attempts++;
+    }
+    if (!response || !response.ok) {
+        throw new Error(`Failed to download from ${url} after ${retries} attempts`);
+    }
+    const totalSize = parseInt(response.headers.get('content-length') || '0', 10);
+    const progressBar = bar ? new ProgressBar(`${desc} [:bar] :percent :etas`, {
+        total: totalSize,
+        width: 40,
+    }) : null;
+    const chunks = [];
+    for await (const chunk of response.body) {
+        if (buffer) {
+            buffer.write(chunk);
+        }
+        else {
+            chunks.push(chunk);
+        }
+        if (progressBar) {
+            progressBar.tick(chunk.length, "X");
+        }
+    }
+    const fileBuffer = Buffer.concat(chunks);
+    return fileBuffer;
+}
+export async function unzip(zipFile, extractPath, desc, bar = true) {
+    const zip = new AdmZip(zipFile);
+    const zipEntries = zip.getEntries();
+    if (bar) {
+        console.log(desc || 'Extracting files...');
+    }
+    for (const entry of zipEntries) {
+        if (bar) {
+            console.log(`Extracting ${entry.entryName}`);
+        }
+        zip.extractEntryTo(entry, extractPath, false, true);
+    }
+    if (bar) {
+        console.log('Extraction complete.');
+    }
+}
+export function loadYaml(file) {
+    let filePath = file;
+    if (!path.isAbsolute(file)) {
+        filePath = path.join(LOCAL_DATA.toString(), file);
+    }
+    const fileContents = fs.readFileSync(filePath, 'utf8');
+    return yaml.load(fileContents);
+}

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+import { BrowserServer } from 'playwright-core';
+import { LaunchOptions } from './utils.js';
+export declare function launchServer({ port, ws_path, ...options }: LaunchOptions | {
+    port?: number;
+    ws_path?: string;
+}): Promise<BrowserServer>;

package/dist/server.js

@@ -0,0 +1,9 @@
+import { firefox } from 'playwright-core';
+import { launchOptions } from './utils.js';
+export async function launchServer({ port, ws_path, ...options }) {
+    return firefox.launchServer({
+        ...await launchOptions(options),
+        port,
+        wsPath: ws_path,
+    });
+}

package/dist/sync_api.d.ts

@@ -0,0 +1,7 @@
+import { Browser, BrowserContext, BrowserType } from 'playwright-core';
+import { LaunchOptions } from './utils.js';
+export declare function Camoufox<UserDataDir extends string | undefined = undefined, ReturnType = UserDataDir extends string ? BrowserContext : Browser>(launch_options?: LaunchOptions | {
+    headless?: boolean | 'virtual';
+    user_data_dir: UserDataDir;
+}): Promise<ReturnType>;
+export declare function NewBrowser<UserDataDir extends string | false = false, ReturnType = UserDataDir extends string ? BrowserContext : Browser>(playwright: BrowserType<Browser>, headless?: boolean | 'virtual', fromOptions?: Record<string, any>, userDataDir?: UserDataDir, debug?: boolean, launch_options?: LaunchOptions): Promise<ReturnType>;