@modeloslab/modelcode 0.1.0

package/dist/puppeteer-core-qdv3v3fq.mjs

@@ -0,0 +1,1486 @@
+import {
+  convertPuppeteerChannelToBrowsersChannel
+} from "./main-tqg5vhra.mjs";
+import {
+  Browser as Browser2,
+  CDP_WEBSOCKET_ENDPOINT_REGEX,
+  TimeoutError as TimeoutError2,
+  WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX,
+  computeExecutablePath,
+  computeSystemExecutablePath,
+  createProfile,
+  detectBrowserPlatform,
+  getInstalledBrowsers,
+  launch,
+  resolveBuildId,
+  uninstall
+} from "./main-d71btkt1.mjs";
+import {
+  ARIAQueryHandler,
+  Accessibility,
+  AsyncDisposableStack,
+  AsyncDisposableStackPolyfill,
+  AsyncIterableUtil,
+  Binding,
+  Browser,
+  BrowserContext,
+  CDPSession,
+  CDPSessionEvent,
+  CDP_BINDING_PREFIX,
+  CSSCoverage,
+  Callback,
+  CallbackRegistry,
+  CdpBluetoothEmulation,
+  CdpBrowser,
+  CdpBrowserContext,
+  CdpCDPSession,
+  CdpDeviceRequestPrompt,
+  CdpDeviceRequestPromptManager,
+  CdpDialog,
+  CdpElementHandle,
+  CdpFrame,
+  CdpHTTPRequest,
+  CdpHTTPResponse,
+  CdpJSHandle,
+  CdpKeyboard,
+  CdpMouse,
+  CdpPage,
+  CdpPreloadScript,
+  CdpTarget,
+  CdpTouchHandle,
+  CdpTouchscreen,
+  CdpWebWorker,
+  Connection,
+  ConsoleMessage,
+  Coverage,
+  CustomQueryHandlerRegistry,
+  DEFAULT_INTERCEPT_RESOLUTION_PRIORITY,
+  Deferred,
+  DelegatedLocator,
+  DevToolsTarget,
+  DeviceRequestPrompt,
+  Dialog,
+  DisposableStack,
+  DisposableStackPolyfill,
+  ElementHandle,
+  EmulatedState,
+  EmulationManager,
+  EventEmitter,
+  ExecutionContext,
+  Extension,
+  ExtensionTransport,
+  FileChooser,
+  FilteredLocator,
+  Frame,
+  FrameEvent,
+  FrameManager,
+  FrameManagerEvent,
+  FrameTree,
+  FunctionLocator,
+  HTTPRequest,
+  HTTPResponse,
+  InitializationStatus,
+  InterceptResolutionAction,
+  IsolatedWorld,
+  JSCoverage,
+  JSHandle,
+  Keyboard,
+  KnownDevices,
+  LazyArg,
+  LifecycleWatcher,
+  Locator,
+  LocatorEvent,
+  MAIN_WORLD,
+  MappedLocator,
+  Mouse,
+  MouseButton,
+  Mutex,
+  NetworkEventManager,
+  NetworkManager,
+  NetworkManagerEvent,
+  NodeLocator,
+  OtherTarget,
+  PQueryHandler,
+  PUPPETEER_REVISIONS,
+  PUPPETEER_WORLD,
+  Page,
+  PageTarget,
+  PierceQueryHandler,
+  PredefinedNetworkConditions,
+  Puppeteer,
+  QueryHandler,
+  RETRY_DELAY,
+  RaceLocator,
+  Realm,
+  STATUS_TEXTS,
+  ScriptInjector,
+  SecurityDetails,
+  SuppressedError,
+  Target,
+  TargetManager,
+  TargetType,
+  TaskManager,
+  TaskQueue,
+  TextQueryHandler,
+  TimeoutSettings,
+  Touchscreen,
+  Tracing,
+  WEB_PERMISSION_TO_PROTOCOL_PERMISSION,
+  WaitTask,
+  WebMCP,
+  WebMCPTool,
+  WebMCPToolCall,
+  WebWorker,
+  WebWorkerEvent,
+  WorkerTarget,
+  XPathQueryHandler,
+  _connectToCdpBrowser,
+  _keyDefinitions,
+  addPageBinding,
+  assertSupportedUrlRestrictions,
+  asyncDisposeSymbol,
+  bindIsolatedHandle,
+  convertConsoleMessageLevel,
+  convertCookiesPartitionKeyFromPuppeteerToCdp,
+  convertSameSiteFromPuppeteerToCdp,
+  createClientError,
+  createConsoleMessage,
+  createEvaluationError,
+  createIncrementalIdGenerator,
+  createProtocolErrorMessage,
+  customQueryHandlers,
+  disposeSymbol,
+  getQueryHandlerAndSelector,
+  guarded,
+  handleError,
+  headersArray,
+  isErrnoException,
+  isErrorLike,
+  isTargetClosedError,
+  normalizeHeaderValue,
+  pageBindingInitString,
+  parsePSelectors,
+  referrerPolicyToProtocol,
+  releaseObject,
+  rewriteError,
+  scriptInjector,
+  setDefaultScreenshotOptions,
+  supportedMetrics,
+  throwIfDetached,
+  transposeIterableHandle,
+  valueFromJSHandle,
+  valueFromPrimitiveRemoteObject,
+  valueFromRemoteObjectReference
+} from "./main-0r35eyef.mjs";
+import {
+  NodeWebSocketTransport
+} from "./main-5vqwebnv.mjs";
+import"./main-7f2pnmhh.mjs";
+import {
+  BrowserWebSocketTransport
+} from "./main-9w13grbs.mjs";
+import {
+  ConnectionClosedError,
+  DEFAULT_VIEWPORT,
+  NETWORK_IDLE_TIME,
+  ProtocolError,
+  PuppeteerError,
+  PuppeteerURL,
+  SOURCE_URL_REGEX,
+  TargetCloseError,
+  TimeoutError,
+  TouchError,
+  UTILITY_WORLD_NAME,
+  UnsupportedOperation,
+  assert,
+  bufferCount,
+  concatMap,
+  debug,
+  debugError,
+  environment,
+  evaluationString,
+  filter,
+  filterAsync,
+  firstValueFrom,
+  from,
+  fromAbortSignal,
+  fromEmitterEvent,
+  fromEvent,
+  getCapturedLogs,
+  getReadableAsTypedArray,
+  getReadableFromProtocolStream,
+  getSourcePuppeteerURLIfAvailable,
+  getSourceUrlComment,
+  importDebug,
+  isDate,
+  isNumber,
+  isPlainObject,
+  isRegExp,
+  isString,
+  lastValueFrom,
+  map,
+  paperFormats,
+  parsePDFOptions,
+  race,
+  setLogCapture,
+  takeUntil,
+  tap,
+  timeout,
+  timer,
+  unitToPixels,
+  validateDialogType,
+  withSourcePuppeteerURLIfNone
+} from "./main-h8e68gyt.mjs";
+import {
+  __require
+} from "./main-8y3fe7c3.mjs";
+// node_modules/puppeteer-core/lib/puppeteer/node/ChromeLauncher.js
+import { mkdtemp } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// node_modules/puppeteer-core/lib/puppeteer/node/BrowserLauncher.js
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// node_modules/puppeteer-core/lib/puppeteer/node/PipeTransport.js
+class PipeTransport {
+  #pipeWrite;
+  #subscriptions = new DisposableStack;
+  #isClosed = false;
+  #pendingMessage = [];
+  onclose;
+  onmessage;
+  constructor(pipeWrite, pipeRead) {
+    this.#pipeWrite = pipeWrite;
+    const pipeReadEmitter = this.#subscriptions.use(new EventEmitter(pipeRead));
+    pipeReadEmitter.on("data", (buffer) => {
+      return this.#dispatch(buffer);
+    });
+    pipeReadEmitter.on("close", () => {
+      if (this.onclose) {
+        this.onclose.call(null);
+      }
+    });
+    pipeReadEmitter.on("error", debugError);
+    const pipeWriteEmitter = this.#subscriptions.use(new EventEmitter(pipeWrite));
+    pipeWriteEmitter.on("error", debugError);
+  }
+  send(message) {
+    assert(!this.#isClosed, "`PipeTransport` is closed.");
+    this.#pipeWrite.write(message);
+    this.#pipeWrite.write("\x00");
+  }
+  #dispatch(buffer) {
+    assert(!this.#isClosed, "`PipeTransport` is closed.");
+    this.#pendingMessage.push(buffer);
+    if (buffer.indexOf("\x00") === -1) {
+      return;
+    }
+    const concatBuffer = Buffer.concat(this.#pendingMessage);
+    let start = 0;
+    let end = concatBuffer.indexOf("\x00");
+    while (end !== -1) {
+      const message = concatBuffer.toString(undefined, start, end);
+      setImmediate(() => {
+        if (this.onmessage) {
+          this.onmessage.call(null, message);
+        }
+      });
+      start = end + 1;
+      end = concatBuffer.indexOf("\x00", start);
+    }
+    if (start >= concatBuffer.length) {
+      this.#pendingMessage = [];
+    } else {
+      this.#pendingMessage = [concatBuffer.subarray(start)];
+    }
+  }
+  close() {
+    this.#isClosed = true;
+    this.#subscriptions.dispose();
+  }
+}
+
+// node_modules/puppeteer-core/lib/puppeteer/node/BrowserLauncher.js
+class BrowserLauncher {
+  #browser;
+  puppeteer;
+  constructor(puppeteer, browser) {
+    this.puppeteer = puppeteer;
+    this.#browser = browser;
+  }
+  get browser() {
+    return this.#browser;
+  }
+  async launch(options = {}) {
+    const { dumpio = false, enableExtensions = false, env = process.env, handleSIGINT = true, handleSIGTERM = true, handleSIGHUP = true, acceptInsecureCerts = false, networkEnabled = true, issuesEnabled = true, defaultViewport = DEFAULT_VIEWPORT, downloadBehavior, slowMo = 0, timeout: timeout2 = 30000, waitForInitialPage = true, protocolTimeout, handleDevToolsAsPage, idGenerator = createIncrementalIdGenerator(), blocklist, allowlist } = options;
+    let { protocol } = options;
+    if (this.#browser === "firefox" && protocol === undefined) {
+      protocol = "webDriverBiDi";
+    }
+    assertSupportedUrlRestrictions({
+      allowlist,
+      blocklist,
+      protocol
+    });
+    if (this.#browser === "firefox" && protocol === "cdp") {
+      throw new Error("Connecting to Firefox using CDP is no longer supported");
+    }
+    const launchArgs = await this.computeLaunchArguments({
+      ...options,
+      protocol
+    });
+    if (!existsSync(launchArgs.executablePath)) {
+      throw new Error(`Browser was not found at the configured executablePath (${launchArgs.executablePath})`);
+    }
+    const usePipe = launchArgs.args.includes("--remote-debugging-pipe");
+    const onProcessExit = async () => {
+      await this.cleanUserDataDir(launchArgs.userDataDir, {
+        isTemp: launchArgs.isTempUserDataDir
+      });
+    };
+    if (this.#browser === "firefox" && protocol === "webDriverBiDi" && usePipe) {
+      throw new Error("Pipe connections are not supported with Firefox and WebDriver BiDi");
+    }
+    const browserProcess = launch({
+      executablePath: launchArgs.executablePath,
+      args: launchArgs.args,
+      handleSIGHUP,
+      handleSIGTERM,
+      handleSIGINT,
+      dumpio,
+      env,
+      pipe: usePipe,
+      onExit: onProcessExit,
+      signal: options.signal
+    });
+    let browser;
+    let cdpConnection;
+    let closing = false;
+    const browserCloseCallback = async () => {
+      if (closing) {
+        return;
+      }
+      closing = true;
+      await this.closeBrowser(browserProcess, cdpConnection);
+    };
+    try {
+      if (this.#browser === "firefox") {
+        browser = await this.createBiDiBrowser(browserProcess, browserCloseCallback, {
+          timeout: timeout2,
+          protocolTimeout,
+          slowMo,
+          defaultViewport,
+          acceptInsecureCerts,
+          networkEnabled,
+          idGenerator
+        });
+      } else {
+        if (usePipe) {
+          cdpConnection = await this.createCdpPipeConnection(browserProcess, {
+            timeout: timeout2,
+            protocolTimeout,
+            slowMo,
+            idGenerator
+          });
+        } else {
+          cdpConnection = await this.createCdpSocketConnection(browserProcess, {
+            timeout: timeout2,
+            protocolTimeout,
+            slowMo,
+            idGenerator
+          });
+        }
+        if (protocol === "webDriverBiDi") {
+          browser = await this.createBiDiOverCdpBrowser(browserProcess, cdpConnection, browserCloseCallback, {
+            defaultViewport,
+            acceptInsecureCerts,
+            networkEnabled,
+            issuesEnabled
+          });
+        } else {
+          browser = await CdpBrowser._create(cdpConnection, [], acceptInsecureCerts, defaultViewport, downloadBehavior, browserProcess.nodeProcess, browserCloseCallback, options.targetFilter, undefined, undefined, networkEnabled, issuesEnabled, handleDevToolsAsPage, blocklist, allowlist);
+        }
+      }
+    } catch (error) {
+      browserCloseCallback();
+      const logs = browserProcess.getRecentLogs().join(`
+`);
+      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync(join(launchArgs.userDataDir, "lockfile"))) {
+        throw new Error(`The browser is already running for ${launchArgs.userDataDir}. Use a different \`userDataDir\` or stop the running browser first.`);
+      }
+      if (logs.includes("Missing X server") && options.headless === false) {
+        throw new Error(`Missing X server to start the headful browser. Either set headless to true or use xvfb-run to run your Puppeteer script.`);
+      }
+      if (error instanceof TimeoutError2) {
+        throw new TimeoutError(error.message);
+      }
+      throw error;
+    }
+    if (Array.isArray(enableExtensions)) {
+      if (this.#browser === "chrome" && !usePipe) {
+        throw new Error("To use `enableExtensions` with a list of paths in Chrome, you must be connected with `--remote-debugging-pipe` (`pipe: true`).");
+      }
+      await Promise.all([
+        enableExtensions.map((path) => {
+          return browser.installExtension(path);
+        })
+      ]);
+    }
+    if (waitForInitialPage) {
+      await this.waitForPageTarget(browser, timeout2);
+    }
+    return browser;
+  }
+  async closeBrowser(browserProcess, cdpConnection) {
+    if (cdpConnection) {
+      try {
+        await cdpConnection.closeBrowser();
+        await browserProcess.hasClosed();
+      } catch (error) {
+        debugError(error);
+        await browserProcess.close();
+      }
+    } else {
+      await firstValueFrom(race(from(browserProcess.hasClosed()), timer(5000).pipe(map(() => {
+        return from(browserProcess.close());
+      }))));
+    }
+  }
+  async waitForPageTarget(browser, timeout2) {
+    try {
+      await browser.waitForTarget((t) => {
+        return t.type() === "page";
+      }, { timeout: timeout2 });
+    } catch (error) {
+      await browser.close();
+      throw error;
+    }
+  }
+  async createCdpSocketConnection(browserProcess, opts) {
+    const browserWSEndpoint = await browserProcess.waitForLineOutput(CDP_WEBSOCKET_ENDPOINT_REGEX, opts.timeout);
+    const transport = await NodeWebSocketTransport.create(browserWSEndpoint);
+    return new Connection(browserWSEndpoint, transport, opts.slowMo, opts.protocolTimeout, false, opts.idGenerator);
+  }
+  async createCdpPipeConnection(browserProcess, opts) {
+    const { 3: pipeWrite, 4: pipeRead } = browserProcess.nodeProcess.stdio;
+    const transport = new PipeTransport(pipeWrite, pipeRead);
+    return new Connection("", transport, opts.slowMo, opts.protocolTimeout, false, opts.idGenerator);
+  }
+  async createBiDiOverCdpBrowser(browserProcess, cdpConnection, closeCallback, opts) {
+    const bidiOnly = process.env["PUPPETEER_WEBDRIVER_BIDI_ONLY"] === "true";
+    const BiDi = await import("./bidi-fwqajnyx.mjs");
+    const bidiConnection = await BiDi.connectBidiOverCdp(cdpConnection);
+    return await BiDi.BidiBrowser.create({
+      connection: bidiConnection,
+      cdpConnection: bidiOnly ? undefined : cdpConnection,
+      closeCallback,
+      process: browserProcess.nodeProcess,
+      defaultViewport: opts.defaultViewport,
+      acceptInsecureCerts: opts.acceptInsecureCerts,
+      networkEnabled: opts.networkEnabled,
+      issuesEnabled: opts.issuesEnabled
+    });
+  }
+  async createBiDiBrowser(browserProcess, closeCallback, opts) {
+    const browserWSEndpoint = await browserProcess.waitForLineOutput(WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX, opts.timeout) + "/session";
+    const transport = await NodeWebSocketTransport.create(browserWSEndpoint);
+    const BiDi = await import("./bidi-fwqajnyx.mjs");
+    const bidiConnection = new BiDi.BidiConnection(browserWSEndpoint, transport, opts.idGenerator, opts.slowMo, opts.protocolTimeout);
+    return await BiDi.BidiBrowser.create({
+      connection: bidiConnection,
+      closeCallback,
+      process: browserProcess.nodeProcess,
+      defaultViewport: opts.defaultViewport,
+      acceptInsecureCerts: opts.acceptInsecureCerts,
+      networkEnabled: opts.networkEnabled ?? true,
+      issuesEnabled: opts.issuesEnabled ?? true
+    });
+  }
+  async getProfilePath() {
+    const config = await this.puppeteer.configuration();
+    return join(config.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
+  }
+  async resolveExecutablePath(headless, validatePath = true) {
+    const config = await this.puppeteer.configuration();
+    let executablePath = config.executablePath;
+    if (executablePath) {
+      if (validatePath && !existsSync(executablePath)) {
+        throw new Error(`Tried to find the browser at the configured path (${executablePath}), but no executable was found.`);
+      }
+      return executablePath;
+    }
+    function puppeteerBrowserToInstalledBrowser(browser, headless2) {
+      switch (browser) {
+        case "chrome":
+          if (headless2 === "shell") {
+            return Browser2.CHROMEHEADLESSSHELL;
+          }
+          return Browser2.CHROME;
+        case "firefox":
+          return Browser2.FIREFOX;
+      }
+      return Browser2.CHROME;
+    }
+    const browserType = puppeteerBrowserToInstalledBrowser(this.browser, headless);
+    const defaultDownloadPath = await this.puppeteer.defaultDownloadPath();
+    const browserVersion = await this.puppeteer.browserVersion();
+    executablePath = computeExecutablePath({
+      cacheDir: defaultDownloadPath,
+      browser: browserType,
+      buildId: browserVersion
+    });
+    if (validatePath && !existsSync(executablePath)) {
+      const configVersion = config?.[this.browser]?.version;
+      if (configVersion) {
+        throw new Error(`Tried to find the browser at the configured path (${executablePath}) for version ${configVersion}, but no executable was found.`);
+      }
+      switch (this.browser) {
+        case "chrome":
+          throw new Error(`Could not find Chrome (ver. ${browserVersion}). This can occur if either
+ 1. you did not perform an installation before running the script (e.g. \`npx puppeteer browsers install ${browserType}\`) or
+ 2. your cache path is incorrectly configured (which is: ${config.cacheDirectory}).
+For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides/configuration.`);
+        case "firefox":
+          throw new Error(`Could not find Firefox (rev. ${browserVersion}). This can occur if either
+ 1. you did not perform an installation for Firefox before running the script (e.g. \`npx puppeteer browsers install firefox\`) or
+ 2. your cache path is incorrectly configured (which is: ${config.cacheDirectory}).
+For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides/configuration.`);
+      }
+    }
+    return executablePath;
+  }
+}
+
+// node_modules/puppeteer-core/lib/puppeteer/node/util/fs.js
+import fs from "node:fs";
+var rmOptions = {
+  force: true,
+  recursive: true,
+  maxRetries: 5
+};
+async function rm(path) {
+  await fs.promises.rm(path, rmOptions);
+}
+
+// node_modules/puppeteer-core/lib/puppeteer/node/ChromeLauncher.js
+class ChromeLauncher extends BrowserLauncher {
+  constructor(puppeteer) {
+    super(puppeteer, "chrome");
+  }
+  async launch(options = {}) {
+    const config = await this.puppeteer.configuration();
+    if (config.logLevel === "warn" && process.platform === "darwin" && process.arch === "x64") {
+      const cpus = os.cpus();
+      if (cpus[0]?.model.includes("Apple")) {
+        console.warn([
+          "\x1B[1m\x1B[43m\x1B[30m",
+          "Degraded performance warning:\x1B[0m\x1B[33m",
+          "Launching Chrome on Mac Silicon (arm64) from an x64 Node installation results in",
+          "Rosetta translating the Chrome binary, even if Chrome is already arm64. This would",
+          "result in huge performance issues. To resolve this, you must run Puppeteer with",
+          "a version of Node built for arm64."
+        ].join(`
+  `));
+      }
+    }
+    return await super.launch(options);
+  }
+  async computeLaunchArguments(options = {}) {
+    const { ignoreDefaultArgs = false, args = [], pipe = false, debuggingPort, channel, executablePath } = options;
+    const chromeArguments = [];
+    if (!ignoreDefaultArgs) {
+      chromeArguments.push(...this.defaultArgs(options));
+    } else if (Array.isArray(ignoreDefaultArgs)) {
+      chromeArguments.push(...this.defaultArgs(options).filter((arg) => {
+        return !ignoreDefaultArgs.includes(arg);
+      }));
+    } else {
+      chromeArguments.push(...args);
+    }
+    if (!chromeArguments.some((argument) => {
+      return argument.startsWith("--remote-debugging-");
+    })) {
+      if (pipe) {
+        assert(!debuggingPort, "Browser should be launched with either pipe or debugging port - not both.");
+        chromeArguments.push("--remote-debugging-pipe");
+      } else {
+        chromeArguments.push(`--remote-debugging-port=${debuggingPort || 0}`);
+      }
+    }
+    let isTempUserDataDir = false;
+    let userDataDirIndex = chromeArguments.findIndex((arg) => {
+      return arg.startsWith("--user-data-dir");
+    });
+    if (userDataDirIndex < 0) {
+      isTempUserDataDir = true;
+      chromeArguments.push(`--user-data-dir=${await mkdtemp(await this.getProfilePath())}`);
+      userDataDirIndex = chromeArguments.length - 1;
+    }
+    const userDataDir = chromeArguments[userDataDirIndex].split("=", 2)[1];
+    assert(typeof userDataDir === "string", "`--user-data-dir` is malformed");
+    let chromeExecutable = executablePath;
+    if (!chromeExecutable) {
+      assert(channel || !this.puppeteer._isPuppeteerCore, `An \`executablePath\` or \`channel\` must be specified for \`puppeteer-core\``);
+      chromeExecutable = channel ? await this.executablePath(channel) : await this.resolveExecutablePath(options.headless ?? true);
+    }
+    return {
+      executablePath: chromeExecutable,
+      args: chromeArguments,
+      isTempUserDataDir,
+      userDataDir
+    };
+  }
+  async cleanUserDataDir(path2, opts) {
+    if (opts.isTemp) {
+      try {
+        await rm(path2);
+      } catch (error) {
+        debugError(error);
+        throw error;
+      }
+    }
+  }
+  defaultArgs(options = {}) {
+    const userDisabledFeatures = getFeatures("--disable-features", options.args);
+    if (options.args && userDisabledFeatures.length > 0) {
+      removeMatchingFlags(options.args, "--disable-features");
+    }
+    const turnOnExperimentalFeaturesForTesting = process.env["PUPPETEER_TEST_EXPERIMENTAL_CHROME_FEATURES"] === "true";
+    const userEnabledFeatures = getFeatures("--enable-features", options.args);
+    if (options.args && userEnabledFeatures.length > 0) {
+      removeMatchingFlags(options.args, "--enable-features");
+    }
+    const enabledFeatures = [
+      "PdfOopif",
+      ...userEnabledFeatures
+    ].filter((feature) => {
+      return feature !== "";
+    });
+    const disabledFeatures = [
+      "Translate",
+      "AcceptCHFrame",
+      "MediaRouter",
+      "OptimizationHints",
+      "WebUIReloadButton",
+      ...turnOnExperimentalFeaturesForTesting ? [] : [
+        "ProcessPerSiteUpToMainFrameThreshold",
+        "IsolateSandboxedIframes"
+      ],
+      ...userDisabledFeatures
+    ].filter((feature) => {
+      return feature !== "";
+    }).filter((disabledFeature) => {
+      return !enabledFeatures.includes(disabledFeature);
+    });
+    const chromeArguments = [
+      "--allow-pre-commit-input",
+      "--disable-background-networking",
+      "--disable-background-timer-throttling",
+      "--disable-backgrounding-occluded-windows",
+      "--disable-breakpad",
+      "--disable-client-side-phishing-detection",
+      "--disable-component-extensions-with-background-pages",
+      "--disable-crash-reporter",
+      "--disable-default-apps",
+      "--disable-dev-shm-usage",
+      "--disable-hang-monitor",
+      "--disable-infobars",
+      "--disable-ipc-flooding-protection",
+      "--disable-popup-blocking",
+      "--disable-prompt-on-repost",
+      "--disable-renderer-backgrounding",
+      "--disable-search-engine-choice-screen",
+      "--disable-sync",
+      "--enable-automation",
+      "--export-tagged-pdf",
+      "--force-color-profile=srgb",
+      "--generate-pdf-document-outline",
+      "--metrics-recording-only",
+      "--no-first-run",
+      "--password-store=basic",
+      "--use-mock-keychain",
+      `--disable-features=${disabledFeatures.join(",")}`,
+      `--enable-features=${enabledFeatures.join(",")}`
+    ].filter((arg) => {
+      return arg !== "";
+    });
+    const { devtools = false, headless = !devtools, args = [], userDataDir, enableExtensions = false } = options;
+    if (process.env["PUPPETEER_DANGEROUS_NO_SANDBOX"] === "true" && !args.includes("--no-sandbox")) {
+      chromeArguments.push("--no-sandbox");
+    }
+    if (userDataDir) {
+      chromeArguments.push(`--user-data-dir=${path.posix.isAbsolute(userDataDir) || path.win32.isAbsolute(userDataDir) ? userDataDir : path.resolve(userDataDir)}`);
+    }
+    if (devtools) {
+      chromeArguments.push("--auto-open-devtools-for-tabs");
+    }
+    if (headless) {
+      chromeArguments.push(headless === "shell" ? "--headless" : "--headless=new", "--hide-scrollbars", "--mute-audio");
+    }
+    chromeArguments.push(enableExtensions ? "--enable-unsafe-extension-debugging" : "--disable-extensions");
+    if (args.every((arg) => {
+      return arg.startsWith("-");
+    })) {
+      chromeArguments.push("about:blank");
+    }
+    chromeArguments.push(...args);
+    return chromeArguments;
+  }
+  async executablePath(channel, validatePath = true) {
+    if (channel) {
+      return computeSystemExecutablePath({
+        browser: Browser2.CHROME,
+        channel: convertPuppeteerChannelToBrowsersChannel(channel)
+      });
+    } else {
+      return await this.resolveExecutablePath(undefined, validatePath);
+    }
+  }
+}
+function getFeatures(flag, options = []) {
+  const prefix = flag.endsWith("=") ? flag : `${flag}=`;
+  return options.filter((s) => {
+    return s.startsWith(prefix);
+  }).flatMap((s) => {
+    return s.substring(s.indexOf("=") + 1).trim().split(",").map((feature) => {
+      return feature.trim();
+    });
+  }).filter((s) => {
+    return s;
+  });
+}
+function removeMatchingFlags(array, flag) {
+  const prefix = flag.endsWith("=") ? flag : `${flag}=`;
+  let i = 0;
+  while (i < array.length) {
+    if (array[i].startsWith(prefix)) {
+      array.splice(i, 1);
+    } else {
+      i++;
+    }
+  }
+  return array;
+}
+// node_modules/puppeteer-core/lib/puppeteer/node/FirefoxLauncher.js
+import fs2 from "node:fs";
+import { rename, unlink, mkdtemp as mkdtemp2 } from "node:fs/promises";
+import os2 from "node:os";
+import path2 from "node:path";
+class FirefoxLauncher extends BrowserLauncher {
+  constructor(puppeteer) {
+    super(puppeteer, "firefox");
+  }
+  static getPreferences(extraPrefsFirefox) {
+    return {
+      ...extraPrefsFirefox,
+      "fission.webContentIsolationStrategy": 0
+    };
+  }
+  async computeLaunchArguments(options = {}) {
+    const { ignoreDefaultArgs = false, args = [], executablePath, pipe = false, extraPrefsFirefox = {}, debuggingPort = null } = options;
+    const firefoxArguments = [];
+    if (!ignoreDefaultArgs) {
+      firefoxArguments.push(...this.defaultArgs(options));
+    } else if (Array.isArray(ignoreDefaultArgs)) {
+      firefoxArguments.push(...this.defaultArgs(options).filter((arg) => {
+        return !ignoreDefaultArgs.includes(arg);
+      }));
+    } else {
+      firefoxArguments.push(...args);
+    }
+    if (!firefoxArguments.some((argument) => {
+      return argument.startsWith("--remote-debugging-");
+    })) {
+      if (pipe) {
+        assert(debuggingPort === null, "Browser should be launched with either pipe or debugging port - not both.");
+      }
+      firefoxArguments.push(`--remote-debugging-port=${debuggingPort || 0}`);
+    }
+    let userDataDir;
+    let isTempUserDataDir = true;
+    const profileArgIndex = firefoxArguments.findIndex((arg) => {
+      return ["-profile", "--profile"].includes(arg);
+    });
+    if (profileArgIndex !== -1) {
+      userDataDir = firefoxArguments[profileArgIndex + 1];
+      if (!userDataDir) {
+        throw new Error(`Missing value for profile command line argument`);
+      }
+      isTempUserDataDir = false;
+    } else {
+      const profilePath = await this.getProfilePath();
+      userDataDir = await mkdtemp2(profilePath);
+      firefoxArguments.push("--profile");
+      firefoxArguments.push(userDataDir);
+    }
+    await createProfile(Browser2.FIREFOX, {
+      path: userDataDir,
+      preferences: FirefoxLauncher.getPreferences(extraPrefsFirefox)
+    });
+    let firefoxExecutable;
+    if (this.puppeteer._isPuppeteerCore || executablePath) {
+      assert(executablePath, `An \`executablePath\` must be specified for \`puppeteer-core\``);
+      firefoxExecutable = executablePath;
+    } else {
+      firefoxExecutable = await this.executablePath(undefined);
+    }
+    return {
+      isTempUserDataDir,
+      userDataDir,
+      args: firefoxArguments,
+      executablePath: firefoxExecutable
+    };
+  }
+  async cleanUserDataDir(userDataDir, opts) {
+    if (opts.isTemp) {
+      try {
+        await rm(userDataDir);
+      } catch (error) {
+        debugError(error);
+        throw error;
+      }
+    } else {
+      try {
+        const backupSuffix = ".puppeteer";
+        const backupFiles = ["prefs.js", "user.js"];
+        const results = await Promise.allSettled(backupFiles.map(async (file) => {
+          const prefsBackupPath = path2.join(userDataDir, file + backupSuffix);
+          if (fs2.existsSync(prefsBackupPath)) {
+            const prefsPath = path2.join(userDataDir, file);
+            await unlink(prefsPath);
+            await rename(prefsBackupPath, prefsPath);
+          }
+        }));
+        for (const result of results) {
+          if (result.status === "rejected") {
+            throw result.reason;
+          }
+        }
+      } catch (error) {
+        debugError(error);
+      }
+    }
+  }
+  async executablePath(_, validatePath = true) {
+    return await this.resolveExecutablePath(undefined, validatePath);
+  }
+  defaultArgs(options = {}) {
+    const { devtools = false, headless = !devtools, args = [], userDataDir = null } = options;
+    const firefoxArguments = [];
+    switch (os2.platform()) {
+      case "darwin":
+        firefoxArguments.push("--foreground");
+        break;
+      case "win32":
+        firefoxArguments.push("--wait-for-browser");
+        break;
+    }
+    if (userDataDir) {
+      firefoxArguments.push("--profile");
+      firefoxArguments.push(userDataDir);
+    }
+    if (headless) {
+      firefoxArguments.push("--headless");
+    }
+    if (devtools) {
+      firefoxArguments.push("--devtools");
+    }
+    if (args.every((arg) => {
+      return arg.startsWith("-");
+    })) {
+      firefoxArguments.push("about:blank");
+    }
+    firefoxArguments.push(...args);
+    return firefoxArguments;
+  }
+}
+// node_modules/puppeteer-core/lib/puppeteer/node/PuppeteerNode.js
+class PuppeteerNode extends Puppeteer {
+  #launcher;
+  #lastLaunchedBrowser;
+  configuration;
+  constructor(settings) {
+    const { configuration, ...commonSettings } = settings;
+    super(commonSettings);
+    if (configuration) {
+      this.configuration = configuration;
+    } else {
+      this.configuration = () => {
+        return Promise.resolve({});
+      };
+    }
+    this.connect = this.connect.bind(this);
+    this.launch = this.launch.bind(this);
+    this.executablePath = this.executablePath.bind(this);
+    this.defaultArgs = this.defaultArgs.bind(this);
+    this.trimCache = this.trimCache.bind(this);
+  }
+  connect(options) {
+    return super.connect(options);
+  }
+  async launch(options = {}) {
+    const { browser = await this.defaultBrowser() } = options;
+    this.#lastLaunchedBrowser = browser;
+    if (!["chrome", "firefox"].includes(browser)) {
+      throw new Error(`Unknown product: ${browser}`);
+    }
+    this.#launcher = this.#getLauncher(browser);
+    return await this.#launcher.launch(options);
+  }
+  #getLauncher(browser) {
+    if (this.#launcher && this.#launcher.browser === browser) {
+      return this.#launcher;
+    }
+    switch (browser) {
+      case "chrome":
+        return new ChromeLauncher(this);
+      case "firefox":
+        return new FirefoxLauncher(this);
+      default:
+        throw new Error(`Unknown product: ${browser}`);
+    }
+  }
+  async executablePath(optsOrChannel) {
+    if (optsOrChannel === undefined) {
+      return await this.#getLauncher(await this.lastLaunchedBrowser()).executablePath(undefined, false);
+    }
+    if (typeof optsOrChannel === "string") {
+      return await this.#getLauncher("chrome").executablePath(optsOrChannel, false);
+    }
+    return await this.#getLauncher(optsOrChannel.browser ?? await this.lastLaunchedBrowser()).resolveExecutablePath(optsOrChannel.headless, false);
+  }
+  async browserVersion() {
+    const config = await this.configuration();
+    const lastLaunched = await this.lastLaunchedBrowser();
+    return config?.[lastLaunched]?.version ?? PUPPETEER_REVISIONS[lastLaunched];
+  }
+  async defaultDownloadPath() {
+    const config = await this.configuration();
+    return config.cacheDirectory;
+  }
+  async lastLaunchedBrowser() {
+    return this.#lastLaunchedBrowser ?? await this.defaultBrowser();
+  }
+  async defaultBrowser() {
+    const config = await this.configuration();
+    return config.defaultBrowser ?? "chrome";
+  }
+  async defaultArgs(options = {}) {
+    return this.#getLauncher(options.browser ?? await this.lastLaunchedBrowser()).defaultArgs(options);
+  }
+  async trimCache() {
+    const platform = detectBrowserPlatform();
+    if (!platform) {
+      throw new Error("The current platform is not supported.");
+    }
+    const config = await this.configuration();
+    const cacheDir = config.cacheDirectory;
+    const installedBrowsers = await getInstalledBrowsers({
+      cacheDir
+    });
+    const puppeteerBrowsers = [
+      {
+        product: "chrome",
+        browser: Browser2.CHROME,
+        currentBuildId: ""
+      },
+      {
+        product: "firefox",
+        browser: Browser2.FIREFOX,
+        currentBuildId: ""
+      }
+    ];
+    await Promise.all(puppeteerBrowsers.map(async (item) => {
+      const tag = config?.[item.product]?.version ?? PUPPETEER_REVISIONS[item.product];
+      item.currentBuildId = await resolveBuildId(item.browser, platform, tag);
+    }));
+    const currentBrowserBuilds = new Set(puppeteerBrowsers.map((browser) => {
+      return `${browser.browser}_${browser.currentBuildId}`;
+    }));
+    const currentBrowsers = new Set(puppeteerBrowsers.map((browser) => {
+      return browser.browser;
+    }));
+    for (const installedBrowser of installedBrowsers) {
+      if (!currentBrowsers.has(installedBrowser.browser)) {
+        continue;
+      }
+      if (currentBrowserBuilds.has(`${installedBrowser.browser}_${installedBrowser.buildId}`)) {
+        continue;
+      }
+      await uninstall({
+        browser: installedBrowser.browser,
+        platform,
+        cacheDir,
+        buildId: installedBrowser.buildId
+      });
+    }
+  }
+}
+// node_modules/puppeteer-core/lib/puppeteer/node/ScreenRecorder.js
+import { spawn, spawnSync } from "node:child_process";
+import fs3 from "node:fs";
+import os3 from "node:os";
+import { dirname } from "node:path";
+import { PassThrough } from "node:stream";
+var __runInitializers = function(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0;i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : undefined;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== undefined && typeof f !== "function")
+      throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn)
+      context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access)
+      context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done)
+        throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === undefined)
+        continue;
+      if (result === null || typeof result !== "object")
+        throw new TypeError("Object expected");
+      if (_ = accept(result.get))
+        descriptor.get = _;
+      if (_ = accept(result.set))
+        descriptor.set = _;
+      if (_ = accept(result.init))
+        initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field")
+        initializers.unshift(_);
+      else
+        descriptor[key] = _;
+    }
+  }
+  if (target)
+    Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var __setFunctionName = function(f, name, prefix) {
+  if (typeof name === "symbol")
+    name = name.description ? "[".concat(name.description, "]") : "";
+  return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+var CRF_VALUE = 30;
+var DEFAULT_FPS = 30;
+var debugFfmpeg = debug("puppeteer:ffmpeg");
+var ScreenRecorder = (() => {
+  let _classSuper = PassThrough;
+  let _instanceExtraInitializers = [];
+  let _private_writeFrame_decorators;
+  let _private_writeFrame_descriptor;
+  let _stop_decorators;
+  return class ScreenRecorder2 extends _classSuper {
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : undefined;
+      __esDecorate(this, _private_writeFrame_descriptor = { value: __setFunctionName(async function(buffer) {
+        const error = await new Promise((resolve) => {
+          this.#process.stdin.write(buffer, resolve);
+        });
+        if (error) {
+          console.log(`ffmpeg failed to write: ${error.message}.`);
+        }
+      }, "#writeFrame") }, _private_writeFrame_decorators, { kind: "method", name: "#writeFrame", static: false, private: true, access: { has: (obj) => (#writeFrame in obj), get: (obj) => obj.#writeFrame }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: (obj) => ("stop" in obj), get: (obj) => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers);
+      if (_metadata)
+        Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    }
+    #page = __runInitializers(this, _instanceExtraInitializers);
+    #process;
+    #controller = new AbortController;
+    #lastFrame;
+    #fps;
+    constructor(page, width, height, { ffmpegPath, speed, scale, crop, format, fps, loop, delay, quality, colors, path: path3, overwrite } = {}) {
+      super({ allowHalfOpen: false });
+      ffmpegPath ??= "ffmpeg";
+      format ??= "webm";
+      fps ??= DEFAULT_FPS;
+      loop ||= -1;
+      delay ??= -1;
+      quality ??= CRF_VALUE;
+      colors ??= 256;
+      overwrite ??= true;
+      this.#fps = fps;
+      const { error } = spawnSync(ffmpegPath);
+      if (error) {
+        throw error;
+      }
+      const filters = [
+        `crop='min(${width},iw):min(${height},ih):0:0'`,
+        `pad=${width}:${height}:0:0`
+      ];
+      if (speed) {
+        filters.push(`setpts=${1 / speed}*PTS`);
+      }
+      if (crop) {
+        filters.push(`crop=${crop.width}:${crop.height}:${crop.x}:${crop.y}`);
+      }
+      if (scale) {
+        filters.push(`scale=iw*${scale}:-1:flags=lanczos`);
+      }
+      const formatArgs = this.#getFormatArgs(format, fps, loop, delay, quality, colors);
+      const vf = formatArgs.indexOf("-vf");
+      if (vf !== -1) {
+        filters.push(formatArgs.splice(vf, 2).at(-1) ?? "");
+      }
+      if (path3) {
+        fs3.mkdirSync(dirname(path3), { recursive: overwrite });
+      }
+      this.#process = spawn(ffmpegPath, [
+        ["-loglevel", "error"],
+        ["-avioflags", "direct"],
+        [
+          "-fpsprobesize",
+          "0",
+          "-probesize",
+          "32",
+          "-analyzeduration",
+          "0",
+          "-fflags",
+          "nobuffer"
+        ],
+        ["-f", "image2pipe", "-vcodec", "png", "-i", "pipe:0"],
+        ["-an"],
+        ["-threads", "1"],
+        ["-framerate", `${fps}`],
+        ["-b:v", "0"],
+        formatArgs,
+        ["-vf", filters.join()],
+        [overwrite ? "-y" : "-n"],
+        "pipe:1"
+      ].flat(), { stdio: ["pipe", "pipe", "pipe"] });
+      this.#process.stdout.pipe(this);
+      this.#process.stderr.on("data", (data) => {
+        debugFfmpeg(data.toString("utf8"));
+      });
+      this.#page = page;
+      const { client } = this.#page.mainFrame();
+      client.once(CDPSessionEvent.Disconnected, () => {
+        this.stop().catch(debugError);
+      });
+      this.#lastFrame = lastValueFrom(fromEmitterEvent(client, "Page.screencastFrame").pipe(tap((event) => {
+        client.send("Page.screencastFrameAck", {
+          sessionId: event.sessionId
+        });
+      }), filter((event) => {
+        return event.metadata.timestamp !== undefined;
+      }), map((event) => {
+        return {
+          buffer: Buffer.from(event.data, "base64"),
+          timestamp: event.metadata.timestamp
+        };
+      }), bufferCount(2, 1), concatMap(([{ timestamp: previousTimestamp, buffer }, { timestamp }]) => {
+        return from(Array(Math.round(fps * Math.max(timestamp - previousTimestamp, 0))).fill(buffer));
+      }), map((buffer) => {
+        this.#writeFrame(buffer);
+        return [buffer, performance.now()];
+      }), takeUntil(fromEvent(this.#controller.signal, "abort"))), { defaultValue: [Buffer.from([]), performance.now()] });
+    }
+    #getFormatArgs(format, fps, loop, delay, quality, colors) {
+      const libvpx = [
+        ["-vcodec", "vp9"],
+        ["-crf", `${quality}`],
+        [
+          "-deadline",
+          "realtime",
+          "-cpu-used",
+          `${Math.min(os3.cpus().length / 2, 8)}`
+        ]
+      ];
+      switch (format) {
+        case "webm":
+          return [
+            ...libvpx,
+            ["-f", "webm"]
+          ].flat();
+        case "gif":
+          fps = DEFAULT_FPS === fps ? 20 : "source_fps";
+          if (loop === Infinity) {
+            loop = 0;
+          }
+          if (delay !== -1) {
+            delay /= 10;
+          }
+          return [
+            [
+              "-vf",
+              `fps=${fps},split[s0][s1];[s0]palettegen=stats_mode=diff:max_colors=${colors}[p];[s1][p]paletteuse=dither=bayer`
+            ],
+            ["-loop", `${loop}`],
+            ["-final_delay", `${delay}`],
+            ["-f", "gif"]
+          ].flat();
+        case "mp4":
+          return [
+            ...libvpx,
+            ["-movflags", "hybrid_fragmented"],
+            ["-f", "mp4"]
+          ].flat();
+      }
+    }
+    get #writeFrame() {
+      return _private_writeFrame_descriptor.value;
+    }
+    async stop() {
+      if (this.#controller.signal.aborted) {
+        return;
+      }
+      await this.#page._stopScreencast().catch(debugError);
+      this.#controller.abort();
+      const [buffer, timestamp] = await this.#lastFrame;
+      await Promise.all(Array(Math.max(1, Math.round(this.#fps * (performance.now() - timestamp) / 1000))).fill(buffer).map(this.#writeFrame.bind(this)));
+      this.#process.stdin.end();
+      await new Promise((resolve) => {
+        this.#process.once("close", resolve);
+      });
+    }
+    async[(_private_writeFrame_decorators = [guarded()], _stop_decorators = [guarded()], asyncDisposeSymbol)]() {
+      await this.stop();
+      await super[asyncDisposeSymbol]();
+    }
+  };
+})();
+// node_modules/puppeteer-core/lib/puppeteer/puppeteer-core.js
+import fs4 from "node:fs";
+import path3 from "node:path";
+environment.value = {
+  fs: fs4,
+  path: path3,
+  ScreenRecorder
+};
+var puppeteer = new PuppeteerNode({
+  isPuppeteerCore: true
+});
+var {
+  connect,
+  defaultArgs,
+  executablePath,
+  launch: launch2
+} = puppeteer;
+var puppeteer_core_default = puppeteer;
+export {
+  withSourcePuppeteerURLIfNone,
+  valueFromRemoteObjectReference,
+  valueFromPrimitiveRemoteObject,
+  valueFromJSHandle,
+  validateDialogType,
+  unitToPixels,
+  transposeIterableHandle,
+  timeout,
+  throwIfDetached,
+  supportedMetrics,
+  setLogCapture,
+  setDefaultScreenshotOptions,
+  scriptInjector,
+  rewriteError,
+  removeMatchingFlags,
+  releaseObject,
+  referrerPolicyToProtocol,
+  parsePSelectors,
+  parsePDFOptions,
+  paperFormats,
+  pageBindingInitString,
+  normalizeHeaderValue,
+  launch2 as launch,
+  isTargetClosedError,
+  isString,
+  isRegExp,
+  isPlainObject,
+  isNumber,
+  isErrorLike,
+  isErrnoException,
+  isDate,
+  importDebug,
+  headersArray,
+  handleError,
+  getSourceUrlComment,
+  getSourcePuppeteerURLIfAvailable,
+  getReadableFromProtocolStream,
+  getReadableAsTypedArray,
+  getQueryHandlerAndSelector,
+  getFeatures,
+  getCapturedLogs,
+  fromEmitterEvent,
+  fromAbortSignal,
+  filterAsync,
+  executablePath,
+  evaluationString,
+  disposeSymbol,
+  defaultArgs,
+  puppeteer_core_default as default,
+  debugError,
+  debug,
+  customQueryHandlers,
+  createProtocolErrorMessage,
+  createIncrementalIdGenerator,
+  createEvaluationError,
+  createConsoleMessage,
+  createClientError,
+  convertSameSiteFromPuppeteerToCdp,
+  convertCookiesPartitionKeyFromPuppeteerToCdp,
+  convertConsoleMessageLevel,
+  connect,
+  bindIsolatedHandle,
+  asyncDisposeSymbol,
+  assert,
+  addPageBinding,
+  _keyDefinitions,
+  _connectToCdpBrowser,
+  XPathQueryHandler,
+  WorkerTarget,
+  WebWorkerEvent,
+  WebWorker,
+  WebMCPToolCall,
+  WebMCPTool,
+  WebMCP,
+  WaitTask,
+  WEB_PERMISSION_TO_PROTOCOL_PERMISSION,
+  UnsupportedOperation,
+  UTILITY_WORLD_NAME,
+  Tracing,
+  Touchscreen,
+  TouchError,
+  TimeoutSettings,
+  TimeoutError,
+  TextQueryHandler,
+  TaskQueue,
+  TaskManager,
+  TargetType,
+  TargetManager,
+  TargetCloseError,
+  Target,
+  SuppressedError,
+  SecurityDetails,
+  ScriptInjector,
+  ScreenRecorder,
+  STATUS_TEXTS,
+  SOURCE_URL_REGEX,
+  Realm,
+  RaceLocator,
+  RETRY_DELAY,
+  QueryHandler,
+  PuppeteerURL,
+  PuppeteerNode,
+  PuppeteerError,
+  Puppeteer,
+  ProtocolError,
+  PredefinedNetworkConditions,
+  PipeTransport,
+  PierceQueryHandler,
+  PageTarget,
+  Page,
+  PUPPETEER_WORLD,
+  PUPPETEER_REVISIONS,
+  PQueryHandler,
+  OtherTarget,
+  NodeLocator,
+  NetworkManagerEvent,
+  NetworkManager,
+  NetworkEventManager,
+  NETWORK_IDLE_TIME,
+  Mutex,
+  MouseButton,
+  Mouse,
+  MappedLocator,
+  MAIN_WORLD,
+  LocatorEvent,
+  Locator,
+  LifecycleWatcher,
+  LazyArg,
+  KnownDevices,
+  Keyboard,
+  JSHandle,
+  JSCoverage,
+  IsolatedWorld,
+  InterceptResolutionAction,
+  InitializationStatus,
+  HTTPResponse,
+  HTTPRequest,
+  FunctionLocator,
+  FrameTree,
+  FrameManagerEvent,
+  FrameManager,
+  FrameEvent,
+  Frame,
+  FirefoxLauncher,
+  FilteredLocator,
+  FileChooser,
+  ExtensionTransport,
+  Extension,
+  ExecutionContext,
+  EventEmitter,
+  EmulationManager,
+  EmulatedState,
+  ElementHandle,
+  DisposableStackPolyfill,
+  DisposableStack,
+  Dialog,
+  DeviceRequestPrompt,
+  DevToolsTarget,
+  DelegatedLocator,
+  Deferred,
+  DEFAULT_VIEWPORT,
+  DEFAULT_INTERCEPT_RESOLUTION_PRIORITY,
+  CustomQueryHandlerRegistry,
+  Coverage,
+  ConsoleMessage,
+  ConnectionClosedError,
+  Connection,
+  ChromeLauncher,
+  CdpWebWorker,
+  CdpTouchscreen,
+  CdpTouchHandle,
+  CdpTarget,
+  CdpPreloadScript,
+  CdpPage,
+  CdpMouse,
+  CdpKeyboard,
+  CdpJSHandle,
+  CdpHTTPResponse,
+  CdpHTTPRequest,
+  CdpFrame,
+  CdpElementHandle,
+  CdpDialog,
+  CdpDeviceRequestPromptManager,
+  CdpDeviceRequestPrompt,
+  CdpCDPSession,
+  CdpBrowserContext,
+  CdpBrowser,
+  CdpBluetoothEmulation,
+  CallbackRegistry,
+  Callback,
+  CSSCoverage,
+  CDP_BINDING_PREFIX,
+  CDPSessionEvent,
+  CDPSession,
+  BrowserWebSocketTransport,
+  BrowserLauncher,
+  BrowserContext,
+  Browser,
+  Binding,
+  AsyncIterableUtil,
+  AsyncDisposableStackPolyfill,
+  AsyncDisposableStack,
+  Accessibility,
+  ARIAQueryHandler
+};