@holydeck/cli 2026.9.2

package/dist/puppeteer-RDWY6FSG.js

@@ -0,0 +1,2386 @@
+#!/usr/bin/env node
+import { createRequire as __holydeckCreateRequire } from 'node:module';
+const require = __holydeckCreateRequire(import.meta.url);
+import {
+  convertPuppeteerChannelToBrowsersChannel
+} from "./chunk-DIBLSFAG.js";
+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 "./chunk-UC6TFXMD.js";
+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,
+  CdpScreenRecording,
+  CdpTarget,
+  CdpTouchHandle,
+  CdpTouchscreen,
+  CdpWebWorker,
+  Connection,
+  ConnectionClosedError,
+  ConsoleMessage,
+  Coverage,
+  CustomQueryHandlerRegistry,
+  DEFAULT_INTERCEPT_RESOLUTION_PRIORITY,
+  DEFAULT_VIEWPORT,
+  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,
+  NETWORK_IDLE_TIME,
+  NetworkEventManager,
+  NetworkManager,
+  NetworkManagerEvent,
+  NodeLocator,
+  OtherTarget,
+  PQueryHandler,
+  PUPPETEER_REVISIONS,
+  PUPPETEER_WORLD,
+  Page,
+  PageTarget,
+  PierceQueryHandler,
+  PredefinedNetworkConditions,
+  ProtocolError,
+  Puppeteer,
+  PuppeteerError,
+  PuppeteerURL,
+  QueryHandler,
+  RETRY_DELAY,
+  RaceLocator,
+  Realm,
+  SOURCE_URL_REGEX,
+  STATUS_TEXTS,
+  ScreenRecording,
+  ScriptInjector,
+  SecurityDetails,
+  SuppressedError,
+  Target,
+  TargetCloseError,
+  TargetManager,
+  TargetType,
+  TaskManager,
+  TaskQueue,
+  TextQueryHandler,
+  TimeoutError,
+  TimeoutSettings,
+  TouchError,
+  Touchscreen,
+  Tracing,
+  UTILITY_WORLD_NAME,
+  UnsupportedOperation,
+  WEB_PERMISSION_TO_PROTOCOL_PERMISSION,
+  WaitTask,
+  WebMCP,
+  WebMCPTool,
+  WebMCPToolCall,
+  WebWorker,
+  WebWorkerEvent,
+  WorkerTarget,
+  XPathQueryHandler,
+  _connectToCdpBrowser,
+  _keyDefinitions,
+  addPageBinding,
+  assert,
+  assertSupportedUrlRestrictions,
+  asyncDisposeSymbol,
+  bindIsolatedHandle,
+  bufferCount,
+  concatMap,
+  convertConsoleMessageLevel,
+  convertCookiesPartitionKeyFromPuppeteerToCdp,
+  convertSameSiteFromPuppeteerToCdp,
+  createClientError,
+  createConsoleMessage,
+  createEvaluationError,
+  createIncrementalIdGenerator,
+  createProtocolErrorMessage,
+  customQueryHandlers,
+  disposeSymbol,
+  evaluationString,
+  filter,
+  filterAsync,
+  firstValueFrom,
+  from,
+  fromAbortSignal,
+  fromEmitterEvent,
+  fromEvent,
+  getQueryHandlerAndSelector,
+  getReadableAsTypedArray,
+  getReadableFromProtocolStream,
+  getSourcePuppeteerURLIfAvailable,
+  getSourceUrlComment,
+  guarded,
+  handleError,
+  headersArray,
+  isDate,
+  isErrnoException,
+  isErrorLike,
+  isNumber,
+  isPlainObject,
+  isRegExp,
+  isString,
+  isTargetClosedError,
+  lastValueFrom,
+  map,
+  normalizeHeaderValue,
+  pageBindingInitString,
+  paperFormats,
+  parsePDFOptions,
+  parsePSelectors,
+  race,
+  referrerPolicyToProtocol,
+  releaseObject,
+  rewriteError,
+  scriptInjector,
+  setDefaultScreenshotOptions,
+  supportedMetrics,
+  takeUntil,
+  tap,
+  throwIfDetached,
+  timeout,
+  timer,
+  transposeIterableHandle,
+  unitToPixels,
+  validateDialogType,
+  valueFromJSHandle,
+  valueFromPrimitiveRemoteObject,
+  valueFromRemoteObjectReference,
+  withSourcePuppeteerURLIfNone
+} from "./chunk-NP3DTWF7.js";
+import {
+  BrowserWebSocketTransport
+} from "./chunk-SWG4X375.js";
+import {
+  NodeWebSocketTransport
+} from "./chunk-JM4YIWBN.js";
+import "./chunk-V77AQPDK.js";
+import {
+  DEBUG_PREFIXES,
+  debug,
+  environment,
+  getCapturedLogs,
+  setLogCapture
+} from "./chunk-XAENXL52.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-IEJ3OX3N.js";
+
+// ../../node_modules/.pnpm/lilconfig@3.1.3/node_modules/lilconfig/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/lilconfig@3.1.3/node_modules/lilconfig/src/index.js"(exports, module) {
+    "use strict";
+    var path4 = __require("path");
+    var fs4 = __require("fs");
+    var os4 = __require("os");
+    var url = __require("url");
+    var fsReadFileAsync = fs4.promises.readFile;
+    function getDefaultSearchPlaces(name, sync) {
+      return [
+        "package.json",
+        `.${name}rc.json`,
+        `.${name}rc.js`,
+        `.${name}rc.cjs`,
+        ...sync ? [] : [`.${name}rc.mjs`],
+        `.config/${name}rc`,
+        `.config/${name}rc.json`,
+        `.config/${name}rc.js`,
+        `.config/${name}rc.cjs`,
+        ...sync ? [] : [`.config/${name}rc.mjs`],
+        `${name}.config.js`,
+        `${name}.config.cjs`,
+        ...sync ? [] : [`${name}.config.mjs`]
+      ];
+    }
+    function parentDir(p) {
+      return path4.dirname(p) || path4.sep;
+    }
+    var jsonLoader = (_, content) => JSON.parse(content);
+    var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+    var defaultLoadersSync = Object.freeze({
+      ".js": requireFunc,
+      ".json": requireFunc,
+      ".cjs": requireFunc,
+      noExt: jsonLoader
+    });
+    module.exports.defaultLoadersSync = defaultLoadersSync;
+    var dynamicImport = async (id) => {
+      try {
+        const fileUrl = url.pathToFileURL(id).href;
+        const mod = await import(
+          /* webpackIgnore: true */
+          fileUrl
+        );
+        return mod.default;
+      } catch (e) {
+        try {
+          return requireFunc(id);
+        } catch (requireE) {
+          if (requireE.code === "ERR_REQUIRE_ESM" || requireE instanceof SyntaxError && requireE.toString().includes("Cannot use import statement outside a module")) {
+            throw e;
+          }
+          throw requireE;
+        }
+      }
+    };
+    var defaultLoaders = Object.freeze({
+      ".js": dynamicImport,
+      ".mjs": dynamicImport,
+      ".cjs": dynamicImport,
+      ".json": jsonLoader,
+      noExt: jsonLoader
+    });
+    module.exports.defaultLoaders = defaultLoaders;
+    function getOptions(name, options, sync) {
+      const conf = {
+        stopDir: os4.homedir(),
+        searchPlaces: getDefaultSearchPlaces(name, sync),
+        ignoreEmptySearchPlaces: true,
+        cache: true,
+        transform: (x) => x,
+        packageProp: [name],
+        ...options,
+        loaders: {
+          ...sync ? defaultLoadersSync : defaultLoaders,
+          ...options.loaders
+        }
+      };
+      conf.searchPlaces.forEach((place) => {
+        const key = path4.extname(place) || "noExt";
+        const loader = conf.loaders[key];
+        if (!loader) {
+          throw new Error(`Missing loader for extension "${place}"`);
+        }
+        if (typeof loader !== "function") {
+          throw new Error(
+            `Loader for extension "${place}" is not a function: Received ${typeof loader}.`
+          );
+        }
+      });
+      return conf;
+    }
+    function getPackageProp(props, obj) {
+      if (typeof props === "string" && props in obj) return obj[props];
+      return (Array.isArray(props) ? props : props.split(".")).reduce(
+        (acc, prop) => acc === void 0 ? acc : acc[prop],
+        obj
+      ) || null;
+    }
+    function validateFilePath(filepath) {
+      if (!filepath) throw new Error("load must pass a non-empty string");
+    }
+    function validateLoader(loader, ext) {
+      if (!loader) throw new Error(`No loader specified for extension "${ext}"`);
+      if (typeof loader !== "function") throw new Error("loader is not a function");
+    }
+    var makeEmplace = (enableCache) => (c, filepath, res) => {
+      if (enableCache) c.set(filepath, res);
+      return res;
+    };
+    module.exports.lilconfig = function lilconfig2(name, options) {
+      const {
+        ignoreEmptySearchPlaces,
+        loaders,
+        packageProp,
+        searchPlaces,
+        stopDir,
+        transform,
+        cache
+      } = getOptions(name, options ?? {}, false);
+      const searchCache = /* @__PURE__ */ new Map();
+      const loadCache = /* @__PURE__ */ new Map();
+      const emplace = makeEmplace(cache);
+      return {
+        async search(searchFrom = process.cwd()) {
+          const result = {
+            config: null,
+            filepath: ""
+          };
+          const visited = /* @__PURE__ */ new Set();
+          let dir = searchFrom;
+          dirLoop: while (true) {
+            if (cache) {
+              const r = searchCache.get(dir);
+              if (r !== void 0) {
+                for (const p of visited) searchCache.set(p, r);
+                return r;
+              }
+              visited.add(dir);
+            }
+            for (const searchPlace of searchPlaces) {
+              const filepath = path4.join(dir, searchPlace);
+              try {
+                await fs4.promises.access(filepath);
+              } catch {
+                continue;
+              }
+              const content = String(await fsReadFileAsync(filepath));
+              const loaderKey = path4.extname(searchPlace) || "noExt";
+              const loader = loaders[loaderKey];
+              if (searchPlace === "package.json") {
+                const pkg = await loader(filepath, content);
+                const maybeConfig = getPackageProp(packageProp, pkg);
+                if (maybeConfig != null) {
+                  result.config = maybeConfig;
+                  result.filepath = filepath;
+                  break dirLoop;
+                }
+                continue;
+              }
+              const isEmpty = content.trim() === "";
+              if (isEmpty && ignoreEmptySearchPlaces) continue;
+              if (isEmpty) {
+                result.isEmpty = true;
+                result.config = void 0;
+              } else {
+                validateLoader(loader, loaderKey);
+                result.config = await loader(filepath, content);
+              }
+              result.filepath = filepath;
+              break dirLoop;
+            }
+            if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+            dir = parentDir(dir);
+          }
+          const transformed = (
+            // not found
+            result.filepath === "" && result.config === null ? transform(null) : transform(result)
+          );
+          if (cache) {
+            for (const p of visited) searchCache.set(p, transformed);
+          }
+          return transformed;
+        },
+        async load(filepath) {
+          validateFilePath(filepath);
+          const absPath = path4.resolve(process.cwd(), filepath);
+          if (cache && loadCache.has(absPath)) {
+            return loadCache.get(absPath);
+          }
+          const { base, ext } = path4.parse(absPath);
+          const loaderKey = ext || "noExt";
+          const loader = loaders[loaderKey];
+          validateLoader(loader, loaderKey);
+          const content = String(await fsReadFileAsync(absPath));
+          if (base === "package.json") {
+            const pkg = await loader(absPath, content);
+            return emplace(
+              loadCache,
+              absPath,
+              transform({
+                config: getPackageProp(packageProp, pkg),
+                filepath: absPath
+              })
+            );
+          }
+          const result = {
+            config: null,
+            filepath: absPath
+          };
+          const isEmpty = content.trim() === "";
+          if (isEmpty && ignoreEmptySearchPlaces)
+            return emplace(
+              loadCache,
+              absPath,
+              transform({
+                config: void 0,
+                filepath: absPath,
+                isEmpty: true
+              })
+            );
+          result.config = isEmpty ? void 0 : await loader(absPath, content);
+          return emplace(
+            loadCache,
+            absPath,
+            transform(isEmpty ? { ...result, isEmpty, config: void 0 } : result)
+          );
+        },
+        clearLoadCache() {
+          if (cache) loadCache.clear();
+        },
+        clearSearchCache() {
+          if (cache) searchCache.clear();
+        },
+        clearCaches() {
+          if (cache) {
+            loadCache.clear();
+            searchCache.clear();
+          }
+        }
+      };
+    };
+    module.exports.lilconfigSync = function lilconfigSync(name, options) {
+      const {
+        ignoreEmptySearchPlaces,
+        loaders,
+        packageProp,
+        searchPlaces,
+        stopDir,
+        transform,
+        cache
+      } = getOptions(name, options ?? {}, true);
+      const searchCache = /* @__PURE__ */ new Map();
+      const loadCache = /* @__PURE__ */ new Map();
+      const emplace = makeEmplace(cache);
+      return {
+        search(searchFrom = process.cwd()) {
+          const result = {
+            config: null,
+            filepath: ""
+          };
+          const visited = /* @__PURE__ */ new Set();
+          let dir = searchFrom;
+          dirLoop: while (true) {
+            if (cache) {
+              const r = searchCache.get(dir);
+              if (r !== void 0) {
+                for (const p of visited) searchCache.set(p, r);
+                return r;
+              }
+              visited.add(dir);
+            }
+            for (const searchPlace of searchPlaces) {
+              const filepath = path4.join(dir, searchPlace);
+              try {
+                fs4.accessSync(filepath);
+              } catch {
+                continue;
+              }
+              const loaderKey = path4.extname(searchPlace) || "noExt";
+              const loader = loaders[loaderKey];
+              const content = String(fs4.readFileSync(filepath));
+              if (searchPlace === "package.json") {
+                const pkg = loader(filepath, content);
+                const maybeConfig = getPackageProp(packageProp, pkg);
+                if (maybeConfig != null) {
+                  result.config = maybeConfig;
+                  result.filepath = filepath;
+                  break dirLoop;
+                }
+                continue;
+              }
+              const isEmpty = content.trim() === "";
+              if (isEmpty && ignoreEmptySearchPlaces) continue;
+              if (isEmpty) {
+                result.isEmpty = true;
+                result.config = void 0;
+              } else {
+                validateLoader(loader, loaderKey);
+                result.config = loader(filepath, content);
+              }
+              result.filepath = filepath;
+              break dirLoop;
+            }
+            if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+            dir = parentDir(dir);
+          }
+          const transformed = (
+            // not found
+            result.filepath === "" && result.config === null ? transform(null) : transform(result)
+          );
+          if (cache) {
+            for (const p of visited) searchCache.set(p, transformed);
+          }
+          return transformed;
+        },
+        load(filepath) {
+          validateFilePath(filepath);
+          const absPath = path4.resolve(process.cwd(), filepath);
+          if (cache && loadCache.has(absPath)) {
+            return loadCache.get(absPath);
+          }
+          const { base, ext } = path4.parse(absPath);
+          const loaderKey = ext || "noExt";
+          const loader = loaders[loaderKey];
+          validateLoader(loader, loaderKey);
+          const content = String(fs4.readFileSync(absPath));
+          if (base === "package.json") {
+            const pkg = loader(absPath, content);
+            return transform({
+              config: getPackageProp(packageProp, pkg),
+              filepath: absPath
+            });
+          }
+          const result = {
+            config: null,
+            filepath: absPath
+          };
+          const isEmpty = content.trim() === "";
+          if (isEmpty && ignoreEmptySearchPlaces)
+            return emplace(
+              loadCache,
+              absPath,
+              transform({
+                filepath: absPath,
+                config: void 0,
+                isEmpty: true
+              })
+            );
+          result.config = isEmpty ? void 0 : loader(absPath, content);
+          return emplace(
+            loadCache,
+            absPath,
+            transform(isEmpty ? { ...result, isEmpty, config: void 0 } : result)
+          );
+        },
+        clearLoadCache() {
+          if (cache) loadCache.clear();
+        },
+        clearSearchCache() {
+          if (cache) searchCache.clear();
+        },
+        clearCaches() {
+          if (cache) {
+            loadCache.clear();
+            searchCache.clear();
+          }
+        }
+      };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node-env-setup.js
+import fs from "fs";
+import path from "path";
+import { debuglog } from "util";
+var READ_NOFOLLOW_FLAGS = fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW;
+var WRITE_NOFOLLOW_FLAGS = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_TRUNC | fs.constants.O_NOFOLLOW;
+var WRITE_NOFOLLOW_NOOVERWRITE_FLAGS = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW;
+var WRITE_NOOVERWRITE_FLAGS = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL;
+var WRITE_NOFOLLOW_MODE = 384;
+async function readFile(path4, encoding) {
+  if (!environment.value.followSymlinks && fs.constants.O_NOFOLLOW !== void 0) {
+    return await fs.promises.readFile(path4, {
+      encoding,
+      flag: READ_NOFOLLOW_FLAGS
+    });
+  }
+  return await fs.promises.readFile(path4, { encoding });
+}
+environment.value = {
+  path,
+  debuglog,
+  ScreenRecorder: environment.value.ScreenRecorder,
+  followSymlinks: true,
+  readFile,
+  writeFile: async (filePath, data) => {
+    if (!environment.value.followSymlinks && fs.constants.O_NOFOLLOW !== void 0) {
+      await fs.promises.writeFile(filePath, data, {
+        flag: WRITE_NOFOLLOW_FLAGS,
+        mode: WRITE_NOFOLLOW_MODE
+      });
+    } else {
+      await fs.promises.writeFile(filePath, data);
+    }
+  },
+  openFileForWriting: async (filePath) => {
+    if (!environment.value.followSymlinks && fs.constants.O_NOFOLLOW !== void 0) {
+      return await fs.promises.open(filePath, WRITE_NOFOLLOW_FLAGS, WRITE_NOFOLLOW_MODE);
+    }
+    return await fs.promises.open(filePath, "w+");
+  },
+  createWriteStream: (filePath, options) => {
+    const encoding = options?.encoding;
+    const overwrite = options?.overwrite ?? true;
+    if (!environment.value.followSymlinks && fs.constants.O_NOFOLLOW !== void 0) {
+      const flags = overwrite ? WRITE_NOFOLLOW_FLAGS : WRITE_NOFOLLOW_NOOVERWRITE_FLAGS;
+      const fd = fs.openSync(filePath, flags, WRITE_NOFOLLOW_MODE);
+      return fs.createWriteStream("", {
+        fd,
+        mode: WRITE_NOFOLLOW_MODE,
+        encoding
+      });
+    }
+    if (!overwrite) {
+      const fd = fs.openSync(filePath, WRITE_NOOVERWRITE_FLAGS);
+      return fs.createWriteStream("", {
+        fd,
+        encoding
+      });
+    }
+    return fs.createWriteStream(filePath, encoding ? { encoding } : void 0);
+  },
+  mkdir: async (dirPath, options) => {
+    await fs.promises.mkdir(dirPath, options);
+  }
+};
+
+// ../../node_modules/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node/ChromeLauncher.js
+import { mkdtemp } from "fs/promises";
+import os from "os";
+import path2 from "path";
+
+// ../../node_modules/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node/BrowserLauncher.js
+import { accessSync, constants, existsSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// ../../node_modules/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node/PipeTransport.js
+var PipeTransport = class {
+  #pipeWrite;
+  #subscriptions = new DisposableStack();
+  #logger;
+  #isClosed = false;
+  #pendingMessage = [];
+  onclose;
+  onmessage;
+  constructor(pipeWrite, pipeRead, logger) {
+    this.#pipeWrite = pipeWrite;
+    this.#logger = logger;
+    const pipeReadEmitter = this.#subscriptions.use(
+      // NodeJS event emitters don't support `*` so we need to typecast
+      // As long as we don't use it we should be OK.
+      new EventEmitter(pipeRead, logger)
+    );
+    pipeReadEmitter.on("data", (buffer) => {
+      return this.#dispatch(buffer);
+    });
+    pipeReadEmitter.on("close", () => {
+      if (this.onclose) {
+        this.onclose.call(null);
+      }
+    });
+    pipeReadEmitter.on("error", (err) => {
+      this.#logger?.(DEBUG_PREFIXES.error)?.(err);
+    });
+    const pipeWriteEmitter = this.#subscriptions.use(
+      // NodeJS event emitters don't support `*` so we need to typecast
+      // As long as we don't use it we should be OK.
+      new EventEmitter(pipeWrite)
+    );
+    pipeWriteEmitter.on("error", (err) => {
+      this.#logger?.(DEBUG_PREFIXES.error)?.(err);
+    });
+  }
+  send(message) {
+    assert(!this.#isClosed, "`PipeTransport` is closed.");
+    this.#pipeWrite.write(message);
+    this.#pipeWrite.write("\0");
+  }
+  #dispatch(buffer) {
+    assert(!this.#isClosed, "`PipeTransport` is closed.");
+    this.#pendingMessage.push(buffer);
+    if (buffer.indexOf("\0") === -1) {
+      return;
+    }
+    const concatBuffer = Buffer.concat(this.#pendingMessage);
+    let start = 0;
+    let end = concatBuffer.indexOf("\0");
+    while (end !== -1) {
+      const message = concatBuffer.toString(void 0, start, end);
+      setImmediate(() => {
+        if (this.onmessage) {
+          this.onmessage.call(null, message);
+        }
+      });
+      start = end + 1;
+      end = concatBuffer.indexOf("\0", start);
+    }
+    if (start >= concatBuffer.length) {
+      this.#pendingMessage = [];
+    } else {
+      this.#pendingMessage = [concatBuffer.subarray(start)];
+    }
+  }
+  close() {
+    this.#isClosed = true;
+    this.#subscriptions.dispose();
+  }
+};
+
+// ../../node_modules/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node/BrowserLauncher.js
+function isWritableDirectory(directory) {
+  try {
+    accessSync(directory, constants.W_OK);
+    return true;
+  } catch {
+    return !existsSync(directory);
+  }
+}
+function getBrowserTypeDisplayName(browserType) {
+  switch (browserType) {
+    case Browser2.FIREFOX:
+    case Browser2.CHROME:
+      return browserType.charAt(0).toUpperCase() + browserType.slice(1);
+    default:
+      return browserType;
+  }
+}
+var BrowserLauncher = class {
+  #browser;
+  #logger;
+  /**
+   * @internal
+   */
+  /**
+   * @internal
+   */
+  puppeteer;
+  /**
+   * @internal
+   */
+  constructor(puppeteer3, browser, logger) {
+    this.puppeteer = puppeteer3;
+    this.#browser = browser;
+    this.#logger = logger;
+  }
+  /**
+   * @internal
+   */
+  get logger() {
+    return this.#logger;
+  }
+  get browser() {
+    return this.#browser;
+  }
+  async launch(options = {}) {
+    options.logger ??= this.#logger;
+    const { dumpio = false, enableExtensions = false, extensionsEnabledInIncognito = [], env = process.env, handleSIGINT = true, handleSIGTERM = true, handleSIGHUP = true, acceptInsecureCerts = false, networkEnabled = true, issuesEnabled = true, defaultViewport = DEFAULT_VIEWPORT, downloadBehavior, slowMo = 0, timeout: timeout2 = 3e4, waitForInitialPage = true, protocolTimeout, handleDevToolsAsPage, idGenerator = createIncrementalIdGenerator(), blocklist, allowlist } = options;
+    let { protocol } = options;
+    if (this.#browser === "firefox" && protocol === void 0) {
+      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)) {
+      if (launchArgs.isTempUserDataDir) {
+        await this.cleanUserDataDir(launchArgs.userDataDir, {
+          isTemp: true
+        });
+      }
+      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,
+      logger: options.logger
+    });
+    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,
+          logger: options.logger
+        });
+      } else {
+        if (usePipe) {
+          cdpConnection = await this.createCdpPipeConnection(browserProcess, {
+            timeout: timeout2,
+            protocolTimeout,
+            slowMo,
+            idGenerator,
+            logger: options.logger
+          });
+        } else {
+          cdpConnection = await this.createCdpSocketConnection(browserProcess, {
+            timeout: timeout2,
+            protocolTimeout,
+            slowMo,
+            idGenerator,
+            logger: options.logger
+          });
+        }
+        if (protocol === "webDriverBiDi") {
+          browser = await this.createBiDiOverCdpBrowser(browserProcess, cdpConnection, browserCloseCallback, {
+            defaultViewport,
+            acceptInsecureCerts,
+            networkEnabled,
+            issuesEnabled,
+            logger: options.logger
+          });
+        } else {
+          browser = await CdpBrowser._create(cdpConnection, [], acceptInsecureCerts, defaultViewport, downloadBehavior, browserProcess.nodeProcess, browserCloseCallback, options.targetFilter, void 0, void 0, networkEnabled, issuesEnabled, handleDevToolsAsPage, blocklist, allowlist, options.logger);
+        }
+      }
+    } catch (error) {
+      void browserCloseCallback();
+      const logs = browserProcess.getRecentLogs().join("\n");
+      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || // On Windows we will not get logs due to the singleton process handover. See
+      // https://source.chromium.org/chromium/chromium/src/+/main:chrome/browser/process_singleton_win.cc;l=46;drc=fc7952f0422b5073515a205a04ec9c3a1ae81658
+      process.platform === "win32" && existsSync(join(launchArgs.userDataDir, "lockfile"))) {
+        if (!isWritableDirectory(launchArgs.userDataDir)) {
+          throw new Error(`The browser cannot write to ${launchArgs.userDataDir}. Make the \`userDataDir\` writable or use a different one.`);
+        }
+        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)) {
+      await Promise.all([
+        enableExtensions.map((path4) => {
+          return browser.installExtension(path4, {
+            enabledInIncognito: extensionsEnabledInIncognito.includes(path4)
+          });
+        })
+      ]);
+    }
+    if (waitForInitialPage) {
+      await this.waitForPageTarget(browser, timeout2);
+    }
+    return browser;
+  }
+  /**
+   * @internal
+   */
+  async closeBrowser(browserProcess, cdpConnection) {
+    if (cdpConnection) {
+      try {
+        await cdpConnection.closeBrowser();
+        await browserProcess.hasClosed();
+      } catch (error) {
+        this.#logger?.(DEBUG_PREFIXES.error)?.(error);
+        await browserProcess.close();
+      }
+    } else {
+      await firstValueFrom(race(from(browserProcess.hasClosed()), timer(5e3).pipe(map(() => {
+        return from(browserProcess.close());
+      }))));
+    }
+  }
+  /**
+   * @internal
+   */
+  async waitForPageTarget(browser, timeout2) {
+    try {
+      await browser.waitForTarget((t) => {
+        return t.type() === "page";
+      }, { timeout: timeout2 });
+    } catch (error) {
+      await browser.close();
+      throw error;
+    }
+  }
+  /**
+   * @internal
+   */
+  async createCdpSocketConnection(browserProcess, opts) {
+    const browserWSEndpoint = await browserProcess.waitForLineOutput(CDP_WEBSOCKET_ENDPOINT_REGEX, opts.timeout);
+    const transport = await NodeWebSocketTransport.create(browserWSEndpoint, void 0, opts.logger, opts.wsOptions);
+    return new Connection(
+      browserWSEndpoint,
+      transport,
+      opts.slowMo,
+      opts.protocolTimeout,
+      /* rawErrors */
+      false,
+      opts.idGenerator,
+      opts.logger
+    );
+  }
+  /**
+   * @internal
+   */
+  async createCdpPipeConnection(browserProcess, opts) {
+    const { 3: pipeWrite, 4: pipeRead } = browserProcess.nodeProcess.stdio;
+    const transport = new PipeTransport(pipeWrite, pipeRead, opts.logger);
+    return new Connection(
+      "",
+      transport,
+      opts.slowMo,
+      opts.protocolTimeout,
+      /* rawErrors */
+      false,
+      opts.idGenerator,
+      opts.logger
+    );
+  }
+  /**
+   * @internal
+   */
+  async createBiDiOverCdpBrowser(browserProcess, cdpConnection, closeCallback, opts) {
+    const bidiOnly = process.env["PUPPETEER_WEBDRIVER_BIDI_ONLY"] === "true";
+    const BiDi = await import(
+      /* webpackIgnore: true */
+      "./bidi-25S23FWJ.js"
+    );
+    const bidiConnection = await BiDi.connectBidiOverCdp(cdpConnection, opts.logger);
+    return await BiDi.BidiBrowser.create({
+      connection: bidiConnection,
+      // Do not provide CDP connection to Browser, if BiDi-only mode is enabled. This
+      // would restrict Browser to use only BiDi endpoint.
+      cdpConnection: bidiOnly ? void 0 : cdpConnection,
+      closeCallback,
+      process: browserProcess.nodeProcess,
+      defaultViewport: opts.defaultViewport,
+      acceptInsecureCerts: opts.acceptInsecureCerts,
+      networkEnabled: opts.networkEnabled,
+      issuesEnabled: opts.issuesEnabled,
+      logger: opts.logger
+    });
+  }
+  /**
+   * @internal
+   */
+  async createBiDiBrowser(browserProcess, closeCallback, opts) {
+    const browserWSEndpoint = await browserProcess.waitForLineOutput(WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX, opts.timeout) + "/session";
+    const transport = await NodeWebSocketTransport.create(browserWSEndpoint, void 0, opts.logger, opts.wsOptions);
+    const BiDi = await import(
+      /* webpackIgnore: true */
+      "./bidi-25S23FWJ.js"
+    );
+    const bidiConnection = new BiDi.BidiConnection(browserWSEndpoint, transport, opts.idGenerator, opts.slowMo, opts.protocolTimeout, opts.logger);
+    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,
+      logger: opts.logger
+    });
+  }
+  /**
+   * @internal
+   */
+  async getProfilePath() {
+    const config = await this.puppeteer.configuration();
+    return join(config.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
+  }
+  /**
+   * @internal
+   */
+  async resolveExecutablePath(headless, validatePath = true) {
+    const config = await this.puppeteer.configuration();
+    let executablePath3 = config.executablePath;
+    if (executablePath3) {
+      if (validatePath && !existsSync(executablePath3)) {
+        throw new Error(`Tried to find the browser at the configured path (${executablePath3}), but no executable was found.`);
+      }
+      return executablePath3;
+    }
+    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();
+    executablePath3 = computeExecutablePath({
+      cacheDir: defaultDownloadPath,
+      browser: browserType,
+      buildId: browserVersion
+    });
+    if (validatePath && !existsSync(executablePath3)) {
+      const configVersion = config?.[this.browser]?.version;
+      if (configVersion) {
+        throw new Error(`Tried to find the browser at the configured path (${executablePath3}) for version ${configVersion}, but no executable was found.`);
+      }
+      throw new Error(`Could not find ${getBrowserTypeDisplayName(browserType)} (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.`);
+    }
+    return executablePath3;
+  }
+};
+
+// ../../node_modules/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node/util/fs.js
+import fs2 from "fs";
+var rmOptions = {
+  force: true,
+  recursive: true,
+  maxRetries: 10,
+  retryDelay: 100
+};
+async function rm(path4) {
+  await fs2.promises.rm(path4, rmOptions);
+}
+
+// ../../node_modules/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node/ChromeLauncher.js
+var ChromeLauncher = class extends BrowserLauncher {
+  constructor(puppeteer3, logger) {
+    super(puppeteer3, "chrome", logger);
+  }
+  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("\n  "));
+      }
+    }
+    return await super.launch(options);
+  }
+  /**
+   * @internal
+   */
+  async computeLaunchArguments(options = {}) {
+    const { ignoreDefaultArgs = false, args = [], pipe = false, debuggingPort, channel, executablePath: executablePath3 } = 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;
+    const userDataDirIndex = chromeArguments.findIndex((arg) => {
+      return arg.startsWith("--user-data-dir");
+    });
+    let userDataDir;
+    if (userDataDirIndex < 0) {
+      isTempUserDataDir = true;
+      const profilePath = await this.getProfilePath();
+      userDataDir = await mkdtemp(profilePath);
+      chromeArguments.push(`--user-data-dir=${userDataDir}`);
+    } else {
+      const parsedUserDataDir = chromeArguments[userDataDirIndex].split("=", 2)[1];
+      assert(typeof parsedUserDataDir === "string", "`--user-data-dir` is malformed");
+      userDataDir = parsedUserDataDir;
+    }
+    let chromeExecutable = executablePath3;
+    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
+    };
+  }
+  /**
+   * @internal
+   */
+  async cleanUserDataDir(path4, opts) {
+    if (opts.isTemp) {
+      try {
+        await rm(path4);
+      } catch (error) {
+        this.logger(DEBUG_PREFIXES.error)?.(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",
+      // Add features to enable by default here.
+      ...userEnabledFeatures
+    ].filter((feature) => {
+      return feature !== "";
+    });
+    const disabledFeatures = [
+      "Translate",
+      // AcceptCHFrame disabled because of crbug.com/1348106.
+      "AcceptCHFrame",
+      "MediaRouter",
+      "OptimizationHints",
+      "WebUIReloadButton",
+      "WebUIOmniboxPopup",
+      "WebUIOmniboxAimPopup",
+      ...turnOnExperimentalFeaturesForTesting ? [] : [
+        // https://crbug.com/1492053
+        "ProcessPerSiteUpToMainFrameThreshold",
+        // https://github.com/puppeteer/puppeteer/issues/10715
+        "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",
+      // No crash reporting in CfT.
+      "--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=${path2.posix.isAbsolute(userDataDir) || path2.win32.isAbsolute(userDataDir) ? userDataDir : path2.resolve(userDataDir)}`);
+    }
+    if (devtools) {
+      chromeArguments.push("--auto-open-devtools-for-tabs");
+    }
+    if (headless) {
+      chromeArguments.push(headless === "shell" ? "--headless" : "--headless=new", "--hide-scrollbars", "--mute-audio");
+    }
+    if (!enableExtensions) {
+      chromeArguments.push("--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)
+      }, validatePath);
+    } else {
+      return await this.resolveExecutablePath(void 0, 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/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node/FirefoxLauncher.js
+import fs3 from "fs";
+import { rename, unlink, mkdtemp as mkdtemp2 } from "fs/promises";
+import os2 from "os";
+import path3 from "path";
+var FirefoxLauncher = class _FirefoxLauncher extends BrowserLauncher {
+  constructor(puppeteer3, logger) {
+    super(puppeteer3, "firefox", logger);
+  }
+  static getPreferences(extraPrefsFirefox) {
+    return {
+      ...extraPrefsFirefox,
+      // Force all web content to use a single content process. TODO: remove
+      // this once Firefox supports mouse event dispatch from the main frame
+      // context. See https://bugzilla.mozilla.org/show_bug.cgi?id=1773393.
+      "fission.webContentIsolationStrategy": 0
+    };
+  }
+  /**
+   * @internal
+   */
+  async computeLaunchArguments(options = {}) {
+    const { ignoreDefaultArgs = false, args = [], executablePath: executablePath3, 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 || executablePath3) {
+      assert(executablePath3, `An \`executablePath\` must be specified for \`puppeteer-core\``);
+      firefoxExecutable = executablePath3;
+    } else {
+      firefoxExecutable = await this.executablePath(void 0);
+    }
+    return {
+      isTempUserDataDir,
+      userDataDir,
+      args: firefoxArguments,
+      executablePath: firefoxExecutable
+    };
+  }
+  /**
+   * @internal
+   */
+  async cleanUserDataDir(userDataDir, opts) {
+    if (opts.isTemp) {
+      try {
+        await rm(userDataDir);
+      } catch (error) {
+        this.logger(DEBUG_PREFIXES.error)?.(error);
+      }
+    } else {
+      try {
+        const backupSuffix = ".puppeteer";
+        const backupFiles = ["prefs.js", "user.js"];
+        const results = await Promise.allSettled(backupFiles.map(async (file) => {
+          const prefsBackupPath = path3.join(userDataDir, file + backupSuffix);
+          if (fs3.existsSync(prefsBackupPath)) {
+            const prefsPath = path3.join(userDataDir, file);
+            await unlink(prefsPath);
+            await rename(prefsBackupPath, prefsPath);
+          }
+        }));
+        for (const result of results) {
+          if (result.status === "rejected") {
+            throw result.reason;
+          }
+        }
+      } catch (error) {
+        this.logger(DEBUG_PREFIXES.error)?.(error);
+      }
+    }
+  }
+  async executablePath(_, validatePath = true) {
+    return await this.resolveExecutablePath(
+      void 0,
+      /* validatePath=*/
+      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/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node/PuppeteerNode.js
+var PuppeteerNode = class extends Puppeteer {
+  #launcher;
+  #lastLaunchedBrowser;
+  configuration;
+  /**
+   * @internal
+   */
+  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);
+  }
+  /**
+   * This method attaches Puppeteer to an existing browser instance.
+   *
+   * @param options - Set of configurable options to set on the browser.
+   * @returns Promise which resolves to browser instance.
+   */
+  connect(options) {
+    options.logger ??= debug;
+    return super.connect(options);
+  }
+  /**
+   * Launches a browser instance with given arguments and options when
+   * specified.
+   *
+   * When using with `puppeteer-core`,
+   * {@link LaunchOptions.executablePath | options.executablePath} or
+   * {@link LaunchOptions.channel | options.channel} must be provided.
+   *
+   * @example
+   * You can use {@link LaunchOptions.ignoreDefaultArgs | options.ignoreDefaultArgs}
+   * to filter out `--mute-audio` from default arguments:
+   *
+   * ```ts
+   * const browser = await puppeteer.launch({
+   *   ignoreDefaultArgs: ['--mute-audio'],
+   * });
+   * ```
+   *
+   * @remarks
+   * Puppeteer can also be used to control the Chrome browser, but it works best
+   * with the version of Chrome for Testing downloaded by default.
+   * There is no guarantee it will work with any other version. If Google Chrome
+   * (rather than Chrome for Testing) is preferred, a
+   * {@link https://www.google.com/chrome/browser/canary.html | Chrome Canary}
+   * or
+   * {@link https://www.chromium.org/getting-involved/dev-channel | Dev Channel}
+   * build is suggested. See
+   * {@link https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/ | this article}
+   * for a description of the differences between Chromium and Chrome.
+   * {@link https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md | This article}
+   * describes some differences for Linux users. See
+   * {@link https://developer.chrome.com/blog/chrome-for-testing/ | this doc} for the description
+   * of Chrome for Testing.
+   *
+   * @param options - Options to configure launching behavior.
+   */
+  async launch(options = {}) {
+    options.logger ??= debug;
+    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, options.logger);
+    return await this.#launcher.launch(options);
+  }
+  #getLauncher(browser, logger) {
+    if (this.#launcher && this.#launcher.browser === browser) {
+      return this.#launcher;
+    }
+    switch (browser) {
+      case "chrome":
+        return new ChromeLauncher(this, logger);
+      case "firefox":
+        return new FirefoxLauncher(this, logger);
+      default:
+        throw new Error(`Unknown product: ${browser}`);
+    }
+  }
+  async executablePath(optsOrChannel) {
+    if (optsOrChannel === void 0) {
+      return await this.#getLauncher(await this.lastLaunchedBrowser(), debug).executablePath(
+        void 0,
+        /* validatePath= */
+        false
+      );
+    }
+    if (typeof optsOrChannel === "string") {
+      return await this.#getLauncher("chrome", debug).executablePath(
+        optsOrChannel,
+        /* validatePath= */
+        false
+      );
+    }
+    return await this.#getLauncher(optsOrChannel.browser ?? await this.lastLaunchedBrowser(), optsOrChannel.logger ?? debug).resolveExecutablePath(
+      optsOrChannel.headless,
+      /* validatePath= */
+      false
+    );
+  }
+  /**
+   * @internal
+   */
+  async browserVersion() {
+    const config = await this.configuration();
+    const lastLaunched = await this.lastLaunchedBrowser();
+    return config?.[lastLaunched]?.version ?? PUPPETEER_REVISIONS[lastLaunched];
+  }
+  /**
+   * The default download path for puppeteer. For puppeteer-core, this
+   * code should never be called as it is never defined.
+   *
+   * @internal
+   */
+  async defaultDownloadPath() {
+    const config = await this.configuration();
+    return config.cacheDirectory;
+  }
+  /**
+   * The name of the browser that was last launched.
+   */
+  async lastLaunchedBrowser() {
+    return this.#lastLaunchedBrowser ?? await this.defaultBrowser();
+  }
+  /**
+   * The name of the browser that will be launched by default. For
+   * `puppeteer`, this is influenced by your configuration. Otherwise, it's
+   * `chrome`.
+   */
+  async defaultBrowser() {
+    const config = await this.configuration();
+    return config.defaultBrowser ?? "chrome";
+  }
+  /**
+   * @param options - Set of configurable options to set on the browser.
+   *
+   * @returns The default arguments that the browser will be launched with.
+   */
+  async defaultArgs(options = {}) {
+    return this.#getLauncher(options.browser ?? await this.lastLaunchedBrowser(), options.logger ?? debug).defaultArgs(options);
+  }
+  /**
+   * Removes all non-current Firefox and Chrome binaries in the cache directory
+   * identified by the provided Puppeteer configuration. The current browser
+   * version is determined by resolving PUPPETEER_REVISIONS from Puppeteer
+   * unless `configuration.browserRevision` is provided.
+   *
+   * @remarks
+   *
+   * Note that the method does not check if any other Puppeteer versions
+   * installed on the host that use the same cache directory require the
+   * non-current binaries.
+   *
+   * @public
+   */
+  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
+      });
+    }
+  }
+  /**
+   * Defines whether Puppeteer should follow symlinks for file operations.
+   *
+   * @param followSymlinks - Whether Puppeteer should follow symlinks.
+   *
+   * @public
+   */
+  setFollowSymlinks(followSymlinks) {
+    environment.value.followSymlinks = followSymlinks;
+  }
+};
+
+// ../../node_modules/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/node/ScreenRecorder.js
+import { spawn, spawnSync } from "child_process";
+import os3 from "os";
+import { PassThrough } from "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 : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && 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 === void 0) 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;
+function countFrames(startTimestamp, previousTimestamp, timestamp, fps) {
+  const end = Math.round((timestamp - startTimestamp) * fps);
+  const start = Math.round((previousTimestamp - startTimestamp) * fps);
+  return Math.max(0, end - start);
+}
+var ScreenRecorder = (() => {
+  let _classSuper = PassThrough;
+  let _instanceExtraInitializers = [];
+  let _private_writeFrame_decorators;
+  let _private_writeFrame_descriptor;
+  let _stop_decorators;
+  return class ScreenRecorder extends _classSuper {
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __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;
+    #logger;
+    /**
+     * @internal
+     */
+    constructor(page, width, height, { ffmpegPath, speed, scale, crop, format, fps, loop, delay, quality, colors } = {}, logger) {
+      super({ allowHalfOpen: false });
+      this.#logger = logger;
+      ffmpegPath ??= "ffmpeg";
+      format ??= "webm";
+      fps ??= DEFAULT_FPS;
+      loop ||= -1;
+      delay ??= -1;
+      quality ??= CRF_VALUE;
+      colors ??= 256;
+      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) ?? "");
+      }
+      this.#process = spawn(
+        ffmpegPath,
+        // See https://trac.ffmpeg.org/wiki/Encode/VP9 for more information on flags.
+        [
+          ["-loglevel", "error"],
+          // Reduces general buffering.
+          ["-avioflags", "direct"],
+          // Reduces initial buffering while analyzing input fps and other stats.
+          [
+            "-fpsprobesize",
+            "0",
+            "-probesize",
+            "32",
+            "-analyzeduration",
+            "0",
+            "-fflags",
+            "nobuffer"
+          ],
+          // Forces input to be read from standard input, and forces png input
+          // image format. `-framerate` is an input option and must appear before
+          // `-i`; otherwise ffmpeg ignores it and the image2pipe demuxer falls
+          // back to its default 25fps, stretching the output timeline relative to
+          // the frames we feed it at `fps`.
+          // prettier-ignore
+          ["-framerate", `${fps}`, "-f", "image2pipe", "-vcodec", "png", "-i", "pipe:0"],
+          // No audio
+          ["-an"],
+          // This drastically reduces stalling when cpu is overbooked. By default
+          // VP9 tries to use all available threads?
+          ["-threads", "1"],
+          // Disable bitrate.
+          ["-b:v", "0"],
+          // Specifies the encoding and format we are using.
+          formatArgs,
+          // Filters to ensure the images are piped correctly,
+          // combined with any format-specific filters.
+          ["-vf", filters.join()],
+          "pipe:1"
+        ].flat(),
+        { stdio: ["pipe", "pipe", "pipe"] }
+      );
+      this.#process.stdout.pipe(this);
+      this.#process.stderr.on("data", (data) => {
+        this.#logger?.(DEBUG_PREFIXES.ffmpeg)?.(data.toString("utf8"));
+      });
+      this.#page = page;
+      const { client } = this.#page.mainFrame();
+      client.once(CDPSessionEvent.Disconnected, () => {
+        void this.stop().catch((err) => {
+          this.#logger?.(DEBUG_PREFIXES.error)?.(err);
+        });
+      });
+      let startTimestamp;
+      this.#lastFrame = lastValueFrom(fromEmitterEvent(client, "Page.screencastFrame").pipe(tap((event) => {
+        void client.send("Page.screencastFrameAck", {
+          sessionId: event.sessionId
+        });
+      }), filter((event) => {
+        return event.metadata.timestamp !== void 0;
+      }), map((event) => {
+        return {
+          buffer: Buffer.from(event.data, "base64"),
+          timestamp: event.metadata.timestamp
+        };
+      }), bufferCount(2, 1), concatMap(([{ timestamp: previousTimestamp, buffer }, { timestamp }]) => {
+        startTimestamp ??= previousTimestamp;
+        return from(Array(countFrames(startTimestamp, previousTimestamp, timestamp, fps)).fill(buffer));
+      }), map((buffer) => {
+        void 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"],
+        // Sets the quality. Lower the better.
+        ["-crf", `${quality}`],
+        // Sets the quality and how efficient the compression will be.
+        [
+          "-deadline",
+          "realtime",
+          "-cpu-used",
+          `${Math.min(os3.cpus().length / 2, 8)}`
+        ]
+      ];
+      switch (format) {
+        case "webm":
+          return [
+            ...libvpx,
+            // Sets the format
+            ["-f", "webm"]
+          ].flat();
+        case "gif":
+          fps = DEFAULT_FPS === fps ? 20 : "source_fps";
+          if (loop === Infinity) {
+            loop = 0;
+          }
+          if (delay !== -1) {
+            delay /= 10;
+          }
+          return [
+            // Sets the frame rate and uses a custom palette generated from the
+            // input.
+            [
+              "-vf",
+              `fps=${fps},split[s0][s1];[s0]palettegen=stats_mode=diff:max_colors=${colors}[p];[s1][p]paletteuse=dither=bayer`
+            ],
+            // Sets the number of times to loop playback.
+            ["-loop", `${loop}`],
+            // Sets the delay between iterations of a loop.
+            ["-final_delay", `${delay}`],
+            // Sets the format
+            ["-f", "gif"]
+          ].flat();
+        case "mp4":
+          return [
+            ...libvpx,
+            // Fragment file during stream to avoid errors.
+            ["-movflags", "hybrid_fragmented"],
+            // Sets the format
+            ["-f", "mp4"]
+          ].flat();
+      }
+    }
+    get #writeFrame() {
+      return _private_writeFrame_descriptor.value;
+    }
+    /**
+     * Stops the recorder.
+     *
+     * @public
+     */
+    async stop() {
+      if (this.#controller.signal.aborted) {
+        return;
+      }
+      await this.#page._stopScreencast().catch((err) => {
+        this.#logger?.(DEBUG_PREFIXES.error)?.(err);
+      });
+      this.#controller.abort();
+      const [buffer, timestamp] = await this.#lastFrame;
+      await Promise.all(Array(Math.max(1, Math.round(this.#fps * (performance.now() - timestamp) / 1e3))).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/.pnpm/puppeteer-core@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer-core/lib/puppeteer/puppeteer-core.js
+environment.value.ScreenRecorder = ScreenRecorder;
+var puppeteer = new PuppeteerNode({
+  isPuppeteerCore: true
+});
+var {
+  /**
+   * @public
+   */
+  connect,
+  /**
+   * @public
+   */
+  defaultArgs,
+  /**
+   * @public
+   */
+  executablePath,
+  /**
+   * @public
+   */
+  launch: launch2
+} = puppeteer;
+
+// ../../node_modules/.pnpm/puppeteer@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer/lib/puppeteer/getConfiguration.js
+var import_lilconfig = __toESM(require_src(), 1);
+import { homedir } from "os";
+import { join as join2 } from "path";
+function getBooleanEnvVar(name) {
+  const env = process.env[name];
+  if (env === void 0) {
+    return;
+  }
+  switch (env.toLowerCase()) {
+    case "":
+    case "0":
+    case "false":
+    case "off":
+      return false;
+    default:
+      return true;
+  }
+}
+function isSupportedBrowser(product) {
+  switch (product) {
+    case "chrome":
+    case "firefox":
+      return true;
+    default:
+      return false;
+  }
+}
+function getDefaultBrowser(browser) {
+  if (!browser) {
+    return "chrome";
+  }
+  if (!isSupportedBrowser(browser)) {
+    throw new Error(`Unsupported browser ${browser}`);
+  }
+  return browser;
+}
+function getLogLevel(logLevel) {
+  switch (logLevel) {
+    case "silent":
+      return "silent";
+    case "error":
+      return "error";
+    default:
+      return "warn";
+  }
+}
+function getBrowserSetting(browser, configuration, defaultConfig = {}) {
+  const browserSetting = {};
+  const browserEnvName = browser.replaceAll("-", "_").toUpperCase();
+  browserSetting.version = process.env[`PUPPETEER_${browserEnvName}_VERSION`] ?? configuration[browser]?.version ?? defaultConfig.version;
+  browserSetting.downloadBaseUrl = process.env[`PUPPETEER_${browserEnvName}_DOWNLOAD_BASE_URL`] ?? configuration[browser]?.downloadBaseUrl ?? defaultConfig.downloadBaseUrl;
+  browserSetting.skipDownload = getBooleanEnvVar(`PUPPETEER_${browserEnvName}_SKIP_DOWNLOAD`) ?? getBooleanEnvVar(`PUPPETEER_SKIP_${browserEnvName}_DOWNLOAD`) ?? configuration[browser]?.skipDownload ?? configuration.skipDownload ?? defaultConfig.skipDownload;
+  return browserSetting;
+}
+var getConfiguration = async () => {
+  const result = await (0, import_lilconfig.lilconfig)("puppeteer", {
+    searchPlaces: [
+      "package.json",
+      ".config/puppeteer.config.cjs",
+      ".config/puppeteer.config.js",
+      ".config/puppeteerrc.cjs",
+      ".config/puppeteerrc.js",
+      ".config/puppeteerrc.json",
+      ".config/puppeteerrc",
+      ".puppeteerrc.cjs",
+      ".puppeteerrc.js",
+      ".puppeteerrc.json",
+      ".puppeteerrc",
+      "puppeteer.config.cjs",
+      "puppeteer.config.js"
+    ]
+  }).search();
+  const configuration = result ? { ...result.config } : {};
+  configuration.logLevel = getLogLevel(process.env["PUPPETEER_LOGLEVEL"] ?? configuration.logLevel);
+  configuration.defaultBrowser = getDefaultBrowser(process.env["PUPPETEER_BROWSER"] ?? configuration.defaultBrowser);
+  configuration.executablePath = process.env["PUPPETEER_EXECUTABLE_PATH"] ?? configuration.executablePath;
+  if (configuration.executablePath) {
+    configuration.skipDownload = true;
+  }
+  configuration.skipDownload = getBooleanEnvVar("PUPPETEER_SKIP_DOWNLOAD") ?? configuration.skipDownload;
+  configuration.chrome = getBrowserSetting("chrome", configuration);
+  configuration["chrome-headless-shell"] = getBrowserSetting("chrome-headless-shell", configuration);
+  configuration.firefox = getBrowserSetting("firefox", configuration, {
+    skipDownload: true
+  });
+  configuration.cacheDirectory = process.env["PUPPETEER_CACHE_DIR"] ?? configuration.cacheDirectory ?? join2(homedir(), ".cache", "puppeteer");
+  configuration.temporaryDirectory = process.env["PUPPETEER_TMP_DIR"] ?? configuration.temporaryDirectory;
+  configuration.experiments ??= {};
+  return configuration;
+};
+
+// ../../node_modules/.pnpm/puppeteer@25.10.0_proxy-agent@8.0.2_yauzl@3.4.0/node_modules/puppeteer/lib/puppeteer/puppeteer.js
+var puppeteer2 = new PuppeteerNode({
+  isPuppeteerCore: false,
+  configuration: getConfiguration
+});
+var {
+  /**
+   * @public
+   */
+  connect: connect2,
+  /**
+   * @public
+   */
+  defaultArgs: defaultArgs2,
+  /**
+   * @public
+   */
+  executablePath: executablePath2,
+  /**
+   * @public
+   */
+  launch: launch3,
+  /**
+   * @public
+   */
+  trimCache,
+  /**
+   * @public
+   */
+  setFollowSymlinks
+} = puppeteer2;
+var puppeteer_default = puppeteer2;
+export {
+  ARIAQueryHandler,
+  Accessibility,
+  AsyncDisposableStack,
+  AsyncDisposableStackPolyfill,
+  AsyncIterableUtil,
+  Binding,
+  Browser,
+  BrowserContext,
+  BrowserLauncher,
+  BrowserWebSocketTransport,
+  CDPSession,
+  CDPSessionEvent,
+  CDP_BINDING_PREFIX,
+  CSSCoverage,
+  Callback,
+  CallbackRegistry,
+  CdpBluetoothEmulation,
+  CdpBrowser,
+  CdpBrowserContext,
+  CdpCDPSession,
+  CdpDeviceRequestPrompt,
+  CdpDeviceRequestPromptManager,
+  CdpDialog,
+  CdpElementHandle,
+  CdpFrame,
+  CdpHTTPRequest,
+  CdpHTTPResponse,
+  CdpJSHandle,
+  CdpKeyboard,
+  CdpMouse,
+  CdpPage,
+  CdpPreloadScript,
+  CdpScreenRecording,
+  CdpTarget,
+  CdpTouchHandle,
+  CdpTouchscreen,
+  CdpWebWorker,
+  ChromeLauncher,
+  Connection,
+  ConnectionClosedError,
+  ConsoleMessage,
+  Coverage,
+  CustomQueryHandlerRegistry,
+  DEBUG_PREFIXES,
+  DEFAULT_INTERCEPT_RESOLUTION_PRIORITY,
+  DEFAULT_VIEWPORT,
+  Deferred,
+  DelegatedLocator,
+  DevToolsTarget,
+  DeviceRequestPrompt,
+  Dialog,
+  DisposableStack,
+  DisposableStackPolyfill,
+  ElementHandle,
+  EmulatedState,
+  EmulationManager,
+  EventEmitter,
+  ExecutionContext,
+  Extension,
+  ExtensionTransport,
+  FileChooser,
+  FilteredLocator,
+  FirefoxLauncher,
+  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,
+  NETWORK_IDLE_TIME,
+  NetworkEventManager,
+  NetworkManager,
+  NetworkManagerEvent,
+  NodeLocator,
+  OtherTarget,
+  PQueryHandler,
+  PUPPETEER_REVISIONS,
+  PUPPETEER_WORLD,
+  Page,
+  PageTarget,
+  PierceQueryHandler,
+  PipeTransport,
+  PredefinedNetworkConditions,
+  ProtocolError,
+  Puppeteer,
+  PuppeteerError,
+  PuppeteerNode,
+  PuppeteerURL,
+  QueryHandler,
+  RETRY_DELAY,
+  RaceLocator,
+  Realm,
+  SOURCE_URL_REGEX,
+  STATUS_TEXTS,
+  ScreenRecorder,
+  ScreenRecording,
+  ScriptInjector,
+  SecurityDetails,
+  SuppressedError,
+  Target,
+  TargetCloseError,
+  TargetManager,
+  TargetType,
+  TaskManager,
+  TaskQueue,
+  TextQueryHandler,
+  TimeoutError,
+  TimeoutSettings,
+  TouchError,
+  Touchscreen,
+  Tracing,
+  UTILITY_WORLD_NAME,
+  UnsupportedOperation,
+  WEB_PERMISSION_TO_PROTOCOL_PERMISSION,
+  WaitTask,
+  WebMCP,
+  WebMCPTool,
+  WebMCPToolCall,
+  WebWorker,
+  WebWorkerEvent,
+  WorkerTarget,
+  XPathQueryHandler,
+  _connectToCdpBrowser,
+  _keyDefinitions,
+  addPageBinding,
+  assert,
+  asyncDisposeSymbol,
+  bindIsolatedHandle,
+  connect2 as connect,
+  convertConsoleMessageLevel,
+  convertCookiesPartitionKeyFromPuppeteerToCdp,
+  convertSameSiteFromPuppeteerToCdp,
+  countFrames,
+  createClientError,
+  createConsoleMessage,
+  createEvaluationError,
+  createIncrementalIdGenerator,
+  createProtocolErrorMessage,
+  customQueryHandlers,
+  debug,
+  puppeteer_default as default,
+  defaultArgs2 as defaultArgs,
+  disposeSymbol,
+  evaluationString,
+  executablePath2 as executablePath,
+  filterAsync,
+  fromAbortSignal,
+  fromEmitterEvent,
+  getBrowserTypeDisplayName,
+  getCapturedLogs,
+  getFeatures,
+  getQueryHandlerAndSelector,
+  getReadableAsTypedArray,
+  getReadableFromProtocolStream,
+  getSourcePuppeteerURLIfAvailable,
+  getSourceUrlComment,
+  handleError,
+  headersArray,
+  isDate,
+  isErrnoException,
+  isErrorLike,
+  isNumber,
+  isPlainObject,
+  isRegExp,
+  isString,
+  isTargetClosedError,
+  launch3 as launch,
+  normalizeHeaderValue,
+  pageBindingInitString,
+  paperFormats,
+  parsePDFOptions,
+  parsePSelectors,
+  referrerPolicyToProtocol,
+  releaseObject,
+  removeMatchingFlags,
+  rewriteError,
+  scriptInjector,
+  setDefaultScreenshotOptions,
+  setFollowSymlinks,
+  setLogCapture,
+  supportedMetrics,
+  throwIfDetached,
+  timeout,
+  transposeIterableHandle,
+  trimCache,
+  unitToPixels,
+  validateDialogType,
+  valueFromJSHandle,
+  valueFromPrimitiveRemoteObject,
+  valueFromRemoteObjectReference,
+  withSourcePuppeteerURLIfNone
+};
+/*! Bundled license information:
+
+puppeteer-core/lib/puppeteer/node-env-setup.js:
+  (**
+   * @license
+   * Copyright 2026 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+
+puppeteer-core/lib/puppeteer/node/BrowserLauncher.js:
+puppeteer-core/lib/puppeteer/index.js:
+puppeteer-core/lib/puppeteer/puppeteer-core.js:
+puppeteer/lib/puppeteer/puppeteer.js:
+  (**
+   * @license
+   * Copyright 2017 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+
+puppeteer-core/lib/puppeteer/node/util/fs.js:
+puppeteer-core/lib/puppeteer/node/ChromeLauncher.js:
+puppeteer-core/lib/puppeteer/node/FirefoxLauncher.js:
+puppeteer-core/lib/puppeteer/node/ScreenRecorder.js:
+puppeteer/lib/puppeteer/getConfiguration.js:
+  (**
+   * @license
+   * Copyright 2023 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+
+puppeteer-core/lib/puppeteer/node/PuppeteerNode.js:
+  (**
+   * @license
+   * Copyright 2020 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+
+puppeteer-core/lib/puppeteer/node/node.js:
+  (**
+   * @license
+   * Copyright 2022 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/
+//# sourceMappingURL=puppeteer-RDWY6FSG.js.map