Initial commit - Dutchie dispensary scraper

backend/node_modules/playwright-extra/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 berstend <github@berstend.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backend/node_modules/playwright-extra/dist/extra.d.ts

@@ -0,0 +1,53 @@
+import type * as pw from 'playwright-core';
+import type { CompatiblePlugin } from './types';
+import { PluginList } from './plugins';
+declare type PlaywrightBrowserLauncher = pw.BrowserType;
+/**
+ * The Playwright browser launcher APIs we're augmenting
+ * @private
+ */
+interface AugmentedLauncherAPIs extends Pick<PlaywrightBrowserLauncher, 'launch' | 'launchPersistentContext' | 'connect' | 'connectOverCDP'> {
+}
+/**
+ * Modular plugin framework to teach `playwright` new tricks.
+ */
+export declare class PlaywrightExtraClass implements AugmentedLauncherAPIs {
+    private _launcher?;
+    /** Plugin manager */
+    readonly plugins: PluginList;
+    constructor(_launcher?: Partial<PlaywrightBrowserLauncher> | undefined);
+    /**
+     * The **main interface** to register plugins.
+     *
+     * Can be called multiple times to enable multiple plugins.
+     *
+     * Plugins derived from `PuppeteerExtraPlugin` will be used with a compatiblity layer.
+     *
+     * @example
+     * chromium.use(plugin1).use(plugin2)
+     * firefox.use(plugin1).use(plugin2)
+     *
+     * @see [PuppeteerExtraPlugin]
+     *
+     * @return The same `PlaywrightExtra` instance (for optional chaining)
+     */
+    use(plugin: CompatiblePlugin): this;
+    launch(...args: Parameters<PlaywrightBrowserLauncher['launch']>): ReturnType<PlaywrightBrowserLauncher['launch']>;
+    launchPersistentContext(...args: Parameters<PlaywrightBrowserLauncher['launchPersistentContext']>): ReturnType<PlaywrightBrowserLauncher['launchPersistentContext']>;
+    connect(wsEndpointOrOptions: string | (pw.ConnectOptions & {
+        wsEndpoint?: string;
+    }), wsOptions?: pw.ConnectOptions): ReturnType<PlaywrightBrowserLauncher['connect']>;
+    connectOverCDP(wsEndpointOrOptions: string | (pw.ConnectOverCDPOptions & {
+        endpointURL?: string;
+    }), wsOptions?: pw.ConnectOverCDPOptions): ReturnType<PlaywrightBrowserLauncher['connectOverCDP']>;
+    protected _bindBrowserContextEvents(context: pw.BrowserContext, contextOptions?: pw.BrowserContextOptions): Promise<void>;
+    protected _bindBrowserEvents(browser: pw.Browser): Promise<void>;
+}
+/**
+ * PlaywrightExtra class with additional launcher methods.
+ *
+ * Augments the class with an instance proxy to pass on methods that are not augmented to the original target.
+ *
+ */
+export declare const PlaywrightExtra: typeof PlaywrightExtraClass;
+export {};

backend/node_modules/playwright-extra/dist/extra.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightExtra = exports.PlaywrightExtraClass = void 0;
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('playwright-extra');
+const plugins_1 = require("./plugins");
+const loader_1 = require("./helper/loader");
+/**
+ * Modular plugin framework to teach `playwright` new tricks.
+ */
+class PlaywrightExtraClass {
+    constructor(_launcher) {
+        this._launcher = _launcher;
+        this.plugins = new plugins_1.PluginList();
+    }
+    /**
+     * The **main interface** to register plugins.
+     *
+     * Can be called multiple times to enable multiple plugins.
+     *
+     * Plugins derived from `PuppeteerExtraPlugin` will be used with a compatiblity layer.
+     *
+     * @example
+     * chromium.use(plugin1).use(plugin2)
+     * firefox.use(plugin1).use(plugin2)
+     *
+     * @see [PuppeteerExtraPlugin]
+     *
+     * @return The same `PlaywrightExtra` instance (for optional chaining)
+     */
+    use(plugin) {
+        const isValid = plugin && 'name' in plugin;
+        if (!isValid) {
+            throw new Error('A plugin must be provided to .use()');
+        }
+        if (this.plugins.add(plugin)) {
+            debug('Plugin registered', plugin.name);
+        }
+        return this;
+    }
+    /**
+     * In order to support a default export which will require vanilla playwright automatically,
+     * as well as `addExtra` to patch a provided launcher, we need to so some gymnastics here.
+     *
+     * Otherwise this would throw immediately, even when only using the `addExtra` export with an arbitrary compatible launcher.
+     *
+     * The solution is to make the vanilla launcher optional and only throw once we try to effectively use and can't find it.
+     *
+     * @internal
+     */
+    get launcher() {
+        if (!this._launcher) {
+            throw loader_1.playwrightLoader.requireError;
+        }
+        return this._launcher;
+    }
+    async launch(...args) {
+        if (!this.launcher.launch) {
+            throw new Error('Launcher does not support "launch"');
+        }
+        let [options] = args;
+        options = Object.assign({ args: [] }, (options || {})); // Initialize args array
+        debug('launch', options);
+        this.plugins.prepare();
+        // Give plugins the chance to modify the options before continuing
+        options =
+            (await this.plugins.dispatchBlocking('beforeLaunch', options)) || options;
+        debug('launch with options', options);
+        if ('userDataDir' in options) {
+            debug("A plugin defined userDataDir during .launch, which isn't supported by playwright - ignoring");
+            delete options.userDataDir;
+        }
+        const browser = await this.launcher['launch'](options);
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterLaunch', browser);
+        return browser;
+    }
+    async launchPersistentContext(...args) {
+        if (!this.launcher.launchPersistentContext) {
+            throw new Error('Launcher does not support "launchPersistentContext"');
+        }
+        let [userDataDir, options] = args;
+        options = Object.assign({ args: [] }, (options || {})); // Initialize args array
+        debug('launchPersistentContext', options);
+        this.plugins.prepare();
+        // Give plugins the chance to modify the options before continuing
+        options =
+            (await this.plugins.dispatchBlocking('beforeLaunch', options)) || options;
+        const context = await this.launcher['launchPersistentContext'](userDataDir, options);
+        await this.plugins.dispatchBlocking('afterLaunch', context);
+        this._bindBrowserContextEvents(context);
+        return context;
+    }
+    async connect(wsEndpointOrOptions, wsOptions = {}) {
+        if (!this.launcher.connect) {
+            throw new Error('Launcher does not support "connect"');
+        }
+        this.plugins.prepare();
+        // Playwright currently supports two function signatures for .connect
+        let options = {};
+        let wsEndpointAsString = false;
+        if (typeof wsEndpointOrOptions === 'object') {
+            options = Object.assign(Object.assign({}, wsEndpointOrOptions), wsOptions);
+        }
+        else {
+            wsEndpointAsString = true;
+            options = Object.assign({ wsEndpoint: wsEndpointOrOptions }, wsOptions);
+        }
+        debug('connect', options);
+        // Give plugins the chance to modify the options before launch/connect
+        options =
+            (await this.plugins.dispatchBlocking('beforeConnect', options)) || options;
+        // Follow call signature of end user
+        const args = [];
+        const wsEndpoint = options.wsEndpoint;
+        if (wsEndpointAsString) {
+            delete options.wsEndpoint;
+            args.push(wsEndpoint, options);
+        }
+        else {
+            args.push(options);
+        }
+        const browser = (await this.launcher['connect'](...args));
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterConnect', browser);
+        return browser;
+    }
+    async connectOverCDP(wsEndpointOrOptions, wsOptions = {}) {
+        if (!this.launcher.connectOverCDP) {
+            throw new Error(`Launcher does not implement 'connectOverCDP'`);
+        }
+        this.plugins.prepare();
+        // Playwright currently supports two function signatures for .connectOverCDP
+        let options = {};
+        let wsEndpointAsString = false;
+        if (typeof wsEndpointOrOptions === 'object') {
+            options = Object.assign(Object.assign({}, wsEndpointOrOptions), wsOptions);
+        }
+        else {
+            wsEndpointAsString = true;
+            options = Object.assign({ endpointURL: wsEndpointOrOptions }, wsOptions);
+        }
+        debug('connectOverCDP'), options;
+        // Give plugins the chance to modify the options before launch/connect
+        options =
+            (await this.plugins.dispatchBlocking('beforeConnect', options)) || options;
+        // Follow call signature of end user
+        const args = [];
+        const endpointURL = options.endpointURL;
+        if (wsEndpointAsString) {
+            delete options.endpointURL;
+            args.push(endpointURL, options);
+        }
+        else {
+            args.push(options);
+        }
+        const browser = (await this.launcher['connectOverCDP'](...args));
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterConnect', browser);
+        return browser;
+    }
+    async _bindBrowserContextEvents(context, contextOptions) {
+        debug('_bindBrowserContextEvents');
+        this.plugins.dispatch('onContextCreated', context, contextOptions);
+        // Make sure things like `addInitScript` show an effect on the very first page as well
+        context.newPage = ((originalMethod, ctx) => {
+            return async () => {
+                const page = await originalMethod.call(ctx);
+                await page.goto('about:blank');
+                return page;
+            };
+        })(context.newPage, context);
+        context.on('close', () => {
+            // When using `launchPersistentContext` context closing is the same as browser closing
+            if (!context.browser()) {
+                this.plugins.dispatch('onDisconnected');
+            }
+        });
+        context.on('page', page => {
+            this.plugins.dispatch('onPageCreated', page);
+            page.on('close', () => {
+                this.plugins.dispatch('onPageClose', page);
+            });
+        });
+    }
+    async _bindBrowserEvents(browser) {
+        debug('_bindPlaywrightBrowserEvents');
+        browser.on('disconnected', () => {
+            this.plugins.dispatch('onDisconnected', browser);
+        });
+        // Note: `browser.newPage` will implicitly call `browser.newContext` as well
+        browser.newContext = ((originalMethod, ctx) => {
+            return async (options = {}) => {
+                const contextOptions = (await this.plugins.dispatchBlocking('beforeContext', options, browser)) || options;
+                const context = await originalMethod.call(ctx, contextOptions);
+                this._bindBrowserContextEvents(context, contextOptions);
+                return context;
+            };
+        })(browser.newContext, browser);
+    }
+}
+exports.PlaywrightExtraClass = PlaywrightExtraClass;
+/**
+ * PlaywrightExtra class with additional launcher methods.
+ *
+ * Augments the class with an instance proxy to pass on methods that are not augmented to the original target.
+ *
+ */
+exports.PlaywrightExtra = new Proxy(PlaywrightExtraClass, {
+    construct(classTarget, args) {
+        debug(`create instance of ${classTarget.name}`);
+        const result = Reflect.construct(classTarget, args);
+        return new Proxy(result, {
+            get(target, prop) {
+                if (prop in target) {
+                    return Reflect.get(target, prop);
+                }
+                debug('proxying property to original launcher: ', prop);
+                return Reflect.get(target.launcher, prop);
+            }
+        });
+    }
+});
+//# sourceMappingURL=extra.js.map

backend/node_modules/playwright-extra/dist/helper/loader.d.ts

@@ -0,0 +1,26 @@
+import type * as pw from 'playwright-core';
+/** Node.js module loader helper */
+export declare class Loader<TargetModule> {
+    moduleName: string;
+    packageNames: string[];
+    constructor(moduleName: string, packageNames: string[]);
+    /**
+     * Lazy load a top level export from another module by wrapping it in a JS proxy.
+     *
+     * This allows us to re-export e.g. `devices` from `playwright` while redirecting direct calls
+     * to it to the module version the user has installed, rather than shipping with a hardcoded version.
+     *
+     * If we don't do this and the user doesn't have the target module installed we'd throw immediately when our code is imported.
+     *
+     * We use a "super" Proxy defining all traps, so calls like `Object.keys(playwright.devices).length` will return the correct value.
+     */
+    lazyloadExportOrDie<T extends keyof TargetModule>(exportName: T): TargetModule[T];
+    /** Load the module if possible */
+    loadModule(): TargetModule | undefined;
+    /** Load the module if possible or throw */
+    loadModuleOrDie(): TargetModule;
+    get requireError(): Error;
+}
+export declare function requirePackages<TargetModule = any>(packageNames: string[]): TargetModule | undefined;
+/** Playwright specific module loader */
+export declare const playwrightLoader: Loader<typeof pw>;

backend/node_modules/playwright-extra/dist/helper/loader.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playwrightLoader = exports.requirePackages = exports.Loader = void 0;
+/** Node.js module loader helper */
+class Loader {
+    constructor(moduleName, packageNames) {
+        this.moduleName = moduleName;
+        this.packageNames = packageNames;
+    }
+    /**
+     * Lazy load a top level export from another module by wrapping it in a JS proxy.
+     *
+     * This allows us to re-export e.g. `devices` from `playwright` while redirecting direct calls
+     * to it to the module version the user has installed, rather than shipping with a hardcoded version.
+     *
+     * If we don't do this and the user doesn't have the target module installed we'd throw immediately when our code is imported.
+     *
+     * We use a "super" Proxy defining all traps, so calls like `Object.keys(playwright.devices).length` will return the correct value.
+     */
+    lazyloadExportOrDie(exportName) {
+        const that = this;
+        const trapHandler = Object.fromEntries(Object.getOwnPropertyNames(Reflect).map((name) => [
+            name,
+            function (target, ...args) {
+                const moduleExport = that.loadModuleOrDie()[exportName];
+                const customTarget = moduleExport;
+                const result = Reflect[name](customTarget || target, ...args);
+                return result;
+            }
+        ]));
+        return new Proxy({}, trapHandler);
+    }
+    /** Load the module if possible */
+    loadModule() {
+        return requirePackages(this.packageNames);
+    }
+    /** Load the module if possible or throw */
+    loadModuleOrDie() {
+        const module = requirePackages(this.packageNames);
+        if (module) {
+            return module;
+        }
+        throw this.requireError;
+    }
+    get requireError() {
+        const moduleNamePretty = this.moduleName.charAt(0).toUpperCase() + this.moduleName.slice(1);
+        return new Error(`
+  ${moduleNamePretty} is missing. :-)
+
+  I've tried loading ${this.packageNames
+            .map(p => `"${p}"`)
+            .join(', ')} - no luck.
+
+  Make sure you install one of those packages or use the named 'addExtra' export,
+  to patch a specific (and maybe non-standard) implementation of ${moduleNamePretty}.
+
+  To get the latest stable version of ${moduleNamePretty} run:
+  'yarn add ${this.moduleName}' or 'npm i ${this.moduleName}'
+  `);
+    }
+}
+exports.Loader = Loader;
+function requirePackages(packageNames) {
+    for (const name of packageNames) {
+        try {
+            return require(name);
+        }
+        catch (_) {
+            continue; // noop
+        }
+    }
+    return;
+}
+exports.requirePackages = requirePackages;
+/** Playwright specific module loader */
+exports.playwrightLoader = new Loader('playwright', [
+    'playwright-core',
+    'playwright'
+]);
+//# sourceMappingURL=loader.js.map

backend/node_modules/playwright-extra/dist/helper/loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.js","sourceRoot":"","sources":["../../src/helper/loader.ts"],"names":[],"mappings":";;;AAEA,mCAAmC;AACnC,MAAa,MAAM;IACjB,YAAmB,UAAkB,EAAS,YAAsB;QAAjD,eAAU,GAAV,UAAU,CAAQ;QAAS,iBAAY,GAAZ,YAAY,CAAU;IAAG,CAAC;IAExE;;;;;;;;;OASG;IACI,mBAAmB,CAA+B,UAAa;QACpE,MAAM,IAAI,GAAG,IAAI,CAAA;QACjB,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CACpC,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC;YACrD,IAAI;YACJ,UAAU,MAAW,EAAE,GAAG,IAAW;gBACnC,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC,UAAU,CAAC,CAAA;gBACvD,MAAM,YAAY,GAAG,YAAmB,CAAA;gBACxC,MAAM,MAAM,GAAK,OAAe,CAAC,IAAI,CAAS,CAC5C,YAAY,IAAI,MAAM,EACtB,GAAG,IAAI,CACR,CAAA;gBACD,OAAO,MAAM,CAAA;YACf,CAAC;SACF,CAAC,CACH,CAAA;QACD,OAAO,IAAI,KAAK,CAAC,EAAE,EAAE,WAAW,CAAoB,CAAA;IACtD,CAAC;IAED,kCAAkC;IAC3B,UAAU;QACf,OAAO,eAAe,CAAe,IAAI,CAAC,YAAY,CAAC,CAAA;IACzD,CAAC;IAED,2CAA2C;IACpC,eAAe;QACpB,MAAM,MAAM,GAAG,eAAe,CAAe,IAAI,CAAC,YAAY,CAAC,CAAA;QAC/D,IAAI,MAAM,EAAE;YACV,OAAO,MAAM,CAAA;SACd;QACD,MAAM,IAAI,CAAC,YAAY,CAAA;IACzB,CAAC;IAED,IAAW,YAAY;QACrB,MAAM,gBAAgB,GACpB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QACpE,OAAO,IAAI,KAAK,CAAC;IACjB,gBAAgB;;uBAEG,IAAI,CAAC,YAAY;aACnC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;aAClB,IAAI,CAAC,IAAI,CAAC;;;mEAGoD,gBAAgB;;wCAE3C,gBAAgB;cAC1C,IAAI,CAAC,UAAU,eAAe,IAAI,CAAC,UAAU;GACxD,CAAC,CAAA;IACF,CAAC;CACF;AA/DD,wBA+DC;AAED,SAAgB,eAAe,CAAqB,YAAsB;IACxE,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE;QAC/B,IAAI;YACF,OAAO,OAAO,CAAC,IAAI,CAAiB,CAAA;SACrC;QAAC,OAAO,CAAC,EAAE;YACV,SAAQ,CAAC,OAAO;SACjB;KACF;IACD,OAAM;AACR,CAAC;AATD,0CASC;AAED,wCAAwC;AAC3B,QAAA,gBAAgB,GAAG,IAAI,MAAM,CAAY,YAAY,EAAE;IAClE,iBAAiB;IACjB,YAAY;CACb,CAAC,CAAA"}

backend/node_modules/playwright-extra/dist/index.cjs.js

@@ -0,0 +1,934 @@
+/*!
+ * playwright-extra v4.3.5 by berstend
+ * https://github.com/berstend/puppeteer-extra/tree/master/packages/playwright-extra#readme
+ * @license MIT
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var Debug = _interopDefault(require('debug'));
+
+/** Node.js module loader helper */
+class Loader {
+    constructor(moduleName, packageNames) {
+        this.moduleName = moduleName;
+        this.packageNames = packageNames;
+    }
+    /**
+     * Lazy load a top level export from another module by wrapping it in a JS proxy.
+     *
+     * This allows us to re-export e.g. `devices` from `playwright` while redirecting direct calls
+     * to it to the module version the user has installed, rather than shipping with a hardcoded version.
+     *
+     * If we don't do this and the user doesn't have the target module installed we'd throw immediately when our code is imported.
+     *
+     * We use a "super" Proxy defining all traps, so calls like `Object.keys(playwright.devices).length` will return the correct value.
+     */
+    lazyloadExportOrDie(exportName) {
+        const that = this;
+        const trapHandler = Object.fromEntries(Object.getOwnPropertyNames(Reflect).map((name) => [
+            name,
+            function (target, ...args) {
+                const moduleExport = that.loadModuleOrDie()[exportName];
+                const customTarget = moduleExport;
+                const result = Reflect[name](customTarget || target, ...args);
+                return result;
+            }
+        ]));
+        return new Proxy({}, trapHandler);
+    }
+    /** Load the module if possible */
+    loadModule() {
+        return requirePackages(this.packageNames);
+    }
+    /** Load the module if possible or throw */
+    loadModuleOrDie() {
+        const module = requirePackages(this.packageNames);
+        if (module) {
+            return module;
+        }
+        throw this.requireError;
+    }
+    get requireError() {
+        const moduleNamePretty = this.moduleName.charAt(0).toUpperCase() + this.moduleName.slice(1);
+        return new Error(`
+  ${moduleNamePretty} is missing. :-)
+
+  I've tried loading ${this.packageNames
+            .map(p => `"${p}"`)
+            .join(', ')} - no luck.
+
+  Make sure you install one of those packages or use the named 'addExtra' export,
+  to patch a specific (and maybe non-standard) implementation of ${moduleNamePretty}.
+
+  To get the latest stable version of ${moduleNamePretty} run:
+  'yarn add ${this.moduleName}' or 'npm i ${this.moduleName}'
+  `);
+    }
+}
+function requirePackages(packageNames) {
+    for (const name of packageNames) {
+        try {
+            return require(name);
+        }
+        catch (_) {
+            continue; // noop
+        }
+    }
+    return;
+}
+/** Playwright specific module loader */
+const playwrightLoader = new Loader('playwright', [
+    'playwright-core',
+    'playwright'
+]);
+
+const debug = Debug('playwright-extra:puppeteer-compat');
+const isPlaywrightPage = (obj) => {
+    return 'unroute' in obj;
+};
+const isPlaywrightFrame = (obj) => {
+    return ['parentFrame', 'frameLocator'].every(x => x in obj);
+};
+const isPlaywrightBrowser = (obj) => {
+    return 'newContext' in obj;
+};
+const isPuppeteerCompat = (obj) => {
+    return !!obj && typeof obj === 'object' && !!obj.isCompatShim;
+};
+const cache = {
+    objectToShim: new Map(),
+    cdpSession: {
+        page: new Map(),
+        browser: new Map()
+    }
+};
+/** Augment a Playwright object with compatibility with certain Puppeteer methods */
+function addPuppeteerCompat(object) {
+    if (!object || typeof object !== 'object') {
+        return object;
+    }
+    if (cache.objectToShim.has(object)) {
+        return cache.objectToShim.get(object);
+    }
+    if (isPuppeteerCompat(object)) {
+        return object;
+    }
+    debug('addPuppeteerCompat', cache.objectToShim.size);
+    if (isPlaywrightPage(object) || isPlaywrightFrame(object)) {
+        const shim = createPageShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    if (isPlaywrightBrowser(object)) {
+        const shim = createBrowserShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    debug('Received unknown object:', Reflect.ownKeys(object));
+    return object;
+}
+// Only chromium browsers support CDP
+const dummyCDPClient = {
+    send: async (...args) => {
+        debug('dummy CDP client called', 'send', args);
+    },
+    on: (...args) => {
+        debug('dummy CDP client called', 'on', args);
+    }
+};
+async function getPageCDPSession(page) {
+    let session = cache.cdpSession.page.get(page);
+    if (session) {
+        debug('getPageCDPSession: use existing');
+        return session;
+    }
+    debug('getPageCDPSession: use new');
+    const context = isPlaywrightFrame(page)
+        ? page.page().context()
+        : page.context();
+    try {
+        session = await context.newCDPSession(page);
+        cache.cdpSession.page.set(page, session);
+        return session;
+    }
+    catch (err) {
+        debug('getPageCDPSession: error while creating session:', err.message);
+        debug('getPageCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+async function getBrowserCDPSession(browser) {
+    let session = cache.cdpSession.browser.get(browser);
+    if (session) {
+        debug('getBrowserCDPSession: use existing');
+        return session;
+    }
+    debug('getBrowserCDPSession: use new');
+    try {
+        session = await browser.newBrowserCDPSession();
+        cache.cdpSession.browser.set(browser, session);
+        return session;
+    }
+    catch (err) {
+        debug('getBrowserCDPSession: error while creating session:', err.message);
+        debug('getBrowserCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+function createPageShim(page) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(page, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('page - get', objId, prop);
+            if (prop === '_client') {
+                return () => ({
+                    send: async (method, params) => {
+                        const session = await getPageCDPSession(page);
+                        return await session.send(method, params);
+                    },
+                    on: (event, listener) => {
+                        getPageCDPSession(page).then(session => {
+                            session.on(event, listener);
+                        });
+                    }
+                });
+            }
+            if (prop === 'setBypassCSP') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Page.setBypassCSP', {
+                        enabled
+                    });
+                };
+            }
+            if (prop === 'setUserAgent') {
+                return async (userAgent, userAgentMetadata) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Emulation.setUserAgentOverride', {
+                        userAgent,
+                        userAgentMetadata
+                    });
+                };
+            }
+            if (prop === 'browser') {
+                if (isPlaywrightPage(page)) {
+                    return () => {
+                        let browser = page.context().browser();
+                        if (!browser) {
+                            debug('page.browser() - not available, most likely due to launchPersistentContext');
+                            // Use a page shim as quick drop-in (so browser.userAgent() still works)
+                            browser = page;
+                        }
+                        return addPuppeteerCompat(browser);
+                    };
+                }
+            }
+            if (prop === 'evaluateOnNewDocument') {
+                if (isPlaywrightPage(page)) {
+                    return async function (pageFunction, ...args) {
+                        return await page.addInitScript(pageFunction, args[0]);
+                    };
+                }
+            }
+            // Only relevant when page is being used a pseudo stand-in for the browser object (launchPersistentContext)
+            if (prop === 'userAgent') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+function createBrowserShim(browser) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(browser, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('browser - get', objId, prop);
+            if (prop === 'pages') {
+                return () => browser
+                    .contexts()
+                    .flatMap(c => c.pages().map(page => addPuppeteerCompat(page)));
+            }
+            if (prop === 'userAgent') {
+                return async () => {
+                    const session = await getBrowserCDPSession(browser);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+
+const debug$1 = Debug('playwright-extra:plugins');
+class PluginList {
+    constructor() {
+        this._plugins = [];
+        this._dependencyDefaults = new Map();
+        this._dependencyResolution = new Map();
+    }
+    /**
+     * Get a list of all registered plugins.
+     */
+    get list() {
+        return this._plugins;
+    }
+    /**
+     * Get the names of all registered plugins.
+     */
+    get names() {
+        return this._plugins.map(p => p.name);
+    }
+    /**
+     * Add a new plugin to the list (after checking if it's well-formed).
+     *
+     * @param plugin
+     * @internal
+     */
+    add(plugin) {
+        var _a;
+        if (!this.isValidPluginInstance(plugin)) {
+            return false;
+        }
+        if (!!plugin.onPluginRegistered) {
+            plugin.onPluginRegistered({ framework: 'playwright' });
+        }
+        // PuppeteerExtraPlugin: Populate `_childClassMembers` list containing methods defined by the plugin
+        if (!!plugin._registerChildClassMembers) {
+            plugin._registerChildClassMembers(Object.getPrototypeOf(plugin));
+        }
+        if ((_a = plugin.requirements) === null || _a === void 0 ? void 0 : _a.has('dataFromPlugins')) {
+            plugin.getDataFromPlugins = this.getData.bind(this);
+        }
+        this._plugins.push(plugin);
+        return true;
+    }
+    /** Check if the shape of a plugin is correct or warn */
+    isValidPluginInstance(plugin) {
+        if (!plugin ||
+            typeof plugin !== 'object' ||
+            !plugin._isPuppeteerExtraPlugin) {
+            console.error(`Warning: Plugin is not derived from PuppeteerExtraPlugin, ignoring.`, plugin);
+            return false;
+        }
+        if (!plugin.name) {
+            console.error(`Warning: Plugin with no name registering, ignoring.`, plugin);
+            return false;
+        }
+        return true;
+    }
+    /** Error callback in case calling a plugin method throws an error. Can be overwritten. */
+    onPluginError(plugin, method, err) {
+        console.warn(`An error occured while executing "${method}" in plugin "${plugin.name}":`, err);
+    }
+    /**
+     * Define default values for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * @param dependencyPath - The string by which the dependency is listed (not the plugin name)
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyDefaults('stealth/evasions/webgl.vendor', { vendor: 'Bob', renderer: 'Alice' })
+     */
+    setDependencyDefaults(dependencyPath, opts) {
+        this._dependencyDefaults.set(dependencyPath, opts);
+        return this;
+    }
+    /**
+     * Define custom plugin modules for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * Using this will prevent dynamic imports from being used, which JS bundlers often have issues with.
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyResolution('stealth/evasions/webgl.vendor', VendorPlugin)
+     */
+    setDependencyResolution(dependencyPath, pluginModule) {
+        this._dependencyResolution.set(dependencyPath, pluginModule);
+        return this;
+    }
+    /**
+     * Prepare plugins to be used (resolve dependencies, ordering)
+     * @internal
+     */
+    prepare() {
+        this.resolveDependencies();
+        this.order();
+    }
+    /** Return all plugins using the supplied method */
+    filterByMethod(methodName) {
+        return this._plugins.filter(plugin => {
+            // PuppeteerExtraPlugin: The base class will already define all methods, hence we need to do a different check
+            if (!!plugin._childClassMembers &&
+                Array.isArray(plugin._childClassMembers)) {
+                return plugin._childClassMembers.includes(methodName);
+            }
+            return methodName in plugin;
+        });
+    }
+    /** Conditionally add puppeteer compatibility to values provided to the plugins */
+    _addPuppeteerCompatIfNeeded(plugin, method, args) {
+        const canUseShim = plugin._isPuppeteerExtraPlugin && !plugin.noPuppeteerShim;
+        const methodWhitelist = [
+            'onBrowser',
+            'onPageCreated',
+            'onPageClose',
+            'afterConnect',
+            'afterLaunch'
+        ];
+        const shouldUseShim = methodWhitelist.includes(method);
+        if (!canUseShim || !shouldUseShim) {
+            return args;
+        }
+        debug$1('add puppeteer compatibility', plugin.name, method);
+        return [...args.map(arg => addPuppeteerCompat(arg))];
+    }
+    /**
+     * Dispatch plugin lifecycle events in a typesafe way.
+     * Only Plugins that expose the supplied property will be called.
+     *
+     * Will not await results to dispatch events as fast as possible to all plugins.
+     *
+     * @param method - The lifecycle method name
+     * @param args - Optional: Any arguments to be supplied to the plugin methods
+     * @internal
+     */
+    dispatch(method, ...args) {
+        var _a, _b;
+        const plugins = this.filterByMethod(method);
+        debug$1('dispatch', method, {
+            all: this._plugins.length,
+            filteredByMethod: plugins.length
+        });
+        for (const plugin of plugins) {
+            try {
+                args = this._addPuppeteerCompatIfNeeded.bind(this)(plugin, method, args);
+                const fnType = (_b = (_a = plugin[method]) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name;
+                debug$1('dispatch to plugin', {
+                    plugin: plugin.name,
+                    method,
+                    fnType
+                });
+                if (fnType === 'AsyncFunction') {
+                    ;
+                    plugin[method](...args).catch((err) => this.onPluginError(plugin, method, err));
+                }
+                else {
+                    ;
+                    plugin[method](...args);
+                }
+            }
+            catch (err) {
+                this.onPluginError(plugin, method, err);
+            }
+        }
+    }
+    /**
+     * Dispatch plugin lifecycle events in a typesafe way.
+     * Only Plugins that expose the supplied property will be called.
+     *
+     * Can also be used to get a definite return value after passing it to plugins:
+     * Calls plugins sequentially and passes on a value (waterfall style).
+     *
+     * The plugins can either modify the value or return an updated one.
+     * Will return the latest, updated value which ran through all plugins.
+     *
+     * By convention only the first argument will be used as the updated value.
+     *
+     * @param method - The lifecycle method name
+     * @param args - Optional: Any arguments to be supplied to the plugin methods
+     * @internal
+     */
+    async dispatchBlocking(method, ...args) {
+        const plugins = this.filterByMethod(method);
+        debug$1('dispatchBlocking', method, {
+            all: this._plugins.length,
+            filteredByMethod: plugins.length
+        });
+        let retValue = null;
+        for (const plugin of plugins) {
+            try {
+                args = this._addPuppeteerCompatIfNeeded.bind(this)(plugin, method, args);
+                retValue = await plugin[method](...args);
+                // In case we got a return value use that as new first argument for followup function calls
+                if (retValue !== undefined) {
+                    args[0] = retValue;
+                }
+            }
+            catch (err) {
+                this.onPluginError(plugin, method, err);
+                return retValue;
+            }
+        }
+        return retValue;
+    }
+    /**
+     * Order plugins that have expressed a special placement requirement.
+     *
+     * This is useful/necessary for e.g. plugins that depend on the data from other plugins.
+     *
+     * @private
+     */
+    order() {
+        debug$1('order:before', this.names);
+        const runLast = this._plugins
+            .filter(p => { var _a; return (_a = p.requirements) === null || _a === void 0 ? void 0 : _a.has('runLast'); })
+            .map(p => p.name);
+        for (const name of runLast) {
+            const index = this._plugins.findIndex(p => p.name === name);
+            this._plugins.push(this._plugins.splice(index, 1)[0]);
+        }
+        debug$1('order:after', this.names);
+    }
+    /**
+     * Collects the exposed `data` property of all registered plugins.
+     * Will be reduced/flattened to a single array.
+     *
+     * Can be accessed by plugins that listed the `dataFromPlugins` requirement.
+     *
+     * Implemented mainly for plugins that need data from other plugins (e.g. `user-preferences`).
+     *
+     * @see [PuppeteerExtraPlugin]/data
+     * @param name - Filter data by optional name
+     *
+     * @private
+     */
+    getData(name) {
+        const data = this._plugins
+            .filter((p) => !!p.data)
+            .map((p) => (Array.isArray(p.data) ? p.data : [p.data]))
+            .reduce((acc, arr) => [...acc, ...arr], []);
+        return name ? data.filter((d) => d.name === name) : data;
+    }
+    /**
+     * Handle `plugins` stanza (already instantiated plugins that don't require dynamic imports)
+     */
+    resolvePluginsStanza() {
+        debug$1('resolvePluginsStanza');
+        const pluginNames = new Set(this.names);
+        this._plugins
+            .filter(p => !!p.plugins && p.plugins.length)
+            .filter(p => !pluginNames.has(p.name)) // TBD: Do we want to filter out existing?
+            .forEach(parent => {
+            (parent.plugins || []).forEach(p => {
+                debug$1(parent.name, 'adding missing plugin', p.name);
+                this.add(p);
+            });
+        });
+    }
+    /**
+     * Handle `dependencies` stanza (which requires dynamic imports)
+     *
+     * Plugins can define `dependencies` as a Set or Array of dependency paths, or a Map with additional opts
+     *
+     * @note
+     * - The default opts for implicit dependencies can be defined using `setDependencyDefaults()`
+     * - Dynamic imports can be avoided by providing plugin modules with `setDependencyResolution()`
+     */
+    resolveDependenciesStanza() {
+        debug$1('resolveDependenciesStanza');
+        /** Attempt to dynamically require a plugin module */
+        const requireDependencyOrDie = (parentName, dependencyPath) => {
+            // If the user provided the plugin module already we use that
+            if (this._dependencyResolution.has(dependencyPath)) {
+                return this._dependencyResolution.get(dependencyPath);
+            }
+            const possiblePrefixes = ['puppeteer-extra-plugin-']; // could be extended later
+            const isAlreadyPrefixed = possiblePrefixes.some(prefix => dependencyPath.startsWith(prefix));
+            const packagePaths = [];
+            // If the dependency is not already prefixed we attempt to require all possible combinations to find one that works
+            if (!isAlreadyPrefixed) {
+                packagePaths.push(...possiblePrefixes.map(prefix => prefix + dependencyPath));
+            }
+            // We always attempt to require the path verbatim (as a last resort)
+            packagePaths.push(dependencyPath);
+            const pluginModule = requirePackages(packagePaths);
+            if (pluginModule) {
+                return pluginModule;
+            }
+            const explanation = `
+The plugin '${parentName}' listed '${dependencyPath}' as dependency,
+which could not be found. Please install it:
+
+${packagePaths
+                .map(packagePath => `yarn add ${packagePath.split('/')[0]}`)
+                .join(`\n or:\n`)}
+
+Note: You don't need to require the plugin yourself,
+unless you want to modify it's default settings.
+
+If your bundler has issues with dynamic imports take a look at '.plugins.setDependencyResolution()'.
+      `;
+            console.warn(explanation);
+            throw new Error('Plugin dependency not found');
+        };
+        const existingPluginNames = new Set(this.names);
+        const recursivelyLoadMissingDependencies = ({ name: parentName, dependencies }) => {
+            if (!dependencies) {
+                return;
+            }
+            const processDependency = (dependencyPath, opts) => {
+                const pluginModule = requireDependencyOrDie(parentName, dependencyPath);
+                opts = opts || this._dependencyDefaults.get(dependencyPath) || {};
+                const plugin = pluginModule(opts);
+                if (existingPluginNames.has(plugin.name)) {
+                    debug$1(parentName, '=> dependency already exists:', plugin.name);
+                    return;
+                }
+                existingPluginNames.add(plugin.name);
+                debug$1(parentName, '=> adding new dependency:', plugin.name, opts);
+                this.add(plugin);
+                return recursivelyLoadMissingDependencies(plugin);
+            };
+            if (dependencies instanceof Set || Array.isArray(dependencies)) {
+                return [...dependencies].forEach(dependencyPath => processDependency(dependencyPath));
+            }
+            if (dependencies instanceof Map) {
+                // Note: `k,v => v,k` (Map + forEach will reverse the order)
+                return dependencies.forEach((v, k) => processDependency(k, v));
+            }
+        };
+        this.list.forEach(recursivelyLoadMissingDependencies);
+    }
+    /**
+     * Lightweight plugin dependency management to require plugins and code mods on demand.
+     * @private
+     */
+    resolveDependencies() {
+        debug$1('resolveDependencies');
+        this.resolvePluginsStanza();
+        this.resolveDependenciesStanza();
+    }
+}
+
+const debug$2 = Debug('playwright-extra');
+/**
+ * Modular plugin framework to teach `playwright` new tricks.
+ */
+class PlaywrightExtraClass {
+    constructor(_launcher) {
+        this._launcher = _launcher;
+        this.plugins = new PluginList();
+    }
+    /**
+     * The **main interface** to register plugins.
+     *
+     * Can be called multiple times to enable multiple plugins.
+     *
+     * Plugins derived from `PuppeteerExtraPlugin` will be used with a compatiblity layer.
+     *
+     * @example
+     * chromium.use(plugin1).use(plugin2)
+     * firefox.use(plugin1).use(plugin2)
+     *
+     * @see [PuppeteerExtraPlugin]
+     *
+     * @return The same `PlaywrightExtra` instance (for optional chaining)
+     */
+    use(plugin) {
+        const isValid = plugin && 'name' in plugin;
+        if (!isValid) {
+            throw new Error('A plugin must be provided to .use()');
+        }
+        if (this.plugins.add(plugin)) {
+            debug$2('Plugin registered', plugin.name);
+        }
+        return this;
+    }
+    /**
+     * In order to support a default export which will require vanilla playwright automatically,
+     * as well as `addExtra` to patch a provided launcher, we need to so some gymnastics here.
+     *
+     * Otherwise this would throw immediately, even when only using the `addExtra` export with an arbitrary compatible launcher.
+     *
+     * The solution is to make the vanilla launcher optional and only throw once we try to effectively use and can't find it.
+     *
+     * @internal
+     */
+    get launcher() {
+        if (!this._launcher) {
+            throw playwrightLoader.requireError;
+        }
+        return this._launcher;
+    }
+    async launch(...args) {
+        if (!this.launcher.launch) {
+            throw new Error('Launcher does not support "launch"');
+        }
+        let [options] = args;
+        options = Object.assign({ args: [] }, (options || {})); // Initialize args array
+        debug$2('launch', options);
+        this.plugins.prepare();
+        // Give plugins the chance to modify the options before continuing
+        options =
+            (await this.plugins.dispatchBlocking('beforeLaunch', options)) || options;
+        debug$2('launch with options', options);
+        if ('userDataDir' in options) {
+            debug$2("A plugin defined userDataDir during .launch, which isn't supported by playwright - ignoring");
+            delete options.userDataDir;
+        }
+        const browser = await this.launcher['launch'](options);
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterLaunch', browser);
+        return browser;
+    }
+    async launchPersistentContext(...args) {
+        if (!this.launcher.launchPersistentContext) {
+            throw new Error('Launcher does not support "launchPersistentContext"');
+        }
+        let [userDataDir, options] = args;
+        options = Object.assign({ args: [] }, (options || {})); // Initialize args array
+        debug$2('launchPersistentContext', options);
+        this.plugins.prepare();
+        // Give plugins the chance to modify the options before continuing
+        options =
+            (await this.plugins.dispatchBlocking('beforeLaunch', options)) || options;
+        const context = await this.launcher['launchPersistentContext'](userDataDir, options);
+        await this.plugins.dispatchBlocking('afterLaunch', context);
+        this._bindBrowserContextEvents(context);
+        return context;
+    }
+    async connect(wsEndpointOrOptions, wsOptions = {}) {
+        if (!this.launcher.connect) {
+            throw new Error('Launcher does not support "connect"');
+        }
+        this.plugins.prepare();
+        // Playwright currently supports two function signatures for .connect
+        let options = {};
+        let wsEndpointAsString = false;
+        if (typeof wsEndpointOrOptions === 'object') {
+            options = Object.assign(Object.assign({}, wsEndpointOrOptions), wsOptions);
+        }
+        else {
+            wsEndpointAsString = true;
+            options = Object.assign({ wsEndpoint: wsEndpointOrOptions }, wsOptions);
+        }
+        debug$2('connect', options);
+        // Give plugins the chance to modify the options before launch/connect
+        options =
+            (await this.plugins.dispatchBlocking('beforeConnect', options)) || options;
+        // Follow call signature of end user
+        const args = [];
+        const wsEndpoint = options.wsEndpoint;
+        if (wsEndpointAsString) {
+            delete options.wsEndpoint;
+            args.push(wsEndpoint, options);
+        }
+        else {
+            args.push(options);
+        }
+        const browser = (await this.launcher['connect'](...args));
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterConnect', browser);
+        return browser;
+    }
+    async connectOverCDP(wsEndpointOrOptions, wsOptions = {}) {
+        if (!this.launcher.connectOverCDP) {
+            throw new Error(`Launcher does not implement 'connectOverCDP'`);
+        }
+        this.plugins.prepare();
+        // Playwright currently supports two function signatures for .connectOverCDP
+        let options = {};
+        let wsEndpointAsString = false;
+        if (typeof wsEndpointOrOptions === 'object') {
+            options = Object.assign(Object.assign({}, wsEndpointOrOptions), wsOptions);
+        }
+        else {
+            wsEndpointAsString = true;
+            options = Object.assign({ endpointURL: wsEndpointOrOptions }, wsOptions);
+        }
+        debug$2('connectOverCDP'), options;
+        // Give plugins the chance to modify the options before launch/connect
+        options =
+            (await this.plugins.dispatchBlocking('beforeConnect', options)) || options;
+        // Follow call signature of end user
+        const args = [];
+        const endpointURL = options.endpointURL;
+        if (wsEndpointAsString) {
+            delete options.endpointURL;
+            args.push(endpointURL, options);
+        }
+        else {
+            args.push(options);
+        }
+        const browser = (await this.launcher['connectOverCDP'](...args));
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterConnect', browser);
+        return browser;
+    }
+    async _bindBrowserContextEvents(context, contextOptions) {
+        debug$2('_bindBrowserContextEvents');
+        this.plugins.dispatch('onContextCreated', context, contextOptions);
+        // Make sure things like `addInitScript` show an effect on the very first page as well
+        context.newPage = ((originalMethod, ctx) => {
+            return async () => {
+                const page = await originalMethod.call(ctx);
+                await page.goto('about:blank');
+                return page;
+            };
+        })(context.newPage, context);
+        context.on('close', () => {
+            // When using `launchPersistentContext` context closing is the same as browser closing
+            if (!context.browser()) {
+                this.plugins.dispatch('onDisconnected');
+            }
+        });
+        context.on('page', page => {
+            this.plugins.dispatch('onPageCreated', page);
+            page.on('close', () => {
+                this.plugins.dispatch('onPageClose', page);
+            });
+        });
+    }
+    async _bindBrowserEvents(browser) {
+        debug$2('_bindPlaywrightBrowserEvents');
+        browser.on('disconnected', () => {
+            this.plugins.dispatch('onDisconnected', browser);
+        });
+        // Note: `browser.newPage` will implicitly call `browser.newContext` as well
+        browser.newContext = ((originalMethod, ctx) => {
+            return async (options = {}) => {
+                const contextOptions = (await this.plugins.dispatchBlocking('beforeContext', options, browser)) || options;
+                const context = await originalMethod.call(ctx, contextOptions);
+                this._bindBrowserContextEvents(context, contextOptions);
+                return context;
+            };
+        })(browser.newContext, browser);
+    }
+}
+/**
+ * PlaywrightExtra class with additional launcher methods.
+ *
+ * Augments the class with an instance proxy to pass on methods that are not augmented to the original target.
+ *
+ */
+const PlaywrightExtra = new Proxy(PlaywrightExtraClass, {
+    construct(classTarget, args) {
+        debug$2(`create instance of ${classTarget.name}`);
+        const result = Reflect.construct(classTarget, args);
+        return new Proxy(result, {
+            get(target, prop) {
+                if (prop in target) {
+                    return Reflect.get(target, prop);
+                }
+                debug$2('proxying property to original launcher: ', prop);
+                return Reflect.get(target.launcher, prop);
+            }
+        });
+    }
+});
+
+/**
+ * Augment the provided Playwright browser launcher with plugin functionality.
+ *
+ * Using `addExtra` will always create a fresh PlaywrightExtra instance.
+ *
+ * @example
+ * import playwright from 'playwright'
+ * import { addExtra } from 'playwright-extra'
+ *
+ * const chromium = addExtra(playwright.chromium)
+ * chromium.use(plugin)
+ *
+ * @param launcher - Playwright (or compatible) browser launcher
+ */
+const addExtra = (launcher) => new PlaywrightExtra(launcher);
+/**
+ * This object can be used to launch or connect to Chromium with plugin functionality.
+ *
+ * This default export will behave exactly the same as the regular playwright
+ * (just with extra plugin functionality) and can be used as a drop-in replacement.
+ *
+ * Behind the scenes it will try to require either the `playwright-core`
+ * or `playwright` module from the installed dependencies.
+ *
+ * @note
+ * Due to Node.js import caching this will result in a single
+ * PlaywrightExtra instance, even when used in different files. If you need multiple
+ * instances with different plugins please use `addExtra`.
+ *
+ * @example
+ * // javascript import
+ * const { chromium } = require('playwright-extra')
+ *
+ * // typescript/es6 module import
+ * import { chromium } from 'playwright-extra'
+ *
+ * // Add plugins
+ * chromium.use(...)
+ */
+const chromium = addExtra((playwrightLoader.loadModule() || {}).chromium);
+/**
+ * This object can be used to launch or connect to Firefox with plugin functionality
+ * @note This export will always return the same instance, if you wish to use multiple instances with different plugins use `addExtra`
+ */
+const firefox = addExtra((playwrightLoader.loadModule() || {}).firefox);
+/**
+ * This object can be used to launch or connect to Webkit with plugin functionality
+ * @note This export will always return the same instance, if you wish to use multiple instances with different plugins use `addExtra`
+ */
+const webkit = addExtra((playwrightLoader.loadModule() || {}).webkit);
+// Other playwright module exports we simply re-export with lazy loading
+const _android = playwrightLoader.lazyloadExportOrDie('_android');
+const _electron = playwrightLoader.lazyloadExportOrDie('_electron');
+const request = playwrightLoader.lazyloadExportOrDie('request');
+const selectors = playwrightLoader.lazyloadExportOrDie('selectors');
+const devices = playwrightLoader.lazyloadExportOrDie('devices');
+const errors = playwrightLoader.lazyloadExportOrDie('errors');
+/** Playwright with plugin functionality */
+const moduleExports = {
+    // custom exports
+    PlaywrightExtra,
+    PlaywrightExtraClass,
+    PluginList,
+    addExtra,
+    chromium,
+    firefox,
+    webkit,
+    // vanilla exports
+    _android,
+    _electron,
+    request,
+    selectors,
+    devices,
+    errors
+};
+
+exports.PlaywrightExtra = PlaywrightExtra;
+exports.PlaywrightExtraClass = PlaywrightExtraClass;
+exports.PluginList = PluginList;
+exports._android = _android;
+exports._electron = _electron;
+exports.addExtra = addExtra;
+exports.chromium = chromium;
+exports.default = moduleExports;
+exports.devices = devices;
+exports.errors = errors;
+exports.firefox = firefox;
+exports.request = request;
+exports.selectors = selectors;
+exports.webkit = webkit;
+
+
+  module.exports = exports.default || {}
+  Object.entries(exports).forEach(([key, value]) => { module.exports[key] = value })
+//# sourceMappingURL=index.cjs.js.map

backend/node_modules/playwright-extra/dist/index.esm.js

@@ -0,0 +1,912 @@
+/*!
+ * playwright-extra v4.3.5 by berstend
+ * https://github.com/berstend/puppeteer-extra/tree/master/packages/playwright-extra#readme
+ * @license MIT
+ */
+import Debug from 'debug';
+
+/** Node.js module loader helper */
+class Loader {
+    constructor(moduleName, packageNames) {
+        this.moduleName = moduleName;
+        this.packageNames = packageNames;
+    }
+    /**
+     * Lazy load a top level export from another module by wrapping it in a JS proxy.
+     *
+     * This allows us to re-export e.g. `devices` from `playwright` while redirecting direct calls
+     * to it to the module version the user has installed, rather than shipping with a hardcoded version.
+     *
+     * If we don't do this and the user doesn't have the target module installed we'd throw immediately when our code is imported.
+     *
+     * We use a "super" Proxy defining all traps, so calls like `Object.keys(playwright.devices).length` will return the correct value.
+     */
+    lazyloadExportOrDie(exportName) {
+        const that = this;
+        const trapHandler = Object.fromEntries(Object.getOwnPropertyNames(Reflect).map((name) => [
+            name,
+            function (target, ...args) {
+                const moduleExport = that.loadModuleOrDie()[exportName];
+                const customTarget = moduleExport;
+                const result = Reflect[name](customTarget || target, ...args);
+                return result;
+            }
+        ]));
+        return new Proxy({}, trapHandler);
+    }
+    /** Load the module if possible */
+    loadModule() {
+        return requirePackages(this.packageNames);
+    }
+    /** Load the module if possible or throw */
+    loadModuleOrDie() {
+        const module = requirePackages(this.packageNames);
+        if (module) {
+            return module;
+        }
+        throw this.requireError;
+    }
+    get requireError() {
+        const moduleNamePretty = this.moduleName.charAt(0).toUpperCase() + this.moduleName.slice(1);
+        return new Error(`
+  ${moduleNamePretty} is missing. :-)
+
+  I've tried loading ${this.packageNames
+            .map(p => `"${p}"`)
+            .join(', ')} - no luck.
+
+  Make sure you install one of those packages or use the named 'addExtra' export,
+  to patch a specific (and maybe non-standard) implementation of ${moduleNamePretty}.
+
+  To get the latest stable version of ${moduleNamePretty} run:
+  'yarn add ${this.moduleName}' or 'npm i ${this.moduleName}'
+  `);
+    }
+}
+function requirePackages(packageNames) {
+    for (const name of packageNames) {
+        try {
+            return require(name);
+        }
+        catch (_) {
+            continue; // noop
+        }
+    }
+    return;
+}
+/** Playwright specific module loader */
+const playwrightLoader = new Loader('playwright', [
+    'playwright-core',
+    'playwright'
+]);
+
+const debug = Debug('playwright-extra:puppeteer-compat');
+const isPlaywrightPage = (obj) => {
+    return 'unroute' in obj;
+};
+const isPlaywrightFrame = (obj) => {
+    return ['parentFrame', 'frameLocator'].every(x => x in obj);
+};
+const isPlaywrightBrowser = (obj) => {
+    return 'newContext' in obj;
+};
+const isPuppeteerCompat = (obj) => {
+    return !!obj && typeof obj === 'object' && !!obj.isCompatShim;
+};
+const cache = {
+    objectToShim: new Map(),
+    cdpSession: {
+        page: new Map(),
+        browser: new Map()
+    }
+};
+/** Augment a Playwright object with compatibility with certain Puppeteer methods */
+function addPuppeteerCompat(object) {
+    if (!object || typeof object !== 'object') {
+        return object;
+    }
+    if (cache.objectToShim.has(object)) {
+        return cache.objectToShim.get(object);
+    }
+    if (isPuppeteerCompat(object)) {
+        return object;
+    }
+    debug('addPuppeteerCompat', cache.objectToShim.size);
+    if (isPlaywrightPage(object) || isPlaywrightFrame(object)) {
+        const shim = createPageShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    if (isPlaywrightBrowser(object)) {
+        const shim = createBrowserShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    debug('Received unknown object:', Reflect.ownKeys(object));
+    return object;
+}
+// Only chromium browsers support CDP
+const dummyCDPClient = {
+    send: async (...args) => {
+        debug('dummy CDP client called', 'send', args);
+    },
+    on: (...args) => {
+        debug('dummy CDP client called', 'on', args);
+    }
+};
+async function getPageCDPSession(page) {
+    let session = cache.cdpSession.page.get(page);
+    if (session) {
+        debug('getPageCDPSession: use existing');
+        return session;
+    }
+    debug('getPageCDPSession: use new');
+    const context = isPlaywrightFrame(page)
+        ? page.page().context()
+        : page.context();
+    try {
+        session = await context.newCDPSession(page);
+        cache.cdpSession.page.set(page, session);
+        return session;
+    }
+    catch (err) {
+        debug('getPageCDPSession: error while creating session:', err.message);
+        debug('getPageCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+async function getBrowserCDPSession(browser) {
+    let session = cache.cdpSession.browser.get(browser);
+    if (session) {
+        debug('getBrowserCDPSession: use existing');
+        return session;
+    }
+    debug('getBrowserCDPSession: use new');
+    try {
+        session = await browser.newBrowserCDPSession();
+        cache.cdpSession.browser.set(browser, session);
+        return session;
+    }
+    catch (err) {
+        debug('getBrowserCDPSession: error while creating session:', err.message);
+        debug('getBrowserCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+function createPageShim(page) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(page, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('page - get', objId, prop);
+            if (prop === '_client') {
+                return () => ({
+                    send: async (method, params) => {
+                        const session = await getPageCDPSession(page);
+                        return await session.send(method, params);
+                    },
+                    on: (event, listener) => {
+                        getPageCDPSession(page).then(session => {
+                            session.on(event, listener);
+                        });
+                    }
+                });
+            }
+            if (prop === 'setBypassCSP') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Page.setBypassCSP', {
+                        enabled
+                    });
+                };
+            }
+            if (prop === 'setUserAgent') {
+                return async (userAgent, userAgentMetadata) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Emulation.setUserAgentOverride', {
+                        userAgent,
+                        userAgentMetadata
+                    });
+                };
+            }
+            if (prop === 'browser') {
+                if (isPlaywrightPage(page)) {
+                    return () => {
+                        let browser = page.context().browser();
+                        if (!browser) {
+                            debug('page.browser() - not available, most likely due to launchPersistentContext');
+                            // Use a page shim as quick drop-in (so browser.userAgent() still works)
+                            browser = page;
+                        }
+                        return addPuppeteerCompat(browser);
+                    };
+                }
+            }
+            if (prop === 'evaluateOnNewDocument') {
+                if (isPlaywrightPage(page)) {
+                    return async function (pageFunction, ...args) {
+                        return await page.addInitScript(pageFunction, args[0]);
+                    };
+                }
+            }
+            // Only relevant when page is being used a pseudo stand-in for the browser object (launchPersistentContext)
+            if (prop === 'userAgent') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+function createBrowserShim(browser) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(browser, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('browser - get', objId, prop);
+            if (prop === 'pages') {
+                return () => browser
+                    .contexts()
+                    .flatMap(c => c.pages().map(page => addPuppeteerCompat(page)));
+            }
+            if (prop === 'userAgent') {
+                return async () => {
+                    const session = await getBrowserCDPSession(browser);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+
+const debug$1 = Debug('playwright-extra:plugins');
+class PluginList {
+    constructor() {
+        this._plugins = [];
+        this._dependencyDefaults = new Map();
+        this._dependencyResolution = new Map();
+    }
+    /**
+     * Get a list of all registered plugins.
+     */
+    get list() {
+        return this._plugins;
+    }
+    /**
+     * Get the names of all registered plugins.
+     */
+    get names() {
+        return this._plugins.map(p => p.name);
+    }
+    /**
+     * Add a new plugin to the list (after checking if it's well-formed).
+     *
+     * @param plugin
+     * @internal
+     */
+    add(plugin) {
+        var _a;
+        if (!this.isValidPluginInstance(plugin)) {
+            return false;
+        }
+        if (!!plugin.onPluginRegistered) {
+            plugin.onPluginRegistered({ framework: 'playwright' });
+        }
+        // PuppeteerExtraPlugin: Populate `_childClassMembers` list containing methods defined by the plugin
+        if (!!plugin._registerChildClassMembers) {
+            plugin._registerChildClassMembers(Object.getPrototypeOf(plugin));
+        }
+        if ((_a = plugin.requirements) === null || _a === void 0 ? void 0 : _a.has('dataFromPlugins')) {
+            plugin.getDataFromPlugins = this.getData.bind(this);
+        }
+        this._plugins.push(plugin);
+        return true;
+    }
+    /** Check if the shape of a plugin is correct or warn */
+    isValidPluginInstance(plugin) {
+        if (!plugin ||
+            typeof plugin !== 'object' ||
+            !plugin._isPuppeteerExtraPlugin) {
+            console.error(`Warning: Plugin is not derived from PuppeteerExtraPlugin, ignoring.`, plugin);
+            return false;
+        }
+        if (!plugin.name) {
+            console.error(`Warning: Plugin with no name registering, ignoring.`, plugin);
+            return false;
+        }
+        return true;
+    }
+    /** Error callback in case calling a plugin method throws an error. Can be overwritten. */
+    onPluginError(plugin, method, err) {
+        console.warn(`An error occured while executing "${method}" in plugin "${plugin.name}":`, err);
+    }
+    /**
+     * Define default values for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * @param dependencyPath - The string by which the dependency is listed (not the plugin name)
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyDefaults('stealth/evasions/webgl.vendor', { vendor: 'Bob', renderer: 'Alice' })
+     */
+    setDependencyDefaults(dependencyPath, opts) {
+        this._dependencyDefaults.set(dependencyPath, opts);
+        return this;
+    }
+    /**
+     * Define custom plugin modules for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * Using this will prevent dynamic imports from being used, which JS bundlers often have issues with.
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyResolution('stealth/evasions/webgl.vendor', VendorPlugin)
+     */
+    setDependencyResolution(dependencyPath, pluginModule) {
+        this._dependencyResolution.set(dependencyPath, pluginModule);
+        return this;
+    }
+    /**
+     * Prepare plugins to be used (resolve dependencies, ordering)
+     * @internal
+     */
+    prepare() {
+        this.resolveDependencies();
+        this.order();
+    }
+    /** Return all plugins using the supplied method */
+    filterByMethod(methodName) {
+        return this._plugins.filter(plugin => {
+            // PuppeteerExtraPlugin: The base class will already define all methods, hence we need to do a different check
+            if (!!plugin._childClassMembers &&
+                Array.isArray(plugin._childClassMembers)) {
+                return plugin._childClassMembers.includes(methodName);
+            }
+            return methodName in plugin;
+        });
+    }
+    /** Conditionally add puppeteer compatibility to values provided to the plugins */
+    _addPuppeteerCompatIfNeeded(plugin, method, args) {
+        const canUseShim = plugin._isPuppeteerExtraPlugin && !plugin.noPuppeteerShim;
+        const methodWhitelist = [
+            'onBrowser',
+            'onPageCreated',
+            'onPageClose',
+            'afterConnect',
+            'afterLaunch'
+        ];
+        const shouldUseShim = methodWhitelist.includes(method);
+        if (!canUseShim || !shouldUseShim) {
+            return args;
+        }
+        debug$1('add puppeteer compatibility', plugin.name, method);
+        return [...args.map(arg => addPuppeteerCompat(arg))];
+    }
+    /**
+     * Dispatch plugin lifecycle events in a typesafe way.
+     * Only Plugins that expose the supplied property will be called.
+     *
+     * Will not await results to dispatch events as fast as possible to all plugins.
+     *
+     * @param method - The lifecycle method name
+     * @param args - Optional: Any arguments to be supplied to the plugin methods
+     * @internal
+     */
+    dispatch(method, ...args) {
+        var _a, _b;
+        const plugins = this.filterByMethod(method);
+        debug$1('dispatch', method, {
+            all: this._plugins.length,
+            filteredByMethod: plugins.length
+        });
+        for (const plugin of plugins) {
+            try {
+                args = this._addPuppeteerCompatIfNeeded.bind(this)(plugin, method, args);
+                const fnType = (_b = (_a = plugin[method]) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name;
+                debug$1('dispatch to plugin', {
+                    plugin: plugin.name,
+                    method,
+                    fnType
+                });
+                if (fnType === 'AsyncFunction') {
+                    ;
+                    plugin[method](...args).catch((err) => this.onPluginError(plugin, method, err));
+                }
+                else {
+                    ;
+                    plugin[method](...args);
+                }
+            }
+            catch (err) {
+                this.onPluginError(plugin, method, err);
+            }
+        }
+    }
+    /**
+     * Dispatch plugin lifecycle events in a typesafe way.
+     * Only Plugins that expose the supplied property will be called.
+     *
+     * Can also be used to get a definite return value after passing it to plugins:
+     * Calls plugins sequentially and passes on a value (waterfall style).
+     *
+     * The plugins can either modify the value or return an updated one.
+     * Will return the latest, updated value which ran through all plugins.
+     *
+     * By convention only the first argument will be used as the updated value.
+     *
+     * @param method - The lifecycle method name
+     * @param args - Optional: Any arguments to be supplied to the plugin methods
+     * @internal
+     */
+    async dispatchBlocking(method, ...args) {
+        const plugins = this.filterByMethod(method);
+        debug$1('dispatchBlocking', method, {
+            all: this._plugins.length,
+            filteredByMethod: plugins.length
+        });
+        let retValue = null;
+        for (const plugin of plugins) {
+            try {
+                args = this._addPuppeteerCompatIfNeeded.bind(this)(plugin, method, args);
+                retValue = await plugin[method](...args);
+                // In case we got a return value use that as new first argument for followup function calls
+                if (retValue !== undefined) {
+                    args[0] = retValue;
+                }
+            }
+            catch (err) {
+                this.onPluginError(plugin, method, err);
+                return retValue;
+            }
+        }
+        return retValue;
+    }
+    /**
+     * Order plugins that have expressed a special placement requirement.
+     *
+     * This is useful/necessary for e.g. plugins that depend on the data from other plugins.
+     *
+     * @private
+     */
+    order() {
+        debug$1('order:before', this.names);
+        const runLast = this._plugins
+            .filter(p => { var _a; return (_a = p.requirements) === null || _a === void 0 ? void 0 : _a.has('runLast'); })
+            .map(p => p.name);
+        for (const name of runLast) {
+            const index = this._plugins.findIndex(p => p.name === name);
+            this._plugins.push(this._plugins.splice(index, 1)[0]);
+        }
+        debug$1('order:after', this.names);
+    }
+    /**
+     * Collects the exposed `data` property of all registered plugins.
+     * Will be reduced/flattened to a single array.
+     *
+     * Can be accessed by plugins that listed the `dataFromPlugins` requirement.
+     *
+     * Implemented mainly for plugins that need data from other plugins (e.g. `user-preferences`).
+     *
+     * @see [PuppeteerExtraPlugin]/data
+     * @param name - Filter data by optional name
+     *
+     * @private
+     */
+    getData(name) {
+        const data = this._plugins
+            .filter((p) => !!p.data)
+            .map((p) => (Array.isArray(p.data) ? p.data : [p.data]))
+            .reduce((acc, arr) => [...acc, ...arr], []);
+        return name ? data.filter((d) => d.name === name) : data;
+    }
+    /**
+     * Handle `plugins` stanza (already instantiated plugins that don't require dynamic imports)
+     */
+    resolvePluginsStanza() {
+        debug$1('resolvePluginsStanza');
+        const pluginNames = new Set(this.names);
+        this._plugins
+            .filter(p => !!p.plugins && p.plugins.length)
+            .filter(p => !pluginNames.has(p.name)) // TBD: Do we want to filter out existing?
+            .forEach(parent => {
+            (parent.plugins || []).forEach(p => {
+                debug$1(parent.name, 'adding missing plugin', p.name);
+                this.add(p);
+            });
+        });
+    }
+    /**
+     * Handle `dependencies` stanza (which requires dynamic imports)
+     *
+     * Plugins can define `dependencies` as a Set or Array of dependency paths, or a Map with additional opts
+     *
+     * @note
+     * - The default opts for implicit dependencies can be defined using `setDependencyDefaults()`
+     * - Dynamic imports can be avoided by providing plugin modules with `setDependencyResolution()`
+     */
+    resolveDependenciesStanza() {
+        debug$1('resolveDependenciesStanza');
+        /** Attempt to dynamically require a plugin module */
+        const requireDependencyOrDie = (parentName, dependencyPath) => {
+            // If the user provided the plugin module already we use that
+            if (this._dependencyResolution.has(dependencyPath)) {
+                return this._dependencyResolution.get(dependencyPath);
+            }
+            const possiblePrefixes = ['puppeteer-extra-plugin-']; // could be extended later
+            const isAlreadyPrefixed = possiblePrefixes.some(prefix => dependencyPath.startsWith(prefix));
+            const packagePaths = [];
+            // If the dependency is not already prefixed we attempt to require all possible combinations to find one that works
+            if (!isAlreadyPrefixed) {
+                packagePaths.push(...possiblePrefixes.map(prefix => prefix + dependencyPath));
+            }
+            // We always attempt to require the path verbatim (as a last resort)
+            packagePaths.push(dependencyPath);
+            const pluginModule = requirePackages(packagePaths);
+            if (pluginModule) {
+                return pluginModule;
+            }
+            const explanation = `
+The plugin '${parentName}' listed '${dependencyPath}' as dependency,
+which could not be found. Please install it:
+
+${packagePaths
+                .map(packagePath => `yarn add ${packagePath.split('/')[0]}`)
+                .join(`\n or:\n`)}
+
+Note: You don't need to require the plugin yourself,
+unless you want to modify it's default settings.
+
+If your bundler has issues with dynamic imports take a look at '.plugins.setDependencyResolution()'.
+      `;
+            console.warn(explanation);
+            throw new Error('Plugin dependency not found');
+        };
+        const existingPluginNames = new Set(this.names);
+        const recursivelyLoadMissingDependencies = ({ name: parentName, dependencies }) => {
+            if (!dependencies) {
+                return;
+            }
+            const processDependency = (dependencyPath, opts) => {
+                const pluginModule = requireDependencyOrDie(parentName, dependencyPath);
+                opts = opts || this._dependencyDefaults.get(dependencyPath) || {};
+                const plugin = pluginModule(opts);
+                if (existingPluginNames.has(plugin.name)) {
+                    debug$1(parentName, '=> dependency already exists:', plugin.name);
+                    return;
+                }
+                existingPluginNames.add(plugin.name);
+                debug$1(parentName, '=> adding new dependency:', plugin.name, opts);
+                this.add(plugin);
+                return recursivelyLoadMissingDependencies(plugin);
+            };
+            if (dependencies instanceof Set || Array.isArray(dependencies)) {
+                return [...dependencies].forEach(dependencyPath => processDependency(dependencyPath));
+            }
+            if (dependencies instanceof Map) {
+                // Note: `k,v => v,k` (Map + forEach will reverse the order)
+                return dependencies.forEach((v, k) => processDependency(k, v));
+            }
+        };
+        this.list.forEach(recursivelyLoadMissingDependencies);
+    }
+    /**
+     * Lightweight plugin dependency management to require plugins and code mods on demand.
+     * @private
+     */
+    resolveDependencies() {
+        debug$1('resolveDependencies');
+        this.resolvePluginsStanza();
+        this.resolveDependenciesStanza();
+    }
+}
+
+const debug$2 = Debug('playwright-extra');
+/**
+ * Modular plugin framework to teach `playwright` new tricks.
+ */
+class PlaywrightExtraClass {
+    constructor(_launcher) {
+        this._launcher = _launcher;
+        this.plugins = new PluginList();
+    }
+    /**
+     * The **main interface** to register plugins.
+     *
+     * Can be called multiple times to enable multiple plugins.
+     *
+     * Plugins derived from `PuppeteerExtraPlugin` will be used with a compatiblity layer.
+     *
+     * @example
+     * chromium.use(plugin1).use(plugin2)
+     * firefox.use(plugin1).use(plugin2)
+     *
+     * @see [PuppeteerExtraPlugin]
+     *
+     * @return The same `PlaywrightExtra` instance (for optional chaining)
+     */
+    use(plugin) {
+        const isValid = plugin && 'name' in plugin;
+        if (!isValid) {
+            throw new Error('A plugin must be provided to .use()');
+        }
+        if (this.plugins.add(plugin)) {
+            debug$2('Plugin registered', plugin.name);
+        }
+        return this;
+    }
+    /**
+     * In order to support a default export which will require vanilla playwright automatically,
+     * as well as `addExtra` to patch a provided launcher, we need to so some gymnastics here.
+     *
+     * Otherwise this would throw immediately, even when only using the `addExtra` export with an arbitrary compatible launcher.
+     *
+     * The solution is to make the vanilla launcher optional and only throw once we try to effectively use and can't find it.
+     *
+     * @internal
+     */
+    get launcher() {
+        if (!this._launcher) {
+            throw playwrightLoader.requireError;
+        }
+        return this._launcher;
+    }
+    async launch(...args) {
+        if (!this.launcher.launch) {
+            throw new Error('Launcher does not support "launch"');
+        }
+        let [options] = args;
+        options = Object.assign({ args: [] }, (options || {})); // Initialize args array
+        debug$2('launch', options);
+        this.plugins.prepare();
+        // Give plugins the chance to modify the options before continuing
+        options =
+            (await this.plugins.dispatchBlocking('beforeLaunch', options)) || options;
+        debug$2('launch with options', options);
+        if ('userDataDir' in options) {
+            debug$2("A plugin defined userDataDir during .launch, which isn't supported by playwright - ignoring");
+            delete options.userDataDir;
+        }
+        const browser = await this.launcher['launch'](options);
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterLaunch', browser);
+        return browser;
+    }
+    async launchPersistentContext(...args) {
+        if (!this.launcher.launchPersistentContext) {
+            throw new Error('Launcher does not support "launchPersistentContext"');
+        }
+        let [userDataDir, options] = args;
+        options = Object.assign({ args: [] }, (options || {})); // Initialize args array
+        debug$2('launchPersistentContext', options);
+        this.plugins.prepare();
+        // Give plugins the chance to modify the options before continuing
+        options =
+            (await this.plugins.dispatchBlocking('beforeLaunch', options)) || options;
+        const context = await this.launcher['launchPersistentContext'](userDataDir, options);
+        await this.plugins.dispatchBlocking('afterLaunch', context);
+        this._bindBrowserContextEvents(context);
+        return context;
+    }
+    async connect(wsEndpointOrOptions, wsOptions = {}) {
+        if (!this.launcher.connect) {
+            throw new Error('Launcher does not support "connect"');
+        }
+        this.plugins.prepare();
+        // Playwright currently supports two function signatures for .connect
+        let options = {};
+        let wsEndpointAsString = false;
+        if (typeof wsEndpointOrOptions === 'object') {
+            options = Object.assign(Object.assign({}, wsEndpointOrOptions), wsOptions);
+        }
+        else {
+            wsEndpointAsString = true;
+            options = Object.assign({ wsEndpoint: wsEndpointOrOptions }, wsOptions);
+        }
+        debug$2('connect', options);
+        // Give plugins the chance to modify the options before launch/connect
+        options =
+            (await this.plugins.dispatchBlocking('beforeConnect', options)) || options;
+        // Follow call signature of end user
+        const args = [];
+        const wsEndpoint = options.wsEndpoint;
+        if (wsEndpointAsString) {
+            delete options.wsEndpoint;
+            args.push(wsEndpoint, options);
+        }
+        else {
+            args.push(options);
+        }
+        const browser = (await this.launcher['connect'](...args));
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterConnect', browser);
+        return browser;
+    }
+    async connectOverCDP(wsEndpointOrOptions, wsOptions = {}) {
+        if (!this.launcher.connectOverCDP) {
+            throw new Error(`Launcher does not implement 'connectOverCDP'`);
+        }
+        this.plugins.prepare();
+        // Playwright currently supports two function signatures for .connectOverCDP
+        let options = {};
+        let wsEndpointAsString = false;
+        if (typeof wsEndpointOrOptions === 'object') {
+            options = Object.assign(Object.assign({}, wsEndpointOrOptions), wsOptions);
+        }
+        else {
+            wsEndpointAsString = true;
+            options = Object.assign({ endpointURL: wsEndpointOrOptions }, wsOptions);
+        }
+        debug$2('connectOverCDP'), options;
+        // Give plugins the chance to modify the options before launch/connect
+        options =
+            (await this.plugins.dispatchBlocking('beforeConnect', options)) || options;
+        // Follow call signature of end user
+        const args = [];
+        const endpointURL = options.endpointURL;
+        if (wsEndpointAsString) {
+            delete options.endpointURL;
+            args.push(endpointURL, options);
+        }
+        else {
+            args.push(options);
+        }
+        const browser = (await this.launcher['connectOverCDP'](...args));
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterConnect', browser);
+        return browser;
+    }
+    async _bindBrowserContextEvents(context, contextOptions) {
+        debug$2('_bindBrowserContextEvents');
+        this.plugins.dispatch('onContextCreated', context, contextOptions);
+        // Make sure things like `addInitScript` show an effect on the very first page as well
+        context.newPage = ((originalMethod, ctx) => {
+            return async () => {
+                const page = await originalMethod.call(ctx);
+                await page.goto('about:blank');
+                return page;
+            };
+        })(context.newPage, context);
+        context.on('close', () => {
+            // When using `launchPersistentContext` context closing is the same as browser closing
+            if (!context.browser()) {
+                this.plugins.dispatch('onDisconnected');
+            }
+        });
+        context.on('page', page => {
+            this.plugins.dispatch('onPageCreated', page);
+            page.on('close', () => {
+                this.plugins.dispatch('onPageClose', page);
+            });
+        });
+    }
+    async _bindBrowserEvents(browser) {
+        debug$2('_bindPlaywrightBrowserEvents');
+        browser.on('disconnected', () => {
+            this.plugins.dispatch('onDisconnected', browser);
+        });
+        // Note: `browser.newPage` will implicitly call `browser.newContext` as well
+        browser.newContext = ((originalMethod, ctx) => {
+            return async (options = {}) => {
+                const contextOptions = (await this.plugins.dispatchBlocking('beforeContext', options, browser)) || options;
+                const context = await originalMethod.call(ctx, contextOptions);
+                this._bindBrowserContextEvents(context, contextOptions);
+                return context;
+            };
+        })(browser.newContext, browser);
+    }
+}
+/**
+ * PlaywrightExtra class with additional launcher methods.
+ *
+ * Augments the class with an instance proxy to pass on methods that are not augmented to the original target.
+ *
+ */
+const PlaywrightExtra = new Proxy(PlaywrightExtraClass, {
+    construct(classTarget, args) {
+        debug$2(`create instance of ${classTarget.name}`);
+        const result = Reflect.construct(classTarget, args);
+        return new Proxy(result, {
+            get(target, prop) {
+                if (prop in target) {
+                    return Reflect.get(target, prop);
+                }
+                debug$2('proxying property to original launcher: ', prop);
+                return Reflect.get(target.launcher, prop);
+            }
+        });
+    }
+});
+
+/**
+ * Augment the provided Playwright browser launcher with plugin functionality.
+ *
+ * Using `addExtra` will always create a fresh PlaywrightExtra instance.
+ *
+ * @example
+ * import playwright from 'playwright'
+ * import { addExtra } from 'playwright-extra'
+ *
+ * const chromium = addExtra(playwright.chromium)
+ * chromium.use(plugin)
+ *
+ * @param launcher - Playwright (or compatible) browser launcher
+ */
+const addExtra = (launcher) => new PlaywrightExtra(launcher);
+/**
+ * This object can be used to launch or connect to Chromium with plugin functionality.
+ *
+ * This default export will behave exactly the same as the regular playwright
+ * (just with extra plugin functionality) and can be used as a drop-in replacement.
+ *
+ * Behind the scenes it will try to require either the `playwright-core`
+ * or `playwright` module from the installed dependencies.
+ *
+ * @note
+ * Due to Node.js import caching this will result in a single
+ * PlaywrightExtra instance, even when used in different files. If you need multiple
+ * instances with different plugins please use `addExtra`.
+ *
+ * @example
+ * // javascript import
+ * const { chromium } = require('playwright-extra')
+ *
+ * // typescript/es6 module import
+ * import { chromium } from 'playwright-extra'
+ *
+ * // Add plugins
+ * chromium.use(...)
+ */
+const chromium = addExtra((playwrightLoader.loadModule() || {}).chromium);
+/**
+ * This object can be used to launch or connect to Firefox with plugin functionality
+ * @note This export will always return the same instance, if you wish to use multiple instances with different plugins use `addExtra`
+ */
+const firefox = addExtra((playwrightLoader.loadModule() || {}).firefox);
+/**
+ * This object can be used to launch or connect to Webkit with plugin functionality
+ * @note This export will always return the same instance, if you wish to use multiple instances with different plugins use `addExtra`
+ */
+const webkit = addExtra((playwrightLoader.loadModule() || {}).webkit);
+// Other playwright module exports we simply re-export with lazy loading
+const _android = playwrightLoader.lazyloadExportOrDie('_android');
+const _electron = playwrightLoader.lazyloadExportOrDie('_electron');
+const request = playwrightLoader.lazyloadExportOrDie('request');
+const selectors = playwrightLoader.lazyloadExportOrDie('selectors');
+const devices = playwrightLoader.lazyloadExportOrDie('devices');
+const errors = playwrightLoader.lazyloadExportOrDie('errors');
+/** Playwright with plugin functionality */
+const moduleExports = {
+    // custom exports
+    PlaywrightExtra,
+    PlaywrightExtraClass,
+    PluginList,
+    addExtra,
+    chromium,
+    firefox,
+    webkit,
+    // vanilla exports
+    _android,
+    _electron,
+    request,
+    selectors,
+    devices,
+    errors
+};
+
+export default moduleExports;
+export { PlaywrightExtra, PlaywrightExtraClass, PluginList, _android, _electron, addExtra, chromium, devices, errors, firefox, request, selectors, webkit };
+//# sourceMappingURL=index.esm.js.map

backend/node_modules/playwright-extra/dist/index.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errors = exports.devices = exports.selectors = exports.request = exports._electron = exports._android = exports.webkit = exports.firefox = exports.chromium = exports.addExtra = exports.PluginList = exports.PlaywrightExtraClass = exports.PlaywrightExtra = void 0;
+const extra_1 = require("./extra");
+const plugins_1 = require("./plugins");
+const loader_1 = require("./helper/loader");
+var extra_2 = require("./extra");
+Object.defineProperty(exports, "PlaywrightExtra", { enumerable: true, get: function () { return extra_2.PlaywrightExtra; } });
+Object.defineProperty(exports, "PlaywrightExtraClass", { enumerable: true, get: function () { return extra_2.PlaywrightExtraClass; } });
+var plugins_2 = require("./plugins");
+Object.defineProperty(exports, "PluginList", { enumerable: true, get: function () { return plugins_2.PluginList; } });
+/**
+ * Augment the provided Playwright browser launcher with plugin functionality.
+ *
+ * Using `addExtra` will always create a fresh PlaywrightExtra instance.
+ *
+ * @example
+ * import playwright from 'playwright'
+ * import { addExtra } from 'playwright-extra'
+ *
+ * const chromium = addExtra(playwright.chromium)
+ * chromium.use(plugin)
+ *
+ * @param launcher - Playwright (or compatible) browser launcher
+ */
+const addExtra = (launcher) => new extra_1.PlaywrightExtra(launcher);
+exports.addExtra = addExtra;
+/**
+ * This object can be used to launch or connect to Chromium with plugin functionality.
+ *
+ * This default export will behave exactly the same as the regular playwright
+ * (just with extra plugin functionality) and can be used as a drop-in replacement.
+ *
+ * Behind the scenes it will try to require either the `playwright-core`
+ * or `playwright` module from the installed dependencies.
+ *
+ * @note
+ * Due to Node.js import caching this will result in a single
+ * PlaywrightExtra instance, even when used in different files. If you need multiple
+ * instances with different plugins please use `addExtra`.
+ *
+ * @example
+ * // javascript import
+ * const { chromium } = require('playwright-extra')
+ *
+ * // typescript/es6 module import
+ * import { chromium } from 'playwright-extra'
+ *
+ * // Add plugins
+ * chromium.use(...)
+ */
+exports.chromium = (0, exports.addExtra)((loader_1.playwrightLoader.loadModule() || {}).chromium);
+/**
+ * This object can be used to launch or connect to Firefox with plugin functionality
+ * @note This export will always return the same instance, if you wish to use multiple instances with different plugins use `addExtra`
+ */
+exports.firefox = (0, exports.addExtra)((loader_1.playwrightLoader.loadModule() || {}).firefox);
+/**
+ * This object can be used to launch or connect to Webkit with plugin functionality
+ * @note This export will always return the same instance, if you wish to use multiple instances with different plugins use `addExtra`
+ */
+exports.webkit = (0, exports.addExtra)((loader_1.playwrightLoader.loadModule() || {}).webkit);
+// Other playwright module exports we simply re-export with lazy loading
+exports._android = loader_1.playwrightLoader.lazyloadExportOrDie('_android');
+exports._electron = loader_1.playwrightLoader.lazyloadExportOrDie('_electron');
+exports.request = loader_1.playwrightLoader.lazyloadExportOrDie('request');
+exports.selectors = loader_1.playwrightLoader.lazyloadExportOrDie('selectors');
+exports.devices = loader_1.playwrightLoader.lazyloadExportOrDie('devices');
+exports.errors = loader_1.playwrightLoader.lazyloadExportOrDie('errors');
+/** Playwright with plugin functionality */
+const moduleExports = {
+    // custom exports
+    PlaywrightExtra: extra_1.PlaywrightExtra,
+    PlaywrightExtraClass: extra_1.PlaywrightExtraClass,
+    PluginList: plugins_1.PluginList,
+    addExtra: exports.addExtra,
+    chromium: exports.chromium,
+    firefox: exports.firefox,
+    webkit: exports.webkit,
+    // vanilla exports
+    _android: exports._android,
+    _electron: exports._electron,
+    request: exports.request,
+    selectors: exports.selectors,
+    devices: exports.devices,
+    errors: exports.errors
+};
+exports.default = moduleExports;
+//# sourceMappingURL=index.js.map

backend/node_modules/playwright-extra/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAEA,mCAA+D;AAC/D,uCAAsC;AACtC,4CAA4D;AAE5D,iCAA+D;AAAtD,wGAAA,eAAe,OAAA;AAAE,6GAAA,oBAAoB,OAAA;AAC9C,qCAAsC;AAA7B,qGAAA,UAAU,OAAA;AA+BnB;;;;;;;;;;;;;GAaG;AACI,MAAM,QAAQ,GAAG,CACtB,QAAmB,EACnB,EAAE,CAAC,IAAI,uBAAe,CAAC,QAAQ,CAAoC,CAAA;AAFxD,QAAA,QAAQ,YAEgD;AAErE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,QAAQ,GAAG,IAAA,gBAAQ,EAAC,CAAC,yBAAM,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAA;AACtE;;;GAGG;AACU,QAAA,OAAO,GAAG,IAAA,gBAAQ,EAAC,CAAC,yBAAM,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;AACpE;;;GAGG;AACU,QAAA,MAAM,GAAG,IAAA,gBAAQ,EAAC,CAAC,yBAAM,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAA;AAElE,wEAAwE;AAC3D,QAAA,QAAQ,GAAG,yBAAM,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAA;AACjD,QAAA,SAAS,GAAG,yBAAM,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAA;AACnD,QAAA,OAAO,GAAG,yBAAM,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAA;AAC/C,QAAA,SAAS,GAAG,yBAAM,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAA;AACnD,QAAA,OAAO,GAAG,yBAAM,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAA;AAC/C,QAAA,MAAM,GAAG,yBAAM,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAA;AAE1D,2CAA2C;AAC3C,MAAM,aAAa,GAAiD;IAClE,iBAAiB;IACjB,eAAe,EAAf,uBAAe;IACf,oBAAoB,EAApB,4BAAoB;IACpB,UAAU,EAAV,oBAAU;IACV,QAAQ,EAAR,gBAAQ;IACR,QAAQ,EAAR,gBAAQ;IACR,OAAO,EAAP,eAAO;IACP,MAAM,EAAN,cAAM;IAEN,kBAAkB;IAClB,QAAQ,EAAR,gBAAQ;IACR,SAAS,EAAT,iBAAS;IACT,OAAO,EAAP,eAAO;IACP,SAAS,EAAT,iBAAS;IACT,OAAO,EAAP,eAAO;IACP,MAAM,EAAN,cAAM;CACP,CAAA;AAED,kBAAe,aAAa,CAAA"}

backend/node_modules/playwright-extra/dist/plugins.d.ts

@@ -0,0 +1,84 @@
+import { Plugin, PluginMethodName, PluginMethodFn, CompatiblePluginModule } from './types';
+export declare class PluginList {
+    private readonly _plugins;
+    private readonly _dependencyDefaults;
+    private readonly _dependencyResolution;
+    constructor();
+    /**
+     * Get a list of all registered plugins.
+     */
+    get list(): import("./types").PuppeteerExtraPlugin[];
+    /**
+     * Get the names of all registered plugins.
+     */
+    get names(): string[];
+    /** Check if the shape of a plugin is correct or warn */
+    protected isValidPluginInstance(plugin: Plugin): boolean;
+    /** Error callback in case calling a plugin method throws an error. Can be overwritten. */
+    onPluginError(plugin: Plugin, method: PluginMethodName, err: Error): void;
+    /**
+     * Define default values for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * @param dependencyPath - The string by which the dependency is listed (not the plugin name)
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyDefaults('stealth/evasions/webgl.vendor', { vendor: 'Bob', renderer: 'Alice' })
+     */
+    setDependencyDefaults(dependencyPath: string, opts: any): this;
+    /**
+     * Define custom plugin modules for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * Using this will prevent dynamic imports from being used, which JS bundlers often have issues with.
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyResolution('stealth/evasions/webgl.vendor', VendorPlugin)
+     */
+    setDependencyResolution(dependencyPath: string, pluginModule: CompatiblePluginModule): this;
+    /** Return all plugins using the supplied method */
+    protected filterByMethod(methodName: PluginMethodName): import("./types").PuppeteerExtraPlugin[];
+    /** Conditionally add puppeteer compatibility to values provided to the plugins */
+    protected _addPuppeteerCompatIfNeeded<TMethod extends PluginMethodName>(plugin: Plugin, method: TMethod, args: Parameters<PluginMethodFn<TMethod>>): Parameters<PluginMethodFn<TMethod>>;
+    /**
+     * Order plugins that have expressed a special placement requirement.
+     *
+     * This is useful/necessary for e.g. plugins that depend on the data from other plugins.
+     *
+     * @private
+     */
+    protected order(): void;
+    /**
+     * Collects the exposed `data` property of all registered plugins.
+     * Will be reduced/flattened to a single array.
+     *
+     * Can be accessed by plugins that listed the `dataFromPlugins` requirement.
+     *
+     * Implemented mainly for plugins that need data from other plugins (e.g. `user-preferences`).
+     *
+     * @see [PuppeteerExtraPlugin]/data
+     * @param name - Filter data by optional name
+     *
+     * @private
+     */
+    protected getData(name?: string): any;
+    /**
+     * Handle `plugins` stanza (already instantiated plugins that don't require dynamic imports)
+     */
+    protected resolvePluginsStanza(): void;
+    /**
+     * Handle `dependencies` stanza (which requires dynamic imports)
+     *
+     * Plugins can define `dependencies` as a Set or Array of dependency paths, or a Map with additional opts
+     *
+     * @note
+     * - The default opts for implicit dependencies can be defined using `setDependencyDefaults()`
+     * - Dynamic imports can be avoided by providing plugin modules with `setDependencyResolution()`
+     */
+    protected resolveDependenciesStanza(): void;
+    /**
+     * Lightweight plugin dependency management to require plugins and code mods on demand.
+     * @private
+     */
+    protected resolveDependencies(): void;
+}

backend/node_modules/playwright-extra/dist/plugins.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginList = void 0;
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('playwright-extra:plugins');
+const loader_1 = require("./helper/loader");
+const puppeteer_compatiblity_shim_1 = require("./puppeteer-compatiblity-shim");
+class PluginList {
+    constructor() {
+        this._plugins = [];
+        this._dependencyDefaults = new Map();
+        this._dependencyResolution = new Map();
+    }
+    /**
+     * Get a list of all registered plugins.
+     */
+    get list() {
+        return this._plugins;
+    }
+    /**
+     * Get the names of all registered plugins.
+     */
+    get names() {
+        return this._plugins.map(p => p.name);
+    }
+    /**
+     * Add a new plugin to the list (after checking if it's well-formed).
+     *
+     * @param plugin
+     * @internal
+     */
+    add(plugin) {
+        var _a;
+        if (!this.isValidPluginInstance(plugin)) {
+            return false;
+        }
+        if (!!plugin.onPluginRegistered) {
+            plugin.onPluginRegistered({ framework: 'playwright' });
+        }
+        // PuppeteerExtraPlugin: Populate `_childClassMembers` list containing methods defined by the plugin
+        if (!!plugin._registerChildClassMembers) {
+            plugin._registerChildClassMembers(Object.getPrototypeOf(plugin));
+        }
+        if ((_a = plugin.requirements) === null || _a === void 0 ? void 0 : _a.has('dataFromPlugins')) {
+            plugin.getDataFromPlugins = this.getData.bind(this);
+        }
+        this._plugins.push(plugin);
+        return true;
+    }
+    /** Check if the shape of a plugin is correct or warn */
+    isValidPluginInstance(plugin) {
+        if (!plugin ||
+            typeof plugin !== 'object' ||
+            !plugin._isPuppeteerExtraPlugin) {
+            console.error(`Warning: Plugin is not derived from PuppeteerExtraPlugin, ignoring.`, plugin);
+            return false;
+        }
+        if (!plugin.name) {
+            console.error(`Warning: Plugin with no name registering, ignoring.`, plugin);
+            return false;
+        }
+        return true;
+    }
+    /** Error callback in case calling a plugin method throws an error. Can be overwritten. */
+    onPluginError(plugin, method, err) {
+        console.warn(`An error occured while executing "${method}" in plugin "${plugin.name}":`, err);
+    }
+    /**
+     * Define default values for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * @param dependencyPath - The string by which the dependency is listed (not the plugin name)
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyDefaults('stealth/evasions/webgl.vendor', { vendor: 'Bob', renderer: 'Alice' })
+     */
+    setDependencyDefaults(dependencyPath, opts) {
+        this._dependencyDefaults.set(dependencyPath, opts);
+        return this;
+    }
+    /**
+     * Define custom plugin modules for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * Using this will prevent dynamic imports from being used, which JS bundlers often have issues with.
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyResolution('stealth/evasions/webgl.vendor', VendorPlugin)
+     */
+    setDependencyResolution(dependencyPath, pluginModule) {
+        this._dependencyResolution.set(dependencyPath, pluginModule);
+        return this;
+    }
+    /**
+     * Prepare plugins to be used (resolve dependencies, ordering)
+     * @internal
+     */
+    prepare() {
+        this.resolveDependencies();
+        this.order();
+    }
+    /** Return all plugins using the supplied method */
+    filterByMethod(methodName) {
+        return this._plugins.filter(plugin => {
+            // PuppeteerExtraPlugin: The base class will already define all methods, hence we need to do a different check
+            if (!!plugin._childClassMembers &&
+                Array.isArray(plugin._childClassMembers)) {
+                return plugin._childClassMembers.includes(methodName);
+            }
+            return methodName in plugin;
+        });
+    }
+    /** Conditionally add puppeteer compatibility to values provided to the plugins */
+    _addPuppeteerCompatIfNeeded(plugin, method, args) {
+        const canUseShim = plugin._isPuppeteerExtraPlugin && !plugin.noPuppeteerShim;
+        const methodWhitelist = [
+            'onBrowser',
+            'onPageCreated',
+            'onPageClose',
+            'afterConnect',
+            'afterLaunch'
+        ];
+        const shouldUseShim = methodWhitelist.includes(method);
+        if (!canUseShim || !shouldUseShim) {
+            return args;
+        }
+        debug('add puppeteer compatibility', plugin.name, method);
+        return [...args.map(arg => (0, puppeteer_compatiblity_shim_1.addPuppeteerCompat)(arg))];
+    }
+    /**
+     * Dispatch plugin lifecycle events in a typesafe way.
+     * Only Plugins that expose the supplied property will be called.
+     *
+     * Will not await results to dispatch events as fast as possible to all plugins.
+     *
+     * @param method - The lifecycle method name
+     * @param args - Optional: Any arguments to be supplied to the plugin methods
+     * @internal
+     */
+    dispatch(method, ...args) {
+        var _a, _b;
+        const plugins = this.filterByMethod(method);
+        debug('dispatch', method, {
+            all: this._plugins.length,
+            filteredByMethod: plugins.length
+        });
+        for (const plugin of plugins) {
+            try {
+                args = this._addPuppeteerCompatIfNeeded.bind(this)(plugin, method, args);
+                const fnType = (_b = (_a = plugin[method]) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name;
+                debug('dispatch to plugin', {
+                    plugin: plugin.name,
+                    method,
+                    fnType
+                });
+                if (fnType === 'AsyncFunction') {
+                    ;
+                    plugin[method](...args).catch((err) => this.onPluginError(plugin, method, err));
+                }
+                else {
+                    ;
+                    plugin[method](...args);
+                }
+            }
+            catch (err) {
+                this.onPluginError(plugin, method, err);
+            }
+        }
+    }
+    /**
+     * Dispatch plugin lifecycle events in a typesafe way.
+     * Only Plugins that expose the supplied property will be called.
+     *
+     * Can also be used to get a definite return value after passing it to plugins:
+     * Calls plugins sequentially and passes on a value (waterfall style).
+     *
+     * The plugins can either modify the value or return an updated one.
+     * Will return the latest, updated value which ran through all plugins.
+     *
+     * By convention only the first argument will be used as the updated value.
+     *
+     * @param method - The lifecycle method name
+     * @param args - Optional: Any arguments to be supplied to the plugin methods
+     * @internal
+     */
+    async dispatchBlocking(method, ...args) {
+        const plugins = this.filterByMethod(method);
+        debug('dispatchBlocking', method, {
+            all: this._plugins.length,
+            filteredByMethod: plugins.length
+        });
+        let retValue = null;
+        for (const plugin of plugins) {
+            try {
+                args = this._addPuppeteerCompatIfNeeded.bind(this)(plugin, method, args);
+                retValue = await plugin[method](...args);
+                // In case we got a return value use that as new first argument for followup function calls
+                if (retValue !== undefined) {
+                    args[0] = retValue;
+                }
+            }
+            catch (err) {
+                this.onPluginError(plugin, method, err);
+                return retValue;
+            }
+        }
+        return retValue;
+    }
+    /**
+     * Order plugins that have expressed a special placement requirement.
+     *
+     * This is useful/necessary for e.g. plugins that depend on the data from other plugins.
+     *
+     * @private
+     */
+    order() {
+        debug('order:before', this.names);
+        const runLast = this._plugins
+            .filter(p => { var _a; return (_a = p.requirements) === null || _a === void 0 ? void 0 : _a.has('runLast'); })
+            .map(p => p.name);
+        for (const name of runLast) {
+            const index = this._plugins.findIndex(p => p.name === name);
+            this._plugins.push(this._plugins.splice(index, 1)[0]);
+        }
+        debug('order:after', this.names);
+    }
+    /**
+     * Collects the exposed `data` property of all registered plugins.
+     * Will be reduced/flattened to a single array.
+     *
+     * Can be accessed by plugins that listed the `dataFromPlugins` requirement.
+     *
+     * Implemented mainly for plugins that need data from other plugins (e.g. `user-preferences`).
+     *
+     * @see [PuppeteerExtraPlugin]/data
+     * @param name - Filter data by optional name
+     *
+     * @private
+     */
+    getData(name) {
+        const data = this._plugins
+            .filter((p) => !!p.data)
+            .map((p) => (Array.isArray(p.data) ? p.data : [p.data]))
+            .reduce((acc, arr) => [...acc, ...arr], []);
+        return name ? data.filter((d) => d.name === name) : data;
+    }
+    /**
+     * Handle `plugins` stanza (already instantiated plugins that don't require dynamic imports)
+     */
+    resolvePluginsStanza() {
+        debug('resolvePluginsStanza');
+        const pluginNames = new Set(this.names);
+        this._plugins
+            .filter(p => !!p.plugins && p.plugins.length)
+            .filter(p => !pluginNames.has(p.name)) // TBD: Do we want to filter out existing?
+            .forEach(parent => {
+            ;
+            (parent.plugins || []).forEach(p => {
+                debug(parent.name, 'adding missing plugin', p.name);
+                this.add(p);
+            });
+        });
+    }
+    /**
+     * Handle `dependencies` stanza (which requires dynamic imports)
+     *
+     * Plugins can define `dependencies` as a Set or Array of dependency paths, or a Map with additional opts
+     *
+     * @note
+     * - The default opts for implicit dependencies can be defined using `setDependencyDefaults()`
+     * - Dynamic imports can be avoided by providing plugin modules with `setDependencyResolution()`
+     */
+    resolveDependenciesStanza() {
+        debug('resolveDependenciesStanza');
+        /** Attempt to dynamically require a plugin module */
+        const requireDependencyOrDie = (parentName, dependencyPath) => {
+            // If the user provided the plugin module already we use that
+            if (this._dependencyResolution.has(dependencyPath)) {
+                return this._dependencyResolution.get(dependencyPath);
+            }
+            const possiblePrefixes = ['puppeteer-extra-plugin-']; // could be extended later
+            const isAlreadyPrefixed = possiblePrefixes.some(prefix => dependencyPath.startsWith(prefix));
+            const packagePaths = [];
+            // If the dependency is not already prefixed we attempt to require all possible combinations to find one that works
+            if (!isAlreadyPrefixed) {
+                packagePaths.push(...possiblePrefixes.map(prefix => prefix + dependencyPath));
+            }
+            // We always attempt to require the path verbatim (as a last resort)
+            packagePaths.push(dependencyPath);
+            const pluginModule = (0, loader_1.requirePackages)(packagePaths);
+            if (pluginModule) {
+                return pluginModule;
+            }
+            const explanation = `
+The plugin '${parentName}' listed '${dependencyPath}' as dependency,
+which could not be found. Please install it:
+
+${packagePaths
+                .map(packagePath => `yarn add ${packagePath.split('/')[0]}`)
+                .join(`\n or:\n`)}
+
+Note: You don't need to require the plugin yourself,
+unless you want to modify it's default settings.
+
+If your bundler has issues with dynamic imports take a look at '.plugins.setDependencyResolution()'.
+      `;
+            console.warn(explanation);
+            throw new Error('Plugin dependency not found');
+        };
+        const existingPluginNames = new Set(this.names);
+        const recursivelyLoadMissingDependencies = ({ name: parentName, dependencies }) => {
+            if (!dependencies) {
+                return;
+            }
+            const processDependency = (dependencyPath, opts) => {
+                const pluginModule = requireDependencyOrDie(parentName, dependencyPath);
+                opts = opts || this._dependencyDefaults.get(dependencyPath) || {};
+                const plugin = pluginModule(opts);
+                if (existingPluginNames.has(plugin.name)) {
+                    debug(parentName, '=> dependency already exists:', plugin.name);
+                    return;
+                }
+                existingPluginNames.add(plugin.name);
+                debug(parentName, '=> adding new dependency:', plugin.name, opts);
+                this.add(plugin);
+                return recursivelyLoadMissingDependencies(plugin);
+            };
+            if (dependencies instanceof Set || Array.isArray(dependencies)) {
+                return [...dependencies].forEach(dependencyPath => processDependency(dependencyPath));
+            }
+            if (dependencies instanceof Map) {
+                // Note: `k,v => v,k` (Map + forEach will reverse the order)
+                return dependencies.forEach((v, k) => processDependency(k, v));
+            }
+        };
+        this.list.forEach(recursivelyLoadMissingDependencies);
+    }
+    /**
+     * Lightweight plugin dependency management to require plugins and code mods on demand.
+     * @private
+     */
+    resolveDependencies() {
+        debug('resolveDependencies');
+        this.resolvePluginsStanza();
+        this.resolveDependenciesStanza();
+    }
+}
+exports.PluginList = PluginList;
+//# sourceMappingURL=plugins.js.map

backend/node_modules/playwright-extra/dist/puppeteer-compatiblity-shim/index.d.ts

@@ -0,0 +1,25 @@
+import type * as pw from 'playwright-core';
+export declare type PlaywrightObject = pw.Page | pw.Frame | pw.Browser;
+export interface PuppeteerBrowserShim {
+    isCompatShim?: boolean;
+    isPlaywright?: boolean;
+    pages?: pw.BrowserContext['pages'];
+    userAgent: () => Promise<'string'>;
+}
+export interface PuppeteerPageShim {
+    isCompatShim?: boolean;
+    isPlaywright?: boolean;
+    browser?: () => pw.Browser;
+    evaluateOnNewDocument?: pw.Page['addInitScript'];
+    _client: () => pw.CDPSession;
+}
+export declare const isPlaywrightPage: (obj: unknown) => obj is pw.Page;
+export declare const isPlaywrightFrame: (obj: unknown) => obj is pw.Frame;
+export declare const isPlaywrightBrowser: (obj: unknown) => obj is pw.Browser;
+export declare const isPuppeteerCompat: (obj?: unknown) => obj is PlaywrightObject;
+/** Augment a Playwright object with compatibility with certain Puppeteer methods */
+export declare function addPuppeteerCompat<Input extends pw.Page | pw.Frame | pw.Browser | null>(object: Input): Input;
+export declare function getPageCDPSession(page: pw.Page | pw.Frame): Promise<pw.CDPSession>;
+export declare function getBrowserCDPSession(browser: pw.Browser): Promise<pw.CDPSession>;
+export declare function createPageShim(page: pw.Page | pw.Frame): pw.Page | pw.Frame;
+export declare function createBrowserShim(browser: pw.Browser): pw.Browser;

backend/node_modules/playwright-extra/dist/puppeteer-compatiblity-shim/index.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowserShim = exports.createPageShim = exports.getBrowserCDPSession = exports.getPageCDPSession = exports.addPuppeteerCompat = exports.isPuppeteerCompat = exports.isPlaywrightBrowser = exports.isPlaywrightFrame = exports.isPlaywrightPage = void 0;
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('playwright-extra:puppeteer-compat');
+const isPlaywrightPage = (obj) => {
+    return 'unroute' in obj;
+};
+exports.isPlaywrightPage = isPlaywrightPage;
+const isPlaywrightFrame = (obj) => {
+    return ['parentFrame', 'frameLocator'].every(x => x in obj);
+};
+exports.isPlaywrightFrame = isPlaywrightFrame;
+const isPlaywrightBrowser = (obj) => {
+    return 'newContext' in obj;
+};
+exports.isPlaywrightBrowser = isPlaywrightBrowser;
+const isPuppeteerCompat = (obj) => {
+    return !!obj && typeof obj === 'object' && !!obj.isCompatShim;
+};
+exports.isPuppeteerCompat = isPuppeteerCompat;
+const cache = {
+    objectToShim: new Map(),
+    cdpSession: {
+        page: new Map(),
+        browser: new Map()
+    }
+};
+/** Augment a Playwright object with compatibility with certain Puppeteer methods */
+function addPuppeteerCompat(object) {
+    if (!object || typeof object !== 'object') {
+        return object;
+    }
+    if (cache.objectToShim.has(object)) {
+        return cache.objectToShim.get(object);
+    }
+    if ((0, exports.isPuppeteerCompat)(object)) {
+        return object;
+    }
+    debug('addPuppeteerCompat', cache.objectToShim.size);
+    if ((0, exports.isPlaywrightPage)(object) || (0, exports.isPlaywrightFrame)(object)) {
+        const shim = createPageShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    if ((0, exports.isPlaywrightBrowser)(object)) {
+        const shim = createBrowserShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    debug('Received unknown object:', Reflect.ownKeys(object));
+    return object;
+}
+exports.addPuppeteerCompat = addPuppeteerCompat;
+// Only chromium browsers support CDP
+const dummyCDPClient = {
+    send: async (...args) => {
+        debug('dummy CDP client called', 'send', args);
+    },
+    on: (...args) => {
+        debug('dummy CDP client called', 'on', args);
+    }
+};
+async function getPageCDPSession(page) {
+    let session = cache.cdpSession.page.get(page);
+    if (session) {
+        debug('getPageCDPSession: use existing');
+        return session;
+    }
+    debug('getPageCDPSession: use new');
+    const context = (0, exports.isPlaywrightFrame)(page)
+        ? page.page().context()
+        : page.context();
+    try {
+        session = await context.newCDPSession(page);
+        cache.cdpSession.page.set(page, session);
+        return session;
+    }
+    catch (err) {
+        debug('getPageCDPSession: error while creating session:', err.message);
+        debug('getPageCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+exports.getPageCDPSession = getPageCDPSession;
+async function getBrowserCDPSession(browser) {
+    let session = cache.cdpSession.browser.get(browser);
+    if (session) {
+        debug('getBrowserCDPSession: use existing');
+        return session;
+    }
+    debug('getBrowserCDPSession: use new');
+    try {
+        session = await browser.newBrowserCDPSession();
+        cache.cdpSession.browser.set(browser, session);
+        return session;
+    }
+    catch (err) {
+        debug('getBrowserCDPSession: error while creating session:', err.message);
+        debug('getBrowserCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+exports.getBrowserCDPSession = getBrowserCDPSession;
+function createPageShim(page) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(page, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('page - get', objId, prop);
+            if (prop === '_client') {
+                return () => ({
+                    send: async (method, params) => {
+                        const session = await getPageCDPSession(page);
+                        return await session.send(method, params);
+                    },
+                    on: (event, listener) => {
+                        getPageCDPSession(page).then(session => {
+                            session.on(event, listener);
+                        });
+                    }
+                });
+            }
+            if (prop === 'setBypassCSP') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Page.setBypassCSP', {
+                        enabled
+                    });
+                };
+            }
+            if (prop === 'setUserAgent') {
+                return async (userAgent, userAgentMetadata) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Emulation.setUserAgentOverride', {
+                        userAgent,
+                        userAgentMetadata
+                    });
+                };
+            }
+            if (prop === 'browser') {
+                if ((0, exports.isPlaywrightPage)(page)) {
+                    return () => {
+                        let browser = page.context().browser();
+                        if (!browser) {
+                            debug('page.browser() - not available, most likely due to launchPersistentContext');
+                            // Use a page shim as quick drop-in (so browser.userAgent() still works)
+                            browser = page;
+                        }
+                        return addPuppeteerCompat(browser);
+                    };
+                }
+            }
+            if (prop === 'evaluateOnNewDocument') {
+                if ((0, exports.isPlaywrightPage)(page)) {
+                    return async function (pageFunction, ...args) {
+                        return await page.addInitScript(pageFunction, args[0]);
+                    };
+                }
+            }
+            // Only relevant when page is being used a pseudo stand-in for the browser object (launchPersistentContext)
+            if (prop === 'userAgent') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+exports.createPageShim = createPageShim;
+function createBrowserShim(browser) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(browser, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('browser - get', objId, prop);
+            if (prop === 'pages') {
+                return () => browser
+                    .contexts()
+                    .flatMap(c => c.pages().map(page => addPuppeteerCompat(page)));
+            }
+            if (prop === 'userAgent') {
+                return async () => {
+                    const session = await getBrowserCDPSession(browser);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+exports.createBrowserShim = createBrowserShim;
+//# sourceMappingURL=index.js.map

backend/node_modules/playwright-extra/dist/puppeteer-compatiblity-shim/playwright-shim.d.ts

@@ -0,0 +1,11 @@
+// Playwright objects extended with puppeteer compatiblity shims
+
+import type {} from 'playwright-core'
+
+import type { PuppeteerPageShim, PuppeteerBrowserShim } from '.'
+
+declare module 'playwright-core' {
+  interface Page extends PuppeteerPageShim {}
+  interface Frame extends PuppeteerPageShim {}
+  interface Browser extends PuppeteerBrowserShim {}
+}

backend/node_modules/playwright-extra/dist/types/index.d.ts

@@ -0,0 +1,87 @@
+import type * as pw from 'playwright-core';
+declare type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
+declare type PluginEnv = {
+    framework: 'playwright';
+};
+/** Strongly typed plugin lifecycle events for internal use */
+export declare abstract class PluginLifecycleMethods {
+    onPluginRegistered(env?: PluginEnv): Promise<void>;
+    beforeLaunch(options: pw.LaunchOptions): Promise<pw.LaunchOptions | void>;
+    afterLaunch(browserOrContext?: pw.Browser | pw.BrowserContext): Promise<void>;
+    beforeConnect(options: pw.ConnectOptions): Promise<pw.ConnectOptions | void>;
+    afterConnect(browser: pw.Browser): Promise<void>;
+    onBrowser(browser: pw.Browser): Promise<void>;
+    onPageCreated(page: pw.Page): Promise<void>;
+    onPageClose(page: pw.Page): Promise<void>;
+    onDisconnected(browser?: pw.Browser): Promise<void>;
+    beforeContext(options?: pw.BrowserContextOptions, browser?: pw.Browser): Promise<pw.BrowserContextOptions | void>;
+    onContextCreated(context?: pw.BrowserContext, options?: pw.BrowserContextOptions): Promise<void>;
+}
+/** A valid plugin method name */
+export declare type PluginMethodName = keyof PluginLifecycleMethods;
+/** A valid plugin method function */
+export declare type PluginMethodFn<TName extends PluginMethodName> = PropType<PluginLifecycleMethods, TName>;
+declare type PluginRequirements = Set<'launch' | 'headful' | 'dataFromPlugins' | 'runLast'>;
+declare type PluginDependencies = Set<string> | Map<string, any> | string[];
+interface PluginData {
+    name: string | {
+        [key: string]: any;
+    };
+    value: {
+        [key: string]: any;
+    };
+}
+export interface CompatiblePluginLifecycleMethods {
+    onPluginRegistered(...any: any[]): Promise<any> | any;
+    beforeLaunch(...any: any[]): Promise<any> | any;
+    afterLaunch(...any: any[]): Promise<any> | any;
+    beforeConnect(...any: any[]): Promise<any> | any;
+    afterConnect(...any: any[]): Promise<any> | any;
+    onBrowser(...any: any[]): Promise<any> | any;
+    onPageCreated(...any: any[]): Promise<any> | any;
+    onPageClose(...any: any[]): Promise<any> | any;
+    onDisconnected(...any: any[]): Promise<any> | any;
+    beforeContext(...any: any[]): Promise<any> | any;
+    onContextCreated(...any: any[]): Promise<any> | any;
+}
+/**
+ * PuppeteerExtraPlugin interface, strongly typed for internal use
+ * @private
+ */
+export interface PuppeteerExtraPlugin extends Partial<PluginLifecycleMethods> {
+    _isPuppeteerExtraPlugin: boolean;
+    name: string;
+    /** Disable the puppeteer compatibility shim for this plugin */
+    noPuppeteerShim?: boolean;
+    requirements?: PluginRequirements;
+    dependencies?: PluginDependencies;
+    data?: PluginData[];
+    getDataFromPlugins?(name?: string): void;
+    _registerChildClassMembers?(prototype: any): void;
+    _childClassMembers?: string[];
+    plugins?: CompatiblePlugin[];
+}
+/**
+ * Minimal compatible PuppeteerExtraPlugin interface
+ * @private
+ */
+export interface CompatiblePuppeteerPlugin extends Partial<CompatiblePluginLifecycleMethods> {
+    _isPuppeteerExtraPlugin: boolean;
+    name?: string;
+}
+export interface CompatiblePlaywrightPlugin extends Partial<CompatiblePluginLifecycleMethods> {
+    _isPlaywrightExtraPlugin: boolean;
+    name?: string;
+}
+export interface CompatibleExtraPlugin extends Partial<CompatiblePluginLifecycleMethods> {
+    _isExtraPlugin: boolean;
+    name?: string;
+}
+/**
+ * A compatible plugin
+ */
+export declare type CompatiblePlugin = CompatiblePuppeteerPlugin | CompatiblePlaywrightPlugin | CompatibleExtraPlugin;
+export declare type CompatiblePluginModule = (...args: any[]) => CompatiblePlugin;
+export declare type Plugin = PuppeteerExtraPlugin;
+export declare type PluginModule = (...args: any[]) => Plugin;
+export {};

backend/node_modules/playwright-extra/dist/types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginLifecycleMethods = void 0;
+/** Strongly typed plugin lifecycle events for internal use */
+class PluginLifecycleMethods {
+    async onPluginRegistered(env) { }
+    async beforeLaunch(options) { }
+    async afterLaunch(browserOrContext) { }
+    async beforeConnect(options) { }
+    async afterConnect(browser) { }
+    async onBrowser(browser) { }
+    async onPageCreated(page) { }
+    async onPageClose(page) { }
+    async onDisconnected(browser) { }
+    // Playwright only at the moment
+    async beforeContext(options, browser) { }
+    async onContextCreated(context, options) { }
+}
+exports.PluginLifecycleMethods = PluginLifecycleMethods;
+//# sourceMappingURL=index.js.map

backend/node_modules/playwright-extra/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;AAKA,8DAA8D;AAC9D,MAAsB,sBAAsB;IAC1C,KAAK,CAAC,kBAAkB,CAAC,GAAe,IAAkB,CAAC;IAC3D,KAAK,CAAC,YAAY,CAChB,OAAyB,IACU,CAAC;IACtC,KAAK,CAAC,WAAW,CAAC,gBAAiD,IAAG,CAAC;IACvE,KAAK,CAAC,aAAa,CACjB,OAA0B,IACU,CAAC;IACvC,KAAK,CAAC,YAAY,CAAC,OAAmB,IAAG,CAAC;IAC1C,KAAK,CAAC,SAAS,CAAC,OAAmB,IAAG,CAAC;IACvC,KAAK,CAAC,aAAa,CAAC,IAAa,IAAG,CAAC;IACrC,KAAK,CAAC,WAAW,CAAC,IAAa,IAAG,CAAC;IACnC,KAAK,CAAC,cAAc,CAAC,OAAoB,IAAG,CAAC;IAC7C,gCAAgC;IAChC,KAAK,CAAC,aAAa,CACjB,OAAkC,EAClC,OAAoB,IACuB,CAAC;IAC9C,KAAK,CAAC,gBAAgB,CACpB,OAA2B,EAC3B,OAAkC,IACjC,CAAC;CACL;AAvBD,wDAuBC"}

backend/node_modules/playwright-extra/node_modules/debug/LICENSE

@@ -0,0 +1,20 @@
+(The MIT License)
+
+Copyright (c) 2014-2017 TJ Holowaychuk <tj@vision-media.ca>
+Copyright (c) 2018-2021 Josh Junon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the 'Software'), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

backend/node_modules/playwright-extra/node_modules/debug/README.md

@@ -0,0 +1,481 @@
+# debug
+[![OpenCollective](https://opencollective.com/debug/backers/badge.svg)](#backers)
+[![OpenCollective](https://opencollective.com/debug/sponsors/badge.svg)](#sponsors)
+
+<img width="647" src="https://user-images.githubusercontent.com/71256/29091486-fa38524c-7c37-11e7-895f-e7ec8e1039b6.png">
+
+A tiny JavaScript debugging utility modelled after Node.js core's debugging
+technique. Works in Node.js and web browsers.
+
+## Installation
+
+```bash
+$ npm install debug
+```
+
+## Usage
+
+`debug` exposes a function; simply pass this function the name of your module, and it will return a decorated version of `console.error` for you to pass debug statements to. This will allow you to toggle the debug output for different parts of your module as well as the module as a whole.
+
+Example [_app.js_](./examples/node/app.js):
+
+```js
+var debug = require('debug')('http')
+  , http = require('http')
+  , name = 'My App';
+
+// fake app
+
+debug('booting %o', name);
+
+http.createServer(function(req, res){
+  debug(req.method + ' ' + req.url);
+  res.end('hello\n');
+}).listen(3000, function(){
+  debug('listening');
+});
+
+// fake worker of some kind
+
+require('./worker');
+```
+
+Example [_worker.js_](./examples/node/worker.js):
+
+```js
+var a = require('debug')('worker:a')
+  , b = require('debug')('worker:b');
+
+function work() {
+  a('doing lots of uninteresting work');
+  setTimeout(work, Math.random() * 1000);
+}
+
+work();
+
+function workb() {
+  b('doing some work');
+  setTimeout(workb, Math.random() * 2000);
+}
+
+workb();
+```
+
+The `DEBUG` environment variable is then used to enable these based on space or
+comma-delimited names.
+
+Here are some examples:
+
+<img width="647" alt="screen shot 2017-08-08 at 12 53 04 pm" src="https://user-images.githubusercontent.com/71256/29091703-a6302cdc-7c38-11e7-8304-7c0b3bc600cd.png">
+<img width="647" alt="screen shot 2017-08-08 at 12 53 38 pm" src="https://user-images.githubusercontent.com/71256/29091700-a62a6888-7c38-11e7-800b-db911291ca2b.png">
+<img width="647" alt="screen shot 2017-08-08 at 12 53 25 pm" src="https://user-images.githubusercontent.com/71256/29091701-a62ea114-7c38-11e7-826a-2692bedca740.png">
+
+#### Windows command prompt notes
+
+##### CMD
+
+On Windows the environment variable is set using the `set` command.
+
+```cmd
+set DEBUG=*,-not_this
+```
+
+Example:
+
+```cmd
+set DEBUG=* & node app.js
+```
+
+##### PowerShell (VS Code default)
+
+PowerShell uses different syntax to set environment variables.
+
+```cmd
+$env:DEBUG = "*,-not_this"
+```
+
+Example:
+
+```cmd
+$env:DEBUG='app';node app.js
+```
+
+Then, run the program to be debugged as usual.
+
+npm script example:
+```js
+  "windowsDebug": "@powershell -Command $env:DEBUG='*';node app.js",
+```
+
+## Namespace Colors
+
+Every debug instance has a color generated for it based on its namespace name.
+This helps when visually parsing the debug output to identify which debug instance
+a debug line belongs to.
+
+#### Node.js
+
+In Node.js, colors are enabled when stderr is a TTY. You also _should_ install
+the [`supports-color`](https://npmjs.org/supports-color) module alongside debug,
+otherwise debug will only use a small handful of basic colors.
+
+<img width="521" src="https://user-images.githubusercontent.com/71256/29092181-47f6a9e6-7c3a-11e7-9a14-1928d8a711cd.png">
+
+#### Web Browser
+
+Colors are also enabled on "Web Inspectors" that understand the `%c` formatting
+option. These are WebKit web inspectors, Firefox ([since version
+31](https://hacks.mozilla.org/2014/05/editable-box-model-multiple-selection-sublime-text-keys-much-more-firefox-developer-tools-episode-31/))
+and the Firebug plugin for Firefox (any version).
+
+<img width="524" src="https://user-images.githubusercontent.com/71256/29092033-b65f9f2e-7c39-11e7-8e32-f6f0d8e865c1.png">
+
+
+## Millisecond diff
+
+When actively developing an application it can be useful to see when the time spent between one `debug()` call and the next. Suppose for example you invoke `debug()` before requesting a resource, and after as well, the "+NNNms" will show you how much time was spent between calls.
+
+<img width="647" src="https://user-images.githubusercontent.com/71256/29091486-fa38524c-7c37-11e7-895f-e7ec8e1039b6.png">
+
+When stdout is not a TTY, `Date#toISOString()` is used, making it more useful for logging the debug information as shown below:
+
+<img width="647" src="https://user-images.githubusercontent.com/71256/29091956-6bd78372-7c39-11e7-8c55-c948396d6edd.png">
+
+
+## Conventions
+
+If you're using this in one or more of your libraries, you _should_ use the name of your library so that developers may toggle debugging as desired without guessing names. If you have more than one debuggers you _should_ prefix them with your library name and use ":" to separate features. For example "bodyParser" from Connect would then be "connect:bodyParser".  If you append a "*" to the end of your name, it will always be enabled regardless of the setting of the DEBUG environment variable.  You can then use it for normal output as well as debug output.
+
+## Wildcards
+
+The `*` character may be used as a wildcard. Suppose for example your library has
+debuggers named "connect:bodyParser", "connect:compress", "connect:session",
+instead of listing all three with
+`DEBUG=connect:bodyParser,connect:compress,connect:session`, you may simply do
+`DEBUG=connect:*`, or to run everything using this module simply use `DEBUG=*`.
+
+You can also exclude specific debuggers by prefixing them with a "-" character.
+For example, `DEBUG=*,-connect:*` would include all debuggers except those
+starting with "connect:".
+
+## Environment Variables
+
+When running through Node.js, you can set a few environment variables that will
+change the behavior of the debug logging:
+
+| Name      | Purpose                                         |
+|-----------|-------------------------------------------------|
+| `DEBUG`   | Enables/disables specific debugging namespaces. |
+| `DEBUG_HIDE_DATE` | Hide date from debug output (non-TTY).  |
+| `DEBUG_COLORS`| Whether or not to use colors in the debug output. |
+| `DEBUG_DEPTH` | Object inspection depth.                    |
+| `DEBUG_SHOW_HIDDEN` | Shows hidden properties on inspected objects. |
+
+
+__Note:__ The environment variables beginning with `DEBUG_` end up being
+converted into an Options object that gets used with `%o`/`%O` formatters.
+See the Node.js documentation for
+[`util.inspect()`](https://nodejs.org/api/util.html#util_util_inspect_object_options)
+for the complete list.
+
+## Formatters
+
+Debug uses [printf-style](https://wikipedia.org/wiki/Printf_format_string) formatting.
+Below are the officially supported formatters:
+
+| Formatter | Representation |
+|-----------|----------------|
+| `%O`      | Pretty-print an Object on multiple lines. |
+| `%o`      | Pretty-print an Object all on a single line. |
+| `%s`      | String. |
+| `%d`      | Number (both integer and float). |
+| `%j`      | JSON. Replaced with the string '[Circular]' if the argument contains circular references. |
+| `%%`      | Single percent sign ('%'). This does not consume an argument. |
+
+
+### Custom formatters
+
+You can add custom formatters by extending the `debug.formatters` object.
+For example, if you wanted to add support for rendering a Buffer as hex with
+`%h`, you could do something like:
+
+```js
+const createDebug = require('debug')
+createDebug.formatters.h = (v) => {
+  return v.toString('hex')
+}
+
+// …elsewhere
+const debug = createDebug('foo')
+debug('this is hex: %h', new Buffer('hello world'))
+//   foo this is hex: 68656c6c6f20776f726c6421 +0ms
+```
+
+
+## Browser Support
+
+You can build a browser-ready script using [browserify](https://github.com/substack/node-browserify),
+or just use the [browserify-as-a-service](https://wzrd.in/) [build](https://wzrd.in/standalone/debug@latest),
+if you don't want to build it yourself.
+
+Debug's enable state is currently persisted by `localStorage`.
+Consider the situation shown below where you have `worker:a` and `worker:b`,
+and wish to debug both. You can enable this using `localStorage.debug`:
+
+```js
+localStorage.debug = 'worker:*'
+```
+
+And then refresh the page.
+
+```js
+a = debug('worker:a');
+b = debug('worker:b');
+
+setInterval(function(){
+  a('doing some work');
+}, 1000);
+
+setInterval(function(){
+  b('doing some work');
+}, 1200);
+```
+
+In Chromium-based web browsers (e.g. Brave, Chrome, and Electron), the JavaScript console will—by default—only show messages logged by `debug` if the "Verbose" log level is _enabled_.
+
+<img width="647" src="https://user-images.githubusercontent.com/7143133/152083257-29034707-c42c-4959-8add-3cee850e6fcf.png">
+
+## Output streams
+
+  By default `debug` will log to stderr, however this can be configured per-namespace by overriding the `log` method:
+
+Example [_stdout.js_](./examples/node/stdout.js):
+
+```js
+var debug = require('debug');
+var error = debug('app:error');
+
+// by default stderr is used
+error('goes to stderr!');
+
+var log = debug('app:log');
+// set this namespace to log via console.log
+log.log = console.log.bind(console); // don't forget to bind to console!
+log('goes to stdout');
+error('still goes to stderr!');
+
+// set all output to go via console.info
+// overrides all per-namespace log settings
+debug.log = console.info.bind(console);
+error('now goes to stdout via console.info');
+log('still goes to stdout, but via console.info now');
+```
+
+## Extend
+You can simply extend debugger 
+```js
+const log = require('debug')('auth');
+
+//creates new debug instance with extended namespace
+const logSign = log.extend('sign');
+const logLogin = log.extend('login');
+
+log('hello'); // auth hello
+logSign('hello'); //auth:sign hello
+logLogin('hello'); //auth:login hello
+```
+
+## Set dynamically
+
+You can also enable debug dynamically by calling the `enable()` method :
+
+```js
+let debug = require('debug');
+
+console.log(1, debug.enabled('test'));
+
+debug.enable('test');
+console.log(2, debug.enabled('test'));
+
+debug.disable();
+console.log(3, debug.enabled('test'));
+
+```
+
+print :   
+```
+1 false
+2 true
+3 false
+```
+
+Usage :  
+`enable(namespaces)`  
+`namespaces` can include modes separated by a colon and wildcards.
+   
+Note that calling `enable()` completely overrides previously set DEBUG variable : 
+
+```
+$ DEBUG=foo node -e 'var dbg = require("debug"); dbg.enable("bar"); console.log(dbg.enabled("foo"))'
+=> false
+```
+
+`disable()`
+
+Will disable all namespaces. The functions returns the namespaces currently
+enabled (and skipped). This can be useful if you want to disable debugging
+temporarily without knowing what was enabled to begin with.
+
+For example:
+
+```js
+let debug = require('debug');
+debug.enable('foo:*,-foo:bar');
+let namespaces = debug.disable();
+debug.enable(namespaces);
+```
+
+Note: There is no guarantee that the string will be identical to the initial
+enable string, but semantically they will be identical.
+
+## Checking whether a debug target is enabled
+
+After you've created a debug instance, you can determine whether or not it is
+enabled by checking the `enabled` property:
+
+```javascript
+const debug = require('debug')('http');
+
+if (debug.enabled) {
+  // do stuff...
+}
+```
+
+You can also manually toggle this property to force the debug instance to be
+enabled or disabled.
+
+## Usage in child processes
+
+Due to the way `debug` detects if the output is a TTY or not, colors are not shown in child processes when `stderr` is piped. A solution is to pass the `DEBUG_COLORS=1` environment variable to the child process.  
+For example:
+
+```javascript
+worker = fork(WORKER_WRAP_PATH, [workerPath], {
+  stdio: [
+    /* stdin: */ 0,
+    /* stdout: */ 'pipe',
+    /* stderr: */ 'pipe',
+    'ipc',
+  ],
+  env: Object.assign({}, process.env, {
+    DEBUG_COLORS: 1 // without this settings, colors won't be shown
+  }),
+});
+
+worker.stderr.pipe(process.stderr, { end: false });
+```
+
+
+## Authors
+
+ - TJ Holowaychuk
+ - Nathan Rajlich
+ - Andrew Rhyne
+ - Josh Junon
+
+## Backers
+
+Support us with a monthly donation and help us continue our activities. [[Become a backer](https://opencollective.com/debug#backer)]
+
+<a href="https://opencollective.com/debug/backer/0/website" target="_blank"><img src="https://opencollective.com/debug/backer/0/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/1/website" target="_blank"><img src="https://opencollective.com/debug/backer/1/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/2/website" target="_blank"><img src="https://opencollective.com/debug/backer/2/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/3/website" target="_blank"><img src="https://opencollective.com/debug/backer/3/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/4/website" target="_blank"><img src="https://opencollective.com/debug/backer/4/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/5/website" target="_blank"><img src="https://opencollective.com/debug/backer/5/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/6/website" target="_blank"><img src="https://opencollective.com/debug/backer/6/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/7/website" target="_blank"><img src="https://opencollective.com/debug/backer/7/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/8/website" target="_blank"><img src="https://opencollective.com/debug/backer/8/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/9/website" target="_blank"><img src="https://opencollective.com/debug/backer/9/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/10/website" target="_blank"><img src="https://opencollective.com/debug/backer/10/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/11/website" target="_blank"><img src="https://opencollective.com/debug/backer/11/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/12/website" target="_blank"><img src="https://opencollective.com/debug/backer/12/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/13/website" target="_blank"><img src="https://opencollective.com/debug/backer/13/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/14/website" target="_blank"><img src="https://opencollective.com/debug/backer/14/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/15/website" target="_blank"><img src="https://opencollective.com/debug/backer/15/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/16/website" target="_blank"><img src="https://opencollective.com/debug/backer/16/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/17/website" target="_blank"><img src="https://opencollective.com/debug/backer/17/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/18/website" target="_blank"><img src="https://opencollective.com/debug/backer/18/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/19/website" target="_blank"><img src="https://opencollective.com/debug/backer/19/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/20/website" target="_blank"><img src="https://opencollective.com/debug/backer/20/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/21/website" target="_blank"><img src="https://opencollective.com/debug/backer/21/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/22/website" target="_blank"><img src="https://opencollective.com/debug/backer/22/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/23/website" target="_blank"><img src="https://opencollective.com/debug/backer/23/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/24/website" target="_blank"><img src="https://opencollective.com/debug/backer/24/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/25/website" target="_blank"><img src="https://opencollective.com/debug/backer/25/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/26/website" target="_blank"><img src="https://opencollective.com/debug/backer/26/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/27/website" target="_blank"><img src="https://opencollective.com/debug/backer/27/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/28/website" target="_blank"><img src="https://opencollective.com/debug/backer/28/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/29/website" target="_blank"><img src="https://opencollective.com/debug/backer/29/avatar.svg"></a>
+
+
+## Sponsors
+
+Become a sponsor and get your logo on our README on Github with a link to your site. [[Become a sponsor](https://opencollective.com/debug#sponsor)]
+
+<a href="https://opencollective.com/debug/sponsor/0/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/1/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/2/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/3/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/4/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/5/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/6/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/7/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/8/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/9/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/9/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/10/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/10/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/11/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/11/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/12/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/12/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/13/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/13/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/14/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/14/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/15/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/15/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/16/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/16/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/17/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/17/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/18/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/18/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/19/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/19/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/20/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/20/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/21/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/21/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/22/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/22/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/23/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/23/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/24/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/24/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/25/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/25/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/26/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/26/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/27/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/27/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/28/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/28/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/29/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/29/avatar.svg"></a>
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2014-2017 TJ Holowaychuk &lt;tj@vision-media.ca&gt;
+Copyright (c) 2018-2021 Josh Junon
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

backend/node_modules/playwright-extra/node_modules/debug/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "debug",
+  "version": "4.4.3",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/debug-js/debug.git"
+  },
+  "description": "Lightweight debugging utility for Node.js and the browser",
+  "keywords": [
+    "debug",
+    "log",
+    "debugger"
+  ],
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "author": "Josh Junon (https://github.com/qix-)",
+  "contributors": [
+    "TJ Holowaychuk <tj@vision-media.ca>",
+    "Nathan Rajlich <nathan@tootallnate.net> (http://n8.io)",
+    "Andrew Rhyne <rhyneandrew@gmail.com>"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "lint": "xo",
+    "test": "npm run test:node && npm run test:browser && npm run lint",
+    "test:node": "mocha test.js test.node.js",
+    "test:browser": "karma start --single-run",
+    "test:coverage": "cat ./coverage/lcov.info | coveralls"
+  },
+  "dependencies": {
+    "ms": "^2.1.3"
+  },
+  "devDependencies": {
+    "brfs": "^2.0.1",
+    "browserify": "^16.2.3",
+    "coveralls": "^3.0.2",
+    "karma": "^3.1.4",
+    "karma-browserify": "^6.0.0",
+    "karma-chrome-launcher": "^2.2.0",
+    "karma-mocha": "^1.3.0",
+    "mocha": "^5.2.0",
+    "mocha-lcov-reporter": "^1.2.0",
+    "sinon": "^14.0.0",
+    "xo": "^0.23.0"
+  },
+  "peerDependenciesMeta": {
+    "supports-color": {
+      "optional": true
+    }
+  },
+  "main": "./src/index.js",
+  "browser": "./src/browser.js",
+  "engines": {
+    "node": ">=6.0"
+  },
+  "xo": {
+    "rules": {
+      "import/extensions": "off"
+    }
+  }
+}

backend/node_modules/playwright-extra/node_modules/debug/src/browser.js

@@ -0,0 +1,272 @@
+/* eslint-env browser */
+
+/**
+ * This is the web browser implementation of `debug()`.
+ */
+
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = localstorage();
+exports.destroy = (() => {
+	let warned = false;
+
+	return () => {
+		if (!warned) {
+			warned = true;
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
+	};
+})();
+
+/**
+ * Colors.
+ */
+
+exports.colors = [
+	'#0000CC',
+	'#0000FF',
+	'#0033CC',
+	'#0033FF',
+	'#0066CC',
+	'#0066FF',
+	'#0099CC',
+	'#0099FF',
+	'#00CC00',
+	'#00CC33',
+	'#00CC66',
+	'#00CC99',
+	'#00CCCC',
+	'#00CCFF',
+	'#3300CC',
+	'#3300FF',
+	'#3333CC',
+	'#3333FF',
+	'#3366CC',
+	'#3366FF',
+	'#3399CC',
+	'#3399FF',
+	'#33CC00',
+	'#33CC33',
+	'#33CC66',
+	'#33CC99',
+	'#33CCCC',
+	'#33CCFF',
+	'#6600CC',
+	'#6600FF',
+	'#6633CC',
+	'#6633FF',
+	'#66CC00',
+	'#66CC33',
+	'#9900CC',
+	'#9900FF',
+	'#9933CC',
+	'#9933FF',
+	'#99CC00',
+	'#99CC33',
+	'#CC0000',
+	'#CC0033',
+	'#CC0066',
+	'#CC0099',
+	'#CC00CC',
+	'#CC00FF',
+	'#CC3300',
+	'#CC3333',
+	'#CC3366',
+	'#CC3399',
+	'#CC33CC',
+	'#CC33FF',
+	'#CC6600',
+	'#CC6633',
+	'#CC9900',
+	'#CC9933',
+	'#CCCC00',
+	'#CCCC33',
+	'#FF0000',
+	'#FF0033',
+	'#FF0066',
+	'#FF0099',
+	'#FF00CC',
+	'#FF00FF',
+	'#FF3300',
+	'#FF3333',
+	'#FF3366',
+	'#FF3399',
+	'#FF33CC',
+	'#FF33FF',
+	'#FF6600',
+	'#FF6633',
+	'#FF9900',
+	'#FF9933',
+	'#FFCC00',
+	'#FFCC33'
+];
+
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
+
+// eslint-disable-next-line complexity
+function useColors() {
+	// NB: In an Electron preload script, document will be defined but not fully
+	// initialized. Since we know we're in Chrome, we'll just detect this case
+	// explicitly
+	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+		return true;
+	}
+
+	// Internet Explorer and Edge do not support colors.
+	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+		return false;
+	}
+
+	let m;
+
+	// Is webkit? http://stackoverflow.com/a/16459606/376773
+	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+	// eslint-disable-next-line no-return-assign
+	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+		// Is firebug? http://stackoverflow.com/a/398120/376773
+		(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+		// Is firefox >= v31?
+		// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+		(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
+		// Double check webkit in userAgent just in case we are in a worker
+		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+}
+
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+	args[0] = (this.useColors ? '%c' : '') +
+		this.namespace +
+		(this.useColors ? ' %c' : ' ') +
+		args[0] +
+		(this.useColors ? '%c ' : ' ') +
+		'+' + module.exports.humanize(this.diff);
+
+	if (!this.useColors) {
+		return;
+	}
+
+	const c = 'color: ' + this.color;
+	args.splice(1, 0, c, 'color: inherit');
+
+	// The final "%c" is somewhat tricky, because there could be other
+	// arguments passed either before or after the %c, so we need to
+	// figure out the correct index to insert the CSS into
+	let index = 0;
+	let lastC = 0;
+	args[0].replace(/%[a-zA-Z%]/g, match => {
+		if (match === '%%') {
+			return;
+		}
+		index++;
+		if (match === '%c') {
+			// We only are interested in the *last* %c
+			// (the user may have provided their own)
+			lastC = index;
+		}
+	});
+
+	args.splice(lastC, 0, c);
+}
+
+/**
+ * Invokes `console.debug()` when available.
+ * No-op when `console.debug` is not a "function".
+ * If `console.debug` is not available, falls back
+ * to `console.log`.
+ *
+ * @api public
+ */
+exports.log = console.debug || console.log || (() => {});
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+function save(namespaces) {
+	try {
+		if (namespaces) {
+			exports.storage.setItem('debug', namespaces);
+		} else {
+			exports.storage.removeItem('debug');
+		}
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+function load() {
+	let r;
+	try {
+		r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG') ;
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+
+	// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+	if (!r && typeof process !== 'undefined' && 'env' in process) {
+		r = process.env.DEBUG;
+	}
+
+	return r;
+}
+
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+function localstorage() {
+	try {
+		// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+		// The Browser also has localStorage in the global context.
+		return localStorage;
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+}
+
+module.exports = require('./common')(exports);
+
+const {formatters} = module.exports;
+
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+formatters.j = function (v) {
+	try {
+		return JSON.stringify(v);
+	} catch (error) {
+		return '[UnexpectedJSONParseError]: ' + error.message;
+	}
+};

backend/node_modules/playwright-extra/node_modules/debug/src/common.js

@@ -0,0 +1,292 @@
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ */
+
+function setup(env) {
+	createDebug.debug = createDebug;
+	createDebug.default = createDebug;
+	createDebug.coerce = coerce;
+	createDebug.disable = disable;
+	createDebug.enable = enable;
+	createDebug.enabled = enabled;
+	createDebug.humanize = require('ms');
+	createDebug.destroy = destroy;
+
+	Object.keys(env).forEach(key => {
+		createDebug[key] = env[key];
+	});
+
+	/**
+	* The currently active debug mode names, and names to skip.
+	*/
+
+	createDebug.names = [];
+	createDebug.skips = [];
+
+	/**
+	* Map of special "%n" handling functions, for the debug "format" argument.
+	*
+	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	*/
+	createDebug.formatters = {};
+
+	/**
+	* Selects a color for a debug namespace
+	* @param {String} namespace The namespace string for the debug instance to be colored
+	* @return {Number|String} An ANSI color code for the given namespace
+	* @api private
+	*/
+	function selectColor(namespace) {
+		let hash = 0;
+
+		for (let i = 0; i < namespace.length; i++) {
+			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+			hash |= 0; // Convert to 32bit integer
+		}
+
+		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+	}
+	createDebug.selectColor = selectColor;
+
+	/**
+	* Create a debugger with the given `namespace`.
+	*
+	* @param {String} namespace
+	* @return {Function}
+	* @api public
+	*/
+	function createDebug(namespace) {
+		let prevTime;
+		let enableOverride = null;
+		let namespacesCache;
+		let enabledCache;
+
+		function debug(...args) {
+			// Disabled?
+			if (!debug.enabled) {
+				return;
+			}
+
+			const self = debug;
+
+			// Set `diff` timestamp
+			const curr = Number(new Date());
+			const ms = curr - (prevTime || curr);
+			self.diff = ms;
+			self.prev = prevTime;
+			self.curr = curr;
+			prevTime = curr;
+
+			args[0] = createDebug.coerce(args[0]);
+
+			if (typeof args[0] !== 'string') {
+				// Anything else let's inspect with %O
+				args.unshift('%O');
+			}
+
+			// Apply any `formatters` transformations
+			let index = 0;
+			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+				// If we encounter an escaped % then don't increase the array index
+				if (match === '%%') {
+					return '%';
+				}
+				index++;
+				const formatter = createDebug.formatters[format];
+				if (typeof formatter === 'function') {
+					const val = args[index];
+					match = formatter.call(self, val);
+
+					// Now we need to remove `args[index]` since it's inlined in the `format`
+					args.splice(index, 1);
+					index--;
+				}
+				return match;
+			});
+
+			// Apply env-specific formatting (colors, etc.)
+			createDebug.formatArgs.call(self, args);
+
+			const logFn = self.log || createDebug.log;
+			logFn.apply(self, args);
+		}
+
+		debug.namespace = namespace;
+		debug.useColors = createDebug.useColors();
+		debug.color = createDebug.selectColor(namespace);
+		debug.extend = extend;
+		debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+		Object.defineProperty(debug, 'enabled', {
+			enumerable: true,
+			configurable: false,
+			get: () => {
+				if (enableOverride !== null) {
+					return enableOverride;
+				}
+				if (namespacesCache !== createDebug.namespaces) {
+					namespacesCache = createDebug.namespaces;
+					enabledCache = createDebug.enabled(namespace);
+				}
+
+				return enabledCache;
+			},
+			set: v => {
+				enableOverride = v;
+			}
+		});
+
+		// Env-specific initialization logic for debug instances
+		if (typeof createDebug.init === 'function') {
+			createDebug.init(debug);
+		}
+
+		return debug;
+	}
+
+	function extend(namespace, delimiter) {
+		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+		newDebug.log = this.log;
+		return newDebug;
+	}
+
+	/**
+	* Enables a debug mode by namespaces. This can include modes
+	* separated by a colon and wildcards.
+	*
+	* @param {String} namespaces
+	* @api public
+	*/
+	function enable(namespaces) {
+		createDebug.save(namespaces);
+		createDebug.namespaces = namespaces;
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		const split = (typeof namespaces === 'string' ? namespaces : '')
+			.trim()
+			.replace(/\s+/g, ',')
+			.split(',')
+			.filter(Boolean);
+
+		for (const ns of split) {
+			if (ns[0] === '-') {
+				createDebug.skips.push(ns.slice(1));
+			} else {
+				createDebug.names.push(ns);
+			}
+		}
+	}
+
+	/**
+	 * Checks if the given string matches a namespace template, honoring
+	 * asterisks as wildcards.
+	 *
+	 * @param {String} search
+	 * @param {String} template
+	 * @return {Boolean}
+	 */
+	function matchesTemplate(search, template) {
+		let searchIndex = 0;
+		let templateIndex = 0;
+		let starIndex = -1;
+		let matchIndex = 0;
+
+		while (searchIndex < search.length) {
+			if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {
+				// Match character or proceed with wildcard
+				if (template[templateIndex] === '*') {
+					starIndex = templateIndex;
+					matchIndex = searchIndex;
+					templateIndex++; // Skip the '*'
+				} else {
+					searchIndex++;
+					templateIndex++;
+				}
+			} else if (starIndex !== -1) { // eslint-disable-line no-negated-condition
+				// Backtrack to the last '*' and try to match more characters
+				templateIndex = starIndex + 1;
+				matchIndex++;
+				searchIndex = matchIndex;
+			} else {
+				return false; // No match
+			}
+		}
+
+		// Handle trailing '*' in template
+		while (templateIndex < template.length && template[templateIndex] === '*') {
+			templateIndex++;
+		}
+
+		return templateIndex === template.length;
+	}
+
+	/**
+	* Disable debug output.
+	*
+	* @return {String} namespaces
+	* @api public
+	*/
+	function disable() {
+		const namespaces = [
+			...createDebug.names,
+			...createDebug.skips.map(namespace => '-' + namespace)
+		].join(',');
+		createDebug.enable('');
+		return namespaces;
+	}
+
+	/**
+	* Returns true if the given mode name is enabled, false otherwise.
+	*
+	* @param {String} name
+	* @return {Boolean}
+	* @api public
+	*/
+	function enabled(name) {
+		for (const skip of createDebug.skips) {
+			if (matchesTemplate(name, skip)) {
+				return false;
+			}
+		}
+
+		for (const ns of createDebug.names) {
+			if (matchesTemplate(name, ns)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	* Coerce `val`.
+	*
+	* @param {Mixed} val
+	* @return {Mixed}
+	* @api private
+	*/
+	function coerce(val) {
+		if (val instanceof Error) {
+			return val.stack || val.message;
+		}
+		return val;
+	}
+
+	/**
+	* XXX DO NOT USE. This is a temporary stub function.
+	* XXX It WILL be removed in the next major release.
+	*/
+	function destroy() {
+		console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+	}
+
+	createDebug.enable(createDebug.load());
+
+	return createDebug;
+}
+
+module.exports = setup;

backend/node_modules/playwright-extra/node_modules/debug/src/index.js

@@ -0,0 +1,10 @@
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+	module.exports = require('./browser.js');
+} else {
+	module.exports = require('./node.js');
+}

backend/node_modules/playwright-extra/node_modules/debug/src/node.js

@@ -0,0 +1,263 @@
+/**
+ * Module dependencies.
+ */
+
+const tty = require('tty');
+const util = require('util');
+
+/**
+ * This is the Node.js implementation of `debug()`.
+ */
+
+exports.init = init;
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.destroy = util.deprecate(
+	() => {},
+	'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+);
+
+/**
+ * Colors.
+ */
+
+exports.colors = [6, 2, 3, 4, 5, 1];
+
+try {
+	// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+	// eslint-disable-next-line import/no-extraneous-dependencies
+	const supportsColor = require('supports-color');
+
+	if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+		exports.colors = [
+			20,
+			21,
+			26,
+			27,
+			32,
+			33,
+			38,
+			39,
+			40,
+			41,
+			42,
+			43,
+			44,
+			45,
+			56,
+			57,
+			62,
+			63,
+			68,
+			69,
+			74,
+			75,
+			76,
+			77,
+			78,
+			79,
+			80,
+			81,
+			92,
+			93,
+			98,
+			99,
+			112,
+			113,
+			128,
+			129,
+			134,
+			135,
+			148,
+			149,
+			160,
+			161,
+			162,
+			163,
+			164,
+			165,
+			166,
+			167,
+			168,
+			169,
+			170,
+			171,
+			172,
+			173,
+			178,
+			179,
+			184,
+			185,
+			196,
+			197,
+			198,
+			199,
+			200,
+			201,
+			202,
+			203,
+			204,
+			205,
+			206,
+			207,
+			208,
+			209,
+			214,
+			215,
+			220,
+			221
+		];
+	}
+} catch (error) {
+	// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+}
+
+/**
+ * Build up the default `inspectOpts` object from the environment variables.
+ *
+ *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ */
+
+exports.inspectOpts = Object.keys(process.env).filter(key => {
+	return /^debug_/i.test(key);
+}).reduce((obj, key) => {
+	// Camel-case
+	const prop = key
+		.substring(6)
+		.toLowerCase()
+		.replace(/_([a-z])/g, (_, k) => {
+			return k.toUpperCase();
+		});
+
+	// Coerce string value into JS value
+	let val = process.env[key];
+	if (/^(yes|on|true|enabled)$/i.test(val)) {
+		val = true;
+	} else if (/^(no|off|false|disabled)$/i.test(val)) {
+		val = false;
+	} else if (val === 'null') {
+		val = null;
+	} else {
+		val = Number(val);
+	}
+
+	obj[prop] = val;
+	return obj;
+}, {});
+
+/**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */
+
+function useColors() {
+	return 'colors' in exports.inspectOpts ?
+		Boolean(exports.inspectOpts.colors) :
+		tty.isatty(process.stderr.fd);
+}
+
+/**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+	const {namespace: name, useColors} = this;
+
+	if (useColors) {
+		const c = this.color;
+		const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+
+		args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+		args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+	} else {
+		args[0] = getDate() + name + ' ' + args[0];
+	}
+}
+
+function getDate() {
+	if (exports.inspectOpts.hideDate) {
+		return '';
+	}
+	return new Date().toISOString() + ' ';
+}
+
+/**
+ * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
+ */
+
+function log(...args) {
+	return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
+}
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+function save(namespaces) {
+	if (namespaces) {
+		process.env.DEBUG = namespaces;
+	} else {
+		// If you set a process.env field to null or undefined, it gets cast to the
+		// string 'null' or 'undefined'. Just delete instead.
+		delete process.env.DEBUG;
+	}
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+function load() {
+	return process.env.DEBUG;
+}
+
+/**
+ * Init logic for `debug` instances.
+ *
+ * Create a new `inspectOpts` object in case `useColors` is set
+ * differently for a particular `debug` instance.
+ */
+
+function init(debug) {
+	debug.inspectOpts = {};
+
+	const keys = Object.keys(exports.inspectOpts);
+	for (let i = 0; i < keys.length; i++) {
+		debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+	}
+}
+
+module.exports = require('./common')(exports);
+
+const {formatters} = module.exports;
+
+/**
+ * Map %o to `util.inspect()`, all on a single line.
+ */
+
+formatters.o = function (v) {
+	this.inspectOpts.colors = this.useColors;
+	return util.inspect(v, this.inspectOpts)
+		.split('\n')
+		.map(str => str.trim())
+		.join(' ');
+};
+
+/**
+ * Map %O to `util.inspect()`, allowing multiple lines if needed.
+ */
+
+formatters.O = function (v) {
+	this.inspectOpts.colors = this.useColors;
+	return util.inspect(v, this.inspectOpts);
+};

backend/node_modules/playwright-extra/node_modules/ms/index.js

@@ -0,0 +1,162 @@
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function (val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isFinite(val)) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}

backend/node_modules/playwright-extra/node_modules/ms/license.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Vercel, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backend/node_modules/playwright-extra/node_modules/ms/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "ms",
+  "version": "2.1.3",
+  "description": "Tiny millisecond conversion utility",
+  "repository": "vercel/ms",
+  "main": "./index",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "precommit": "lint-staged",
+    "lint": "eslint lib/* bin/*",
+    "test": "mocha tests.js"
+  },
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "env": {
+      "node": true,
+      "es6": true
+    }
+  },
+  "lint-staged": {
+    "*.js": [
+      "npm run lint",
+      "prettier --single-quote --write",
+      "git add"
+    ]
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "4.18.2",
+    "expect.js": "0.3.1",
+    "husky": "0.14.3",
+    "lint-staged": "5.0.0",
+    "mocha": "4.0.1",
+    "prettier": "2.0.5"
+  }
+}

backend/node_modules/playwright-extra/node_modules/ms/readme.md

@@ -0,0 +1,59 @@
+# ms
+
+![CI](https://github.com/vercel/ms/workflows/CI/badge.svg)
+
+Use this package to easily convert various time formats to milliseconds.
+
+## Examples
+
+```js
+ms('2 days')  // 172800000
+ms('1d')      // 86400000
+ms('10h')     // 36000000
+ms('2.5 hrs') // 9000000
+ms('2h')      // 7200000
+ms('1m')      // 60000
+ms('5s')      // 5000
+ms('1y')      // 31557600000
+ms('100')     // 100
+ms('-3 days') // -259200000
+ms('-1h')     // -3600000
+ms('-200')    // -200
+```
+
+### Convert from Milliseconds
+
+```js
+ms(60000)             // "1m"
+ms(2 * 60000)         // "2m"
+ms(-3 * 60000)        // "-3m"
+ms(ms('10 hours'))    // "10h"
+```
+
+### Time Format Written-Out
+
+```js
+ms(60000, { long: true })             // "1 minute"
+ms(2 * 60000, { long: true })         // "2 minutes"
+ms(-3 * 60000, { long: true })        // "-3 minutes"
+ms(ms('10 hours'), { long: true })    // "10 hours"
+```
+
+## Features
+
+- Works both in [Node.js](https://nodejs.org) and in the browser
+- If a number is supplied to `ms`, a string with a unit is returned
+- If a string that contains the number is supplied, it returns it as a number (e.g.: it returns `100` for `'100'`)
+- If you pass a string with a number and a valid unit, the number of equivalent milliseconds is returned
+
+## Related Packages
+
+- [ms.macro](https://github.com/knpwrs/ms.macro) - Run `ms` as a macro at build-time.
+
+## Caught a Bug?
+
+1. [Fork](https://help.github.com/articles/fork-a-repo/) this repository to your own GitHub account and then [clone](https://help.github.com/articles/cloning-a-repository/) it to your local device
+2. Link the package to the global module directory: `npm link`
+3. Within the module you want to test your local development instance of ms, just link it to the dependencies: `npm link ms`. Instead of the default one from npm, Node.js will now use your clone of ms!
+
+As always, you can run the tests using: `npm test`

backend/node_modules/playwright-extra/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "playwright-extra",
+  "version": "4.3.6",
+  "description": "Teach playwright new tricks through plugins.",
+  "repository": "berstend/puppeteer-extra",
+  "homepage": "https://github.com/berstend/puppeteer-extra/tree/master/packages/playwright-extra#readme",
+  "author": "berstend",
+  "license": "MIT",
+  "typings": "dist/index.d.ts",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rimraf dist/*",
+    "prebuild": "run-s clean",
+    "build": "run-s build:tsc build:rollup ambient-dts",
+    "build:tsc": "tsc --module commonjs",
+    "build:rollup": "rollup -c rollup.config.ts",
+    "docs": "echo \"No docs\"",
+    "test": "yarn playwright test --config test/playwright.config.ts",
+    "test-ci": "run-s test",
+    "ambient-dts": "run-s ambient-dts-copy ambient-dts-fix-path",
+    "ambient-dts-copy": "copyfiles -u 1 \"src/**/*.d.ts\" dist",
+    "ambient-dts-fix-path": "replace-in-files --string='/// <reference path=\"../src/' --replacement='/// <reference path=\"../dist/' 'dist/**/*.d.ts'"
+  },
+  "keywords": [
+    "playwright",
+    "playwright-extra",
+    "stealth",
+    "recaptcha",
+    "user-preferences",
+    "chrome",
+    "headless",
+    "pupeteer"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.23.1",
+    "@types/debug": "^4.1.7",
+    "@types/node": "^18.0.0",
+    "esbuild": "^0.14.47",
+    "esbuild-register": "^3.3.3",
+    "npm-run-all": "^4.1.5",
+    "playwright": "1.24.2",
+    "prettier": "^2.7.1",
+    "puppeteer-extra-plugin": "^3.2.3",
+    "puppeteer-extra-plugin-anonymize-ua": "^2.4.5",
+    "rimraf": "^3.0.0",
+    "rollup": "^1.27.5",
+    "rollup-plugin-commonjs": "^10.1.0",
+    "rollup-plugin-node-resolve": "^5.2.0",
+    "rollup-plugin-sourcemaps": "^0.4.2",
+    "rollup-plugin-typescript2": "^0.25.2",
+    "typescript": "4.4.3"
+  },
+  "dependencies": {
+    "debug": "^4.3.4"
+  },
+  "peerDependencies": {
+    "playwright": "*",
+    "playwright-core": "*"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    },
+    "playwright-core": {
+      "optional": true
+    }
+  },
+  "gitHead": "2f4a357f233b35a7a20f16ce007f5ef3f62765b9"
+}

backend/node_modules/playwright-extra/readme.md

@@ -0,0 +1,282 @@
+# playwright-extra [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/berstend/puppeteer-extra/test.yml?branch=master&event=push)](https://github.com/berstend/puppeteer-extra/actions) [![Discord](https://img.shields.io/discord/737009125862408274)](https://extra.community) [![npm](https://img.shields.io/npm/v/playwright-extra.svg)](https://www.npmjs.com/package/playwright-extra)
+
+> A modular plugin framework for [playwright](https://github.com/microsoft/playwright) to enable cool [plugins](#plugins) through a clean interface.
+
+## Installation
+
+```bash
+yarn add playwright playwright-extra
+# - or -
+npm install playwright playwright-extra
+```
+
+<details>
+ <summary>Changelog</summary>
+
+> Please check the `announcements` channel in our [discord server](https://extra.community) until we've automated readme updates. :)
+
+- **v4.3**
+  - Rerelease due to versioning issues with previous beta packages
+- **v3.3**
+  - Initial public release
+  </details>
+
+## Quickstart
+
+```js
+// playwright-extra is a drop-in replacement for playwright,
+// it augments the installed playwright with plugin functionality
+const { chromium } = require('playwright-extra')
+
+// Load the stealth plugin and use defaults (all tricks to hide playwright usage)
+// Note: playwright-extra is compatible with most puppeteer-extra plugins
+const stealth = require('puppeteer-extra-plugin-stealth')()
+
+// Add the plugin to playwright (any number of plugins can be added)
+chromium.use(stealth)
+
+// That's it, the rest is playwright usage as normal 😊
+chromium.launch({ headless: true }).then(async browser => {
+  const page = await browser.newPage()
+
+  console.log('Testing the stealth plugin..')
+  await page.goto('https://bot.sannysoft.com', { waitUntil: 'networkidle' })
+  await page.screenshot({ path: 'stealth.png', fullPage: true })
+
+  console.log('All done, check the screenshot. ✨')
+  await browser.close()
+})
+```
+
+The above example uses the compatible [`stealth`](/packages/puppeteer-extra-plugin-stealth) plugin from puppeteer-extra, that plugin needs to be installed as well:
+
+```bash
+yarn add puppeteer-extra-plugin-stealth
+# - or -
+npm install puppeteer-extra-plugin-stealth
+```
+
+If you'd like to see debug output just run your script like so:
+
+```bash
+# macOS/Linux (Bash)
+DEBUG=playwright-extra*,puppeteer-extra* node myscript.js
+
+# Windows (Powershell)
+$env:DEBUG='playwright-extra*,puppeteer-extra*';node myscript.js
+```
+
+### More examples
+
+<details>
+ <summary><strong>TypeScript & ESM usage</strong></summary><br/>
+
+`playwright-extra` and most plugins are written in TS, so you get perfect type support out of the box. :)
+
+```ts
+// playwright-extra is a drop-in replacement for playwright,
+// it augments the installed playwright with plugin functionality
+import { chromium } from 'playwright-extra'
+
+// Load the stealth plugin and use defaults (all tricks to hide playwright usage)
+// Note: playwright-extra is compatible with most puppeteer-extra plugins
+import StealthPlugin from 'puppeteer-extra-plugin-stealth'
+
+// Add the plugin to playwright (any number of plugins can be added)
+chromium.use(StealthPlugin())
+
+// ...(the rest of the quickstart code example is the same)
+chromium.launch({ headless: true }).then(async browser => {
+  const page = await browser.newPage()
+
+  console.log('Testing the stealth plugin..')
+  await page.goto('https://bot.sannysoft.com', { waitUntil: 'networkidle' })
+  await page.screenshot({ path: 'stealth.png', fullPage: true })
+
+  console.log('All done, check the screenshot. ✨')
+  await browser.close()
+})
+```
+
+New to Typescript? Here it is in 30 seconds or less 😄:
+
+```bash
+# Optional: If you don't have yarn yet
+npm i --global yarn
+
+# Optional: Create new package.json if it's a new project
+yarn init -y
+
+# Add basic typescript dependencies
+yarn add --dev typescript @types/node esbuild esbuild-register
+
+# Bootstrap a tsconfig.json
+yarn tsc --init --target ES2020 --lib ES2020 --module commonjs --rootDir src --outDir dist
+
+# Add dependencies used in the quick start example
+yarn add playwright playwright-extra puppeteer-extra-plugin-stealth
+
+# Create source folder for the .ts files
+mkdir src
+
+# Now place the example code above in `src/index.ts`
+
+# Run the typescript code without the need of compiling it first
+node -r esbuild-register src/index.ts
+
+# You can now add Typescript to your CV 🎉
+```
+
+</details>
+<details>
+ <summary><strong>Using different browsers</strong></summary><br/>
+
+```ts
+// Any browser supported by playwright can be used with plugins
+import { chromium, firefox, webkit } from 'playwright-extra'
+
+chromium.use(plugin)
+firefox.use(plugin)
+webkit.use(plugin)
+```
+
+</details>
+<details>
+ <summary><strong>Multiple instances with different plugins</strong></summary><br/>
+
+Node.js imports are cached, therefore the default `chromium`, `firefox`, `webkit` export from `playwright-extra` will always return the same playwright instance.
+
+```ts
+// Use `addExtra` to create a fresh and independent instance
+import playwright from 'playwright'
+import { addExtra } from 'playwright-extra'
+
+const chromium1 = addExtra(playwright.chromium)
+const chromium2 = addExtra(playwright.chromium)
+
+chromium1.use(onePlugin)
+chromium2.use(anotherPlugin)
+// chromium1 and chromium2 are independent
+```
+
+</details>
+
+---
+
+## Plugins
+
+We're currently in the process of making the existing [puppeteer-extra](/packages/puppeteer-extra) plugins compatible with playwright-extra, the following plugins have been successfully tested already:
+
+### 🔥 [`puppeteer-extra-plugin-stealth`](/packages/puppeteer-extra-plugin-stealth)
+
+- Applies various evasion techniques to make detection of an automated browser harder
+- Compatible with Puppeteer & Playwright and chromium based browsers
+
+<details>
+<summary>&nbsp;&nbsp;Example: Using stealth in Playwright with custom options</summary>
+
+```js
+// The stealth plugin is optimized for chromium based browsers currently
+import { chromium } from 'playwright-extra'
+
+import StealthPlugin from 'puppeteer-extra-plugin-stealth'
+chromium.use(StealthPlugin())
+
+// New way to overwrite the default options of stealth evasion plugins
+// https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra-plugin-stealth/evasions
+chromium.plugins.setDependencyDefaults('stealth/evasions/webgl.vendor', {
+  vendor: 'Bob',
+  renderer: 'Alice'
+})
+
+// That's it, the rest is playwright usage as normal 😊
+chromium.launch({ headless: true }).then(async browser => {
+  const page = await browser.newPage()
+
+  console.log('Testing the webgl spoofing feature of the stealth plugin..')
+  await page.goto('https://webglreport.com', { waitUntil: 'networkidle' })
+  await page.screenshot({ path: 'webgl.png', fullPage: true })
+
+  console.log('All done, check the screenshot. ✨')
+  await browser.close()
+})
+```
+
+</details>
+
+### 🏴 [`puppeteer-extra-plugin-recaptcha`](/packages/puppeteer-extra-plugin-recaptcha)
+
+- Solves reCAPTCHAs and hCaptchas automatically, using a single line of code: `page.solveRecaptchas()`
+- Compatible with Puppeteer & Playwright and all browsers (chromium, firefox, webkit)
+<details>
+<summary>&nbsp;&nbsp;Example: Solving captchas in Playwright & Firefox</summary>
+
+```js
+// Any browser (chromium, webkit, firefox) can be used
+import { firefox } from 'playwright-extra'
+
+import RecaptchaPlugin from 'puppeteer-extra-plugin-recaptcha'
+firefox.use(
+  RecaptchaPlugin({
+    provider: {
+      id: '2captcha',
+      token: process.env.TWOCAPTCHA_TOKEN || 'YOUR_API_KEY'
+    }
+  })
+)
+
+// Works in headless as well, just so you can see it in action
+firefox.launch({ headless: false }).then(async browser => {
+  const context = await browser.newContext()
+  const page = await context.newPage()
+  const url = 'https://www.google.com/recaptcha/api2/demo'
+  await page.goto(url, { waitUntil: 'networkidle' })
+
+  console.log('Solving captchas..')
+  await page.solveRecaptchas()
+
+  await Promise.all([
+    page.waitForNavigation({ waitUntil: 'networkidle' }),
+    page.click(`#recaptcha-demo-submit`)
+  ])
+
+  const content = await page.content()
+  const isSuccess = content.includes('Verification Success')
+  console.log('Done', { isSuccess })
+  await browser.close()
+})
+```
+
+</details>
+
+### 🆕 [`plugin-proxy-router`](/packages/plugin-proxy-router)
+
+- Use multiple proxies dynamically with flexible per-host routing and more
+- Compatible with Puppeteer & Playwright and all browsers (chromium, firefox, webkit)
+
+**Notes**
+
+- If you're in need of adblocking use [this package](https://www.npmjs.com/package/@cliqz/adblocker-playwright) or [block resources natively](https://github.com/berstend/puppeteer-extra/wiki/Block-resources-without-request-interception)
+- We're focussing on compatiblity with existing plugins at the moment, more documentation on how to write your own playwright-extra plugins will follow
+
+---
+
+## Contributors
+
+<a href="https://github.com/berstend/puppeteer-extra/graphs/contributors">
+  <img src="https://contributors-img.firebaseapp.com/image?repo=berstend/puppeteer-extra" />
+</a>
+
+---
+
+## License
+
+Copyright © 2018 - 2023, [berstend̡̲̫̹̠̖͚͓̔̄̓̐̄͛̀͘](https://github.com/berstend). Released under the MIT License.
+
+<!--
+  Reference links
+-->
+
+[playwright-extra]: https://github.com/berstend/puppeteer-extra/tree/master/packages/playwright-extra
+[puppeteer-extra]: https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra
+[`puppeteer-extra`]: https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra