@purepageio/fetch-engines 0.2.5 → 0.2.7

package/dist/index.cjs

@@ -0,0 +1,3274 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/.pnpm/tsup@8.4.0_postcss@8.5.3_typescript@5.8.2/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/.pnpm/tsup@8.4.0_postcss@8.5.3_typescript@5.8.2/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/ms/index.js
+var require_ms = __commonJS({
+  "../node_modules/ms/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module2.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse2(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse2(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// ../node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "../node_modules/debug/src/common.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    function setup(env) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug[key] = env[key];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug2(...args) {
+          if (!debug2.enabled) {
+            return;
+          }
+          const self = debug2;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          self.prev = prevTime;
+          self.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self, args);
+          const logFn = self.log || createDebug.log;
+          logFn.apply(self, args);
+        }
+        debug2.namespace = namespace;
+        debug2.useColors = createDebug.useColors();
+        debug2.color = createDebug.selectColor(namespace);
+        debug2.extend = extend;
+        debug2.destroy = createDebug.destroy;
+        Object.defineProperty(debug2, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug2);
+        }
+        return debug2;
+      }
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(" ", ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug.skips.push(ns.slice(1));
+          } else {
+            createDebug.names.push(ns);
+          }
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
+          } else {
+            return false;
+          }
+        }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        for (const skip of createDebug.skips) {
+          if (matchesTemplate(name, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug.names) {
+          if (matchesTemplate(name, ns)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    module2.exports = setup;
+  }
+});
+
+// ../node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "../node_modules/debug/src/browser.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    exports2.formatArgs = formatArgs;
+    exports2.save = save;
+    exports2.load = load;
+    exports2.useColors = useColors;
+    exports2.storage = localstorage();
+    exports2.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports2.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports2.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports2.storage.setItem("debug", namespaces);
+        } else {
+          exports2.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports2.storage.getItem("debug");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module2.exports = require_common()(exports2);
+    var { formatters } = module2.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// ../node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "../node_modules/debug/src/node.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var tty = require("tty");
+    var util = require("util");
+    exports2.init = init;
+    exports2.log = log;
+    exports2.formatArgs = formatArgs;
+    exports2.save = save;
+    exports2.load = load;
+    exports2.useColors = useColors;
+    exports2.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports2.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = require("supports-color");
+      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+        exports2.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error) {
+    }
+    exports2.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+        return k.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color;
+        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports2.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug2) {
+      debug2.inspectOpts = {};
+      const keys = Object.keys(exports2.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug2.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
+      }
+    }
+    module2.exports = require_common()(exports2);
+    var { formatters } = module2.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// ../node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "../node_modules/debug/src/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module2.exports = require_browser();
+    } else {
+      module2.exports = require_node();
+    }
+  }
+});
+
+// ../node_modules/arr-union/index.js
+var require_arr_union = __commonJS({
+  "../node_modules/arr-union/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = function union(init) {
+      if (!Array.isArray(init)) {
+        throw new TypeError("arr-union expects the first argument to be an array.");
+      }
+      var len = arguments.length;
+      var i = 0;
+      while (++i < len) {
+        var arg = arguments[i];
+        if (!arg) continue;
+        if (!Array.isArray(arg)) {
+          arg = [arg];
+        }
+        for (var j = 0; j < arg.length; j++) {
+          var ele = arg[j];
+          if (init.indexOf(ele) >= 0) {
+            continue;
+          }
+          init.push(ele);
+        }
+      }
+      return init;
+    };
+  }
+});
+
+// ../node_modules/lazy-cache/index.js
+var require_lazy_cache = __commonJS({
+  "../node_modules/lazy-cache/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    function lazyCache(fn) {
+      var cache = {};
+      var proxy = function(mod, name) {
+        name = name || camelcase(mod);
+        if (process.env.UNLAZY === "true" || process.env.UNLAZY === true || process.env.TRAVIS) {
+          cache[name] = fn(mod);
+        }
+        Object.defineProperty(proxy, name, {
+          enumerable: true,
+          configurable: true,
+          get: getter
+        });
+        function getter() {
+          if (cache.hasOwnProperty(name)) {
+            return cache[name];
+          }
+          return cache[name] = fn(mod);
+        }
+        return getter;
+      };
+      return proxy;
+    }
+    function camelcase(str) {
+      if (str.length === 1) {
+        return str.toLowerCase();
+      }
+      str = str.replace(/^[\W_]+|[\W_]+$/g, "").toLowerCase();
+      return str.replace(/[\W_]+(\w|$)/g, function(_, ch) {
+        return ch.toUpperCase();
+      });
+    }
+    module2.exports = lazyCache;
+  }
+});
+
+// ../node_modules/for-in/index.js
+var require_for_in = __commonJS({
+  "../node_modules/for-in/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = function forIn(obj, fn, thisArg) {
+      for (var key in obj) {
+        if (fn.call(thisArg, obj[key], key, obj) === false) {
+          break;
+        }
+      }
+    };
+  }
+});
+
+// ../node_modules/for-own/index.js
+var require_for_own = __commonJS({
+  "../node_modules/for-own/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var forIn = require_for_in();
+    var hasOwn = Object.prototype.hasOwnProperty;
+    module2.exports = function forOwn(obj, fn, thisArg) {
+      forIn(obj, function(val, key) {
+        if (hasOwn.call(obj, key)) {
+          return fn.call(thisArg, obj[key], key, obj);
+        }
+      });
+    };
+  }
+});
+
+// ../node_modules/clone-deep/utils.js
+var require_utils = __commonJS({
+  "../node_modules/clone-deep/utils.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var utils = require_lazy_cache()(require);
+    var fn = require;
+    require = utils;
+    require("is-plain-object", "isObject");
+    require("shallow-clone", "clone");
+    require("kind-of", "typeOf");
+    require_for_own();
+    require = fn;
+    module2.exports = utils;
+  }
+});
+
+// ../node_modules/clone-deep/index.js
+var require_clone_deep = __commonJS({
+  "../node_modules/clone-deep/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var utils = require_utils();
+    function cloneDeep(val, instanceClone) {
+      switch (utils.typeOf(val)) {
+        case "object":
+          return cloneObjectDeep(val, instanceClone);
+        case "array":
+          return cloneArrayDeep(val, instanceClone);
+        default:
+          return utils.clone(val);
+      }
+    }
+    function cloneObjectDeep(obj, instanceClone) {
+      if (utils.isObject(obj)) {
+        var res = {};
+        utils.forOwn(obj, function(obj2, key) {
+          this[key] = cloneDeep(obj2, instanceClone);
+        }, res);
+        return res;
+      } else if (instanceClone) {
+        return instanceClone(obj);
+      } else {
+        return obj;
+      }
+    }
+    function cloneArrayDeep(arr, instanceClone) {
+      var len = arr.length, res = [];
+      var i = -1;
+      while (++i < len) {
+        res[i] = cloneDeep(arr[i], instanceClone);
+      }
+      return res;
+    }
+    module2.exports = cloneDeep;
+  }
+});
+
+// ../node_modules/is-buffer/index.js
+var require_is_buffer = __commonJS({
+  "../node_modules/is-buffer/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = function(obj) {
+      return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+    };
+    function isBuffer(obj) {
+      return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+    }
+    function isSlowBuffer(obj) {
+      return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer(obj.slice(0, 0));
+    }
+  }
+});
+
+// ../node_modules/kind-of/index.js
+var require_kind_of = __commonJS({
+  "../node_modules/kind-of/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var isBuffer = require_is_buffer();
+    var toString = Object.prototype.toString;
+    module2.exports = function kindOf(val) {
+      if (typeof val === "undefined") {
+        return "undefined";
+      }
+      if (val === null) {
+        return "null";
+      }
+      if (val === true || val === false || val instanceof Boolean) {
+        return "boolean";
+      }
+      if (typeof val === "string" || val instanceof String) {
+        return "string";
+      }
+      if (typeof val === "number" || val instanceof Number) {
+        return "number";
+      }
+      if (typeof val === "function" || val instanceof Function) {
+        return "function";
+      }
+      if (typeof Array.isArray !== "undefined" && Array.isArray(val)) {
+        return "array";
+      }
+      if (val instanceof RegExp) {
+        return "regexp";
+      }
+      if (val instanceof Date) {
+        return "date";
+      }
+      var type = toString.call(val);
+      if (type === "[object RegExp]") {
+        return "regexp";
+      }
+      if (type === "[object Date]") {
+        return "date";
+      }
+      if (type === "[object Arguments]") {
+        return "arguments";
+      }
+      if (type === "[object Error]") {
+        return "error";
+      }
+      if (isBuffer(val)) {
+        return "buffer";
+      }
+      if (type === "[object Set]") {
+        return "set";
+      }
+      if (type === "[object WeakSet]") {
+        return "weakset";
+      }
+      if (type === "[object Map]") {
+        return "map";
+      }
+      if (type === "[object WeakMap]") {
+        return "weakmap";
+      }
+      if (type === "[object Symbol]") {
+        return "symbol";
+      }
+      if (type === "[object Int8Array]") {
+        return "int8array";
+      }
+      if (type === "[object Uint8Array]") {
+        return "uint8array";
+      }
+      if (type === "[object Uint8ClampedArray]") {
+        return "uint8clampedarray";
+      }
+      if (type === "[object Int16Array]") {
+        return "int16array";
+      }
+      if (type === "[object Uint16Array]") {
+        return "uint16array";
+      }
+      if (type === "[object Int32Array]") {
+        return "int32array";
+      }
+      if (type === "[object Uint32Array]") {
+        return "uint32array";
+      }
+      if (type === "[object Float32Array]") {
+        return "float32array";
+      }
+      if (type === "[object Float64Array]") {
+        return "float64array";
+      }
+      return "object";
+    };
+  }
+});
+
+// ../node_modules/merge-deep/index.js
+var require_merge_deep = __commonJS({
+  "../node_modules/merge-deep/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var union = require_arr_union();
+    var clone = require_clone_deep();
+    var typeOf = require_kind_of();
+    module2.exports = function mergeDeep(orig, objects) {
+      if (!isObject(orig) && !Array.isArray(orig)) {
+        orig = {};
+      }
+      var target = clone(orig);
+      var len = arguments.length;
+      var idx = 0;
+      while (++idx < len) {
+        var val = arguments[idx];
+        if (isObject(val) || Array.isArray(val)) {
+          merge2(target, val);
+        }
+      }
+      return target;
+    };
+    function merge2(target, obj) {
+      for (var key in obj) {
+        if (!isValidKey(key) || !hasOwn(obj, key)) {
+          continue;
+        }
+        var oldVal = obj[key];
+        var newVal = target[key];
+        if (isObject(newVal) && isObject(oldVal)) {
+          target[key] = merge2(newVal, oldVal);
+        } else if (Array.isArray(newVal)) {
+          target[key] = union([], newVal, oldVal);
+        } else {
+          target[key] = clone(oldVal);
+        }
+      }
+      return target;
+    }
+    function hasOwn(obj, key) {
+      return Object.prototype.hasOwnProperty.call(obj, key);
+    }
+    function isObject(val) {
+      return typeOf(val) === "object" || typeOf(val) === "function";
+    }
+    function isValidKey(key) {
+      return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+    }
+  }
+});
+
+// ../node_modules/puppeteer-extra-plugin/dist/index.esm.js
+var index_esm_exports = {};
+__export(index_esm_exports, {
+  PuppeteerExtraPlugin: () => PuppeteerExtraPlugin
+});
+var import_debug, merge, PuppeteerExtraPlugin;
+var init_index_esm = __esm({
+  "../node_modules/puppeteer-extra-plugin/dist/index.esm.js"() {
+    "use strict";
+    init_cjs_shims();
+    import_debug = __toESM(require_src());
+    merge = require_merge_deep();
+    PuppeteerExtraPlugin = class {
+      constructor(opts) {
+        this._debugBase = (0, import_debug.default)(`puppeteer-extra-plugin:base:${this.name}`);
+        this._childClassMembers = [];
+        this._opts = merge(this.defaults, opts || {});
+        this._debugBase("Initialized.");
+      }
+      /**
+       * Plugin name (required).
+       *
+       * Convention:
+       * - Package: `puppeteer-extra-plugin-anonymize-ua`
+       * - Name: `anonymize-ua`
+       *
+       * @example
+       * get name () { return 'anonymize-ua' }
+       */
+      get name() {
+        throw new Error('Plugin must override "name"');
+      }
+      /**
+       * Plugin defaults (optional).
+       *
+       * If defined will be ([deep-](https://github.com/jonschlinkert/merge-deep))merged with the (optional) user supplied options (supplied during plugin instantiation).
+       *
+       * The result of merging defaults with user supplied options can be accessed through `this.opts`.
+       *
+       * @see [[opts]]
+       *
+       * @example
+       * get defaults () {
+       *   return {
+       *     stripHeadless: true,
+       *     makeWindows: true,
+       *     customFn: null
+       *   }
+       * }
+       *
+       * // Users can overwrite plugin defaults during instantiation:
+       * puppeteer.use(require('puppeteer-extra-plugin-foobar')({ makeWindows: false }))
+       */
+      get defaults() {
+        return {};
+      }
+      /**
+       * Plugin requirements (optional).
+       *
+       * Signal certain plugin requirements to the base class and the user.
+       *
+       * Currently supported:
+       * - `launch`
+       *   - If the plugin only supports locally created browser instances (no `puppeteer.connect()`),
+       *     will output a warning to the user.
+       * - `headful`
+       *   - If the plugin doesn't work in `headless: true` mode,
+       *     will output a warning to the user.
+       * - `dataFromPlugins`
+       *   - In case the plugin requires data from other plugins.
+       *     will enable usage of `this.getDataFromPlugins()`.
+       * - `runLast`
+       *   - In case the plugin prefers to run after the others.
+       *     Useful when the plugin needs data from others.
+       *
+       * @example
+       * get requirements () {
+       *   return new Set(['runLast', 'dataFromPlugins'])
+       * }
+       */
+      get requirements() {
+        return /* @__PURE__ */ new Set([]);
+      }
+      /**
+       * Plugin dependencies (optional).
+       *
+       * Missing plugins will be required() by puppeteer-extra.
+       *
+       * @example
+       * get dependencies () {
+       *   return new Set(['user-preferences'])
+       * }
+       * // Will ensure the 'puppeteer-extra-plugin-user-preferences' plugin is loaded.
+       */
+      get dependencies() {
+        return /* @__PURE__ */ new Set([]);
+      }
+      /**
+       * Plugin data (optional).
+       *
+       * Plugins can expose data (an array of objects), which in turn can be consumed by other plugins,
+       * that list the `dataFromPlugins` requirement (by using `this.getDataFromPlugins()`).
+       *
+       * Convention: `[ {name: 'Any name', value: 'Any value'} ]`
+       *
+       * @see [[getDataFromPlugins]]
+       *
+       * @example
+       * // plugin1.js
+       * get data () {
+       *   return [
+       *     {
+       *       name: 'userPreferences',
+       *       value: { foo: 'bar' }
+       *     },
+       *     {
+       *       name: 'userPreferences',
+       *       value: { hello: 'world' }
+       *     }
+       *   ]
+       *
+       * // plugin2.js
+       * get requirements () { return new Set(['dataFromPlugins']) }
+       *
+       * async beforeLaunch () {
+       *   const prefs = this.getDataFromPlugins('userPreferences').map(d => d.value)
+       *   this.debug(prefs) // => [ { foo: 'bar' }, { hello: 'world' } ]
+       * }
+       */
+      get data() {
+        return [];
+      }
+      /**
+       * Access the plugin options (usually the `defaults` merged with user defined options)
+       *
+       * To skip the auto-merging of defaults with user supplied opts don't define a `defaults`
+       * property and set the `this._opts` Object in your plugin constructor directly.
+       *
+       * @see [[defaults]]
+       *
+       * @example
+       * get defaults () { return { foo: "bar" } }
+       *
+       * async onPageCreated (page) {
+       *   this.debug(this.opts.foo) // => bar
+       * }
+       */
+      get opts() {
+        return this._opts;
+      }
+      /**
+       *  Convenience debug logger based on the [debug] module.
+       *  Will automatically namespace the logging output to the plugin package name.
+       *  [debug]: https://www.npmjs.com/package/debug
+       *
+       *  ```bash
+       *  # toggle output using environment variables
+       *  DEBUG=puppeteer-extra-plugin:<plugin_name> node foo.js
+       *  # to debug all the things:
+       *  DEBUG=puppeteer-extra,puppeteer-extra-plugin:* node foo.js
+       *  ```
+       *
+       * @example
+       * this.debug('hello world')
+       * // will output e.g. 'puppeteer-extra-plugin:anonymize-ua hello world'
+       */
+      get debug() {
+        return (0, import_debug.default)(`puppeteer-extra-plugin:${this.name}`);
+      }
+      /**
+       * Before a new browser instance is created/launched.
+       *
+       * Can be used to modify the puppeteer launch options by modifying or returning them.
+       *
+       * Plugins using this method will be called in sequence to each
+       * be able to update the launch options.
+       *
+       * @example
+       * async beforeLaunch (options) {
+       *   if (this.opts.flashPluginPath) {
+       *     options.args.push(`--ppapi-flash-path=${this.opts.flashPluginPath}`)
+       *   }
+       * }
+       *
+       * @param options - Puppeteer launch options
+       */
+      async beforeLaunch(options) {
+      }
+      /**
+       * After the browser has launched.
+       *
+       * Note: Don't assume that there will only be a single browser instance during the lifecycle of a plugin.
+       * It's possible that `pupeeteer.launch` will be  called multiple times and more than one browser created.
+       * In order to make the plugins as stateless as possible don't store a reference to the browser instance
+       * in the plugin but rather consider alternatives.
+       *
+       * E.g. when using `onPageCreated` you can get a browser reference by using `page.browser()`.
+       *
+       * Alternatively you could expose a class method that takes a browser instance as a parameter to work with:
+       *
+       * ```es6
+       * const fancyPlugin = require('puppeteer-extra-plugin-fancy')()
+       * puppeteer.use(fancyPlugin)
+       * const browser = await puppeteer.launch()
+       * await fancyPlugin.killBrowser(browser)
+       * ```
+       *
+       * @param  browser - The `puppeteer` browser instance.
+       * @param  opts.options - Puppeteer launch options used.
+       *
+       * @example
+       * async afterLaunch (browser, opts) {
+       *   this.debug('browser has been launched', opts.options)
+       * }
+       */
+      async afterLaunch(browser, opts = { options: {} }) {
+      }
+      /**
+       * Before connecting to an existing browser instance.
+       *
+       * Can be used to modify the puppeteer connect options by modifying or returning them.
+       *
+       * Plugins using this method will be called in sequence to each
+       * be able to update the launch options.
+       *
+       * @param  {Object} options - Puppeteer connect options
+       * @return {Object=}
+       */
+      async beforeConnect(options) {
+      }
+      /**
+       * After connecting to an existing browser instance.
+       *
+       * > Note: Don't assume that there will only be a single browser instance during the lifecycle of a plugin.
+       *
+       * @param browser - The `puppeteer` browser instance.
+       * @param  {Object} opts
+       * @param  {Object} opts.options - Puppeteer connect options used.
+       *
+       */
+      async afterConnect(browser, opts = {}) {
+      }
+      /**
+       * Called when a browser instance is available.
+       *
+       * This applies to both `puppeteer.launch()` and `puppeteer.connect()`.
+       *
+       * Convenience method created for plugins that need access to a browser instance
+       * and don't mind if it has been created through `launch` or `connect`.
+       *
+       * > Note: Don't assume that there will only be a single browser instance during the lifecycle of a plugin.
+       *
+       * @param browser - The `puppeteer` browser instance.
+       */
+      async onBrowser(browser, opts) {
+      }
+      /**
+       * Called when a target is created, for example when a new page is opened by window.open or browser.newPage.
+       *
+       * > Note: This includes target creations in incognito browser contexts.
+       *
+       * > Note: This includes browser instances created through `.launch()` as well as `.connect()`.
+       *
+       * @param  {Puppeteer.Target} target
+       */
+      async onTargetCreated(target) {
+      }
+      /**
+       * Same as `onTargetCreated` but prefiltered to only contain Pages, for convenience.
+       *
+       * > Note: This includes page creations in incognito browser contexts.
+       *
+       * > Note: This includes browser instances created through `.launch()` as well as `.connect()`.
+       *
+       * @param  {Puppeteer.Target} target
+       *
+       * @example
+       * async onPageCreated (page) {
+       *   let ua = await page.browser().userAgent()
+       *   if (this.opts.stripHeadless) {
+       *     ua = ua.replace('HeadlessChrome/', 'Chrome/')
+       *   }
+       *   this.debug('new ua', ua)
+       *   await page.setUserAgent(ua)
+       * }
+       */
+      async onPageCreated(page) {
+      }
+      /**
+       * Called when the url of a target changes.
+       *
+       * > Note: This includes target changes in incognito browser contexts.
+       *
+       * > Note: This includes browser instances created through `.launch()` as well as `.connect()`.
+       *
+       * @param  {Puppeteer.Target} target
+       */
+      async onTargetChanged(target) {
+      }
+      /**
+       * Called when a target is destroyed, for example when a page is closed.
+       *
+       * > Note: This includes target destructions in incognito browser contexts.
+       *
+       * > Note: This includes browser instances created through `.launch()` as well as `.connect()`.
+       *
+       * @param  {Puppeteer.Target} target
+       */
+      async onTargetDestroyed(target) {
+      }
+      /**
+       * Called when Puppeteer gets disconnected from the Chromium instance.
+       *
+       * This might happen because of one of the following:
+       * - Chromium is closed or crashed
+       * - The `browser.disconnect` method was called
+       */
+      async onDisconnected() {
+      }
+      /**
+       * **Deprecated:** Since puppeteer v1.6.0 `onDisconnected` has been improved
+       * and should be used instead of `onClose`.
+       *
+       * In puppeteer < v1.6.0 `onDisconnected` was not catching all exit scenarios.
+       * In order for plugins to clean up properly (e.g. deleting temporary files)
+       * the `onClose` method had been introduced.
+       *
+       * > Note: Might be called multiple times on exit.
+       *
+       * > Note: This only includes browser instances created through `.launch()`.
+       */
+      async onClose() {
+      }
+      /**
+       * After the plugin has been registered in `puppeteer-extra`.
+       *
+       * Normally right after `puppeteer.use(plugin)` is called
+       */
+      async onPluginRegistered() {
+      }
+      /**
+       * Helper method to retrieve `data` objects from other plugins.
+       *
+       * A plugin needs to state the `dataFromPlugins` requirement
+       * in order to use this method. Will be mapped to `puppeteer.getPluginData`.
+       *
+       * @param name - Filter data by `name` property
+       *
+       * @see [data]
+       * @see [requirements]
+       */
+      getDataFromPlugins(name) {
+        return [];
+      }
+      /**
+       * Will match plugin dependencies against all currently registered plugins.
+       * Is being called by `puppeteer-extra` and used to require missing dependencies.
+       *
+       * @param  {Array<Object>} plugins
+       * @return {Set} - list of missing plugin names
+       *
+       * @private
+       */
+      _getMissingDependencies(plugins) {
+        const pluginNames = new Set(plugins.map((p) => p.name));
+        const missing = new Set(Array.from(this.dependencies.values()).filter((x) => !pluginNames.has(x)));
+        return missing;
+      }
+      /**
+       * Conditionally bind browser/process events to class members.
+       * The idea is to reduce event binding boilerplate in plugins.
+       *
+       * For efficiency we make sure the plugin is using the respective event
+       * by checking the child class members before registering the listener.
+       *
+       * @param  {<Puppeteer.Browser>} browser
+       * @param  {Object} opts - Options
+       * @param  {string} opts.context - Puppeteer context (launch/connect)
+       * @param  {Object} [opts.options] - Puppeteer launch or connect options
+       * @param  {Array<string>} [opts.defaultArgs] - The default flags that Chromium will be launched with
+       *
+       * @private
+       */
+      async _bindBrowserEvents(browser, opts = {}) {
+        if (this._hasChildClassMember("onTargetCreated") || this._hasChildClassMember("onPageCreated")) {
+          browser.on("targetcreated", this._onTargetCreated.bind(this));
+        }
+        if (this._hasChildClassMember("onTargetChanged") && this.onTargetChanged) {
+          browser.on("targetchanged", this.onTargetChanged.bind(this));
+        }
+        if (this._hasChildClassMember("onTargetDestroyed") && this.onTargetDestroyed) {
+          browser.on("targetdestroyed", this.onTargetDestroyed.bind(this));
+        }
+        if (this._hasChildClassMember("onDisconnected") && this.onDisconnected) {
+          browser.on("disconnected", this.onDisconnected.bind(this));
+        }
+        if (opts.context === "launch" && this._hasChildClassMember("onClose")) {
+          if (this.onClose) {
+            process.on("exit", this.onClose.bind(this));
+            browser.on("disconnected", this.onClose.bind(this));
+            if (opts.options.handleSIGINT !== false) {
+              process.on("SIGINT", this.onClose.bind(this));
+            }
+            if (opts.options.handleSIGTERM !== false) {
+              process.on("SIGTERM", this.onClose.bind(this));
+            }
+            if (opts.options.handleSIGHUP !== false) {
+              process.on("SIGHUP", this.onClose.bind(this));
+            }
+          }
+        }
+        if (opts.context === "launch" && this.afterLaunch) {
+          await this.afterLaunch(browser, opts);
+        }
+        if (opts.context === "connect" && this.afterConnect) {
+          await this.afterConnect(browser, opts);
+        }
+        if (this.onBrowser)
+          await this.onBrowser(browser, opts);
+      }
+      /**
+       * @private
+       */
+      async _onTargetCreated(target) {
+        if (this.onTargetCreated)
+          await this.onTargetCreated(target);
+        if (target.type() === "page") {
+          try {
+            const page = await target.page();
+            if (!page) {
+              return;
+            }
+            const validPage = "isClosed" in page && !page.isClosed();
+            if (this.onPageCreated && validPage) {
+              await this.onPageCreated(page);
+            }
+          } catch (err) {
+            console.error(err);
+          }
+        }
+      }
+      /**
+       * @private
+       */
+      _register(prototype) {
+        this._registerChildClassMembers(prototype);
+        if (this.onPluginRegistered)
+          this.onPluginRegistered();
+      }
+      /**
+       * @private
+       */
+      _registerChildClassMembers(prototype) {
+        this._childClassMembers = Object.getOwnPropertyNames(prototype);
+      }
+      /**
+       * @private
+       */
+      _hasChildClassMember(name) {
+        return !!this._childClassMembers.includes(name);
+      }
+      /**
+       * @private
+       */
+      get _isPuppeteerExtraPlugin() {
+        return true;
+      }
+    };
+  }
+});
+
+// ../node_modules/puppeteer-extra-plugin-stealth/index.js
+var require_puppeteer_extra_plugin_stealth = __commonJS({
+  "../node_modules/puppeteer-extra-plugin-stealth/index.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var { PuppeteerExtraPlugin: PuppeteerExtraPlugin2 } = (init_index_esm(), __toCommonJS(index_esm_exports));
+    var StealthPlugin = class extends PuppeteerExtraPlugin2 {
+      constructor(opts = {}) {
+        super(opts);
+      }
+      get name() {
+        return "stealth";
+      }
+      get defaults() {
+        const availableEvasions = /* @__PURE__ */ new Set([
+          "chrome.app",
+          "chrome.csi",
+          "chrome.loadTimes",
+          "chrome.runtime",
+          "defaultArgs",
+          "iframe.contentWindow",
+          "media.codecs",
+          "navigator.hardwareConcurrency",
+          "navigator.languages",
+          "navigator.permissions",
+          "navigator.plugins",
+          "navigator.webdriver",
+          "sourceurl",
+          "user-agent-override",
+          "webgl.vendor",
+          "window.outerdimensions"
+        ]);
+        return {
+          availableEvasions,
+          // Enable all available evasions by default
+          enabledEvasions: /* @__PURE__ */ new Set([...availableEvasions])
+        };
+      }
+      /**
+       * Requires evasion techniques dynamically based on configuration.
+       *
+       * @private
+       */
+      get dependencies() {
+        return new Set(
+          [...this.opts.enabledEvasions].map((e) => `${this.name}/evasions/${e}`)
+        );
+      }
+      /**
+       * Get all available evasions.
+       *
+       * Please look into the [evasions directory](./evasions/) for an up to date list.
+       *
+       * @type {Set<string>} - A Set of all available evasions.
+       *
+       * @example
+       * const pluginStealth = require('puppeteer-extra-plugin-stealth')()
+       * console.log(pluginStealth.availableEvasions) // => Set { 'user-agent', 'console.debug' }
+       * puppeteer.use(pluginStealth)
+       */
+      get availableEvasions() {
+        return this.defaults.availableEvasions;
+      }
+      /**
+       * Get all enabled evasions.
+       *
+       * Enabled evasions can be configured either through `opts` or by modifying this property.
+       *
+       * @type {Set<string>} - A Set of all enabled evasions.
+       *
+       * @example
+       * // Remove specific evasion from enabled ones dynamically
+       * const pluginStealth = require('puppeteer-extra-plugin-stealth')()
+       * pluginStealth.enabledEvasions.delete('console.debug')
+       * puppeteer.use(pluginStealth)
+       */
+      get enabledEvasions() {
+        return this.opts.enabledEvasions;
+      }
+      /**
+       * @private
+       */
+      set enabledEvasions(evasions) {
+        this.opts.enabledEvasions = evasions;
+      }
+      async onBrowser(browser) {
+        if (browser && browser.setMaxListeners) {
+          browser.setMaxListeners(30);
+        }
+      }
+    };
+    var defaultExport = (opts) => new StealthPlugin(opts);
+    module2.exports = defaultExport;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FetchEngine: () => FetchEngine,
+  HybridEngine: () => HybridEngine,
+  PlaywrightEngine: () => PlaywrightEngine
+});
+module.exports = __toCommonJS(index_exports);
+init_cjs_shims();
+
+// src/FetchEngine.ts
+init_cjs_shims();
+
+// src/utils/markdown-converter.ts
+init_cjs_shims();
+var import_turndown = __toESM(require("turndown"), 1);
+var import_turndown_plugin_gfm = require("turndown-plugin-gfm");
+var import_node_html_parser = require("node-html-parser");
+var PREPROCESSING_REMOVE_SELECTORS = [
+  "script:not([type='application/ld+json'])",
+  // Keep JSON-LD
+  "style",
+  "noscript",
+  "iframe:not([title])"
+  // Keep iframes with titles (potential embeds)
+];
+var MAIN_CONTENT_SELECTORS = [
+  // By semantics
+  "article",
+  "main",
+  "[role='main']",
+  "[role='article']",
+  // By common class/id names (more robust patterns)
+  "[class*='article-body']",
+  "[class*='post-content']",
+  "[class*='main-content']",
+  "[class*='entry-content']",
+  "[id*='article-body']",
+  "[id*='main-content']",
+  // Common CMS patterns
+  ".article",
+  ".post",
+  ".content",
+  ".entry",
+  ".blog-post",
+  // Fallback
+  "body"
+];
+var FORUM_COMMENT_SELECTORS = [
+  ".comment",
+  ".comments",
+  ".comtr",
+  '[id^="comment-"]',
+  'div[id^="c_"]'
+];
+var FORUM_THREAD_SELECTORS = [".thread", ".post", '[id^="thread-"]'];
+var FORUM_VOTE_SELECTORS = [".vote", ".score", ".upvote", ".downvote", ".votelinks"];
+var FORUM_MAIN_POST_SELECTORS = [".fatitem", ".submission", ".op", ".original-post"];
+var FORUM_COMMENTS_CONTAINER_SELECTORS = [".comment-tree", ".comments", "#comments"];
+var FORUM_OBVIOUS_NON_CONTENT_SELECTORS = ["header", "footer", ".nav", ".sidebar"];
+var MIN_LINK_DENSITY_TEXT_LENGTH = 50;
+var DEFAULT_LINK_DENSITY_THRESHOLD = 0.4;
+var MIN_FORUM_INDICATOR_COUNT = 3;
+var CODE_BLOCK_LANG_PREFIXES = ["language-", "lang-"];
+var POSTPROCESSING_MAX_CONSECUTIVE_NEWLINES = 2;
+var MarkdownConverter = class {
+  turndownService;
+  constructor() {
+    this.turndownService = new import_turndown.default({
+      headingStyle: "atx",
+      codeBlockStyle: "fenced",
+      bulletListMarker: "-",
+      strongDelimiter: "**",
+      emDelimiter: "*",
+      hr: "---",
+      // Use nodeType check instead of window.HTMLElement
+      keepReplacement: (_content, node) => {
+        if (node.nodeType === 1) {
+          const htmlElement = node;
+          if (htmlElement.getAttribute("role") === "presentation" || htmlElement.classList?.contains("preserve")) {
+            return htmlElement.outerHTML;
+          }
+        }
+        return "";
+      }
+    });
+    this.turndownService.use(import_turndown_plugin_gfm.gfm);
+    this.setupPrioritizedRules();
+  }
+  // --- Public Method ---
+  /**
+   * Converts HTML string to Markdown.
+   * @param html The HTML string to convert.
+   * @param options Conversion options.
+   * @returns The converted Markdown string.
+   */
+  convert(html, options = {}) {
+    const preprocessedHtml = this.preprocessHTML(html);
+    let markdown = this.turndownService.turndown(preprocessedHtml);
+    markdown = this.postprocessMarkdown(markdown, options);
+    return markdown;
+  }
+  // --- Turndown Rule Setup ---
+  setupPrioritizedRules() {
+    this.addContentExtractionRules();
+    this.addStructureRules();
+    this.addBlockRules();
+    this.addInlineRules();
+  }
+  // We rely on preprocessing to remove nav/menus/high-link-density areas.
+  // These rules primarily help Turndown understand the *structure* of the *intended* content.
+  addContentExtractionRules() {
+    this.turndownService.addRule("main-content-marker", {
+      filter: (node) => {
+        if (node.nodeType !== 1) return false;
+        const el = node;
+        const element = node;
+        return el.tagName.toLowerCase() === "main" || ["main", "article"].includes(el.getAttribute("role") || "") || MAIN_CONTENT_SELECTORS.some((selector) => {
+          try {
+            return element.matches(selector) && selector !== "body";
+          } catch {
+            return false;
+          }
+        });
+      },
+      // Just pass content through, this rule is mainly for filter priority/debugging
+      replacement: (content) => content
+    });
+    const unwantedTags = [
+      "script",
+      "style",
+      "noscript",
+      "iframe",
+      "button",
+      "input",
+      "select",
+      "textarea",
+      "form",
+      "canvas",
+      /*'svg' removed */
+      "audio",
+      "video"
+    ];
+    this.turndownService.addRule("remove-unwanted", {
+      filter: unwantedTags,
+      replacement: () => ""
+    });
+  }
+  addStructureRules() {
+    this.turndownService.addRule("article", {
+      filter: "article",
+      replacement: (content) => `
+
+${content}
+
+`
+      // Add separation
+    });
+    this.turndownService.addRule("section", {
+      filter: "section",
+      replacement: (content) => `
+
+${content}
+
+`
+      // Add separation
+    });
+  }
+  addBlockRules() {
+    this.turndownService.addRule("list", {
+      filter: ["ul", "ol"],
+      replacement: (content, node) => {
+        if (node.nodeType !== 1) return content;
+        const parent = node.parentNode;
+        const indent = parent && parent.nodeName.toLowerCase() === "li" ? "  " : "";
+        return "\n" + content.split("\n").map((line) => indent + line.trimEnd()).join("\n").trim() + "\n";
+      }
+    });
+    this.turndownService.addRule("listItem", {
+      filter: "li",
+      // Use standard function for `this` context if needed, or ensure types match
+      replacement: function(content, node, options) {
+        content = content.replace(/^\s+/gm, "").replace(/\n(?!\s*$)/gm, "\n  ");
+        let prefix = options.bulletListMarker + " ";
+        const parentNode = node.parentNode;
+        if (parentNode && parentNode.nodeName === "OL") {
+          try {
+            const start = parentNode.getAttribute("start");
+            const elementNode = node;
+            const parentElement = parentNode;
+            const index = Array.prototype.indexOf.call(parentElement.children, elementNode);
+            prefix = (start ? Number(start) + index : index + 1) + ". ";
+          } catch (e) {
+            console.warn("Could not determine ordered list index:", e);
+            prefix = "1. ";
+          }
+        }
+        const trimmedContent = content.trim();
+        return prefix + trimmedContent + (node.nextSibling && !/\n$/.test(trimmedContent) ? "\n" : "");
+      }
+    });
+    this.turndownService.addRule("blockquote", {
+      filter: "blockquote",
+      replacement: (content) => {
+        const trimmedContent = content.trim();
+        return "\n\n> " + trimmedContent.replace(/\n/g, "\n> ") + "\n\n";
+      }
+    });
+  }
+  addInlineRules() {
+    this.turndownService.addRule("link", {
+      filter: (node, _options) => {
+        return node.nodeType === 1 && node.nodeName === "A" && !!node.getAttribute("href");
+      },
+      replacement: (content, node) => {
+        const element = node;
+        const href = element.getAttribute("href") || "";
+        const title = element.getAttribute("title");
+        const text = content.trim() ? content.trim() : href;
+        let decodedHref = href;
+        try {
+          if (href.includes("%")) {
+            decodedHref = decodeURI(href);
+          }
+        } catch (e) {
+          console.warn(`Failed to decode URI, keeping original: ${href}`, e);
+        }
+        return title ? `[${text}](${decodedHref} "${title}")` : `[${text}](${decodedHref})`;
+      }
+    });
+    this.turndownService.addRule("figure", {
+      filter: "figure",
+      replacement: (content, node) => {
+        if (node.nodeType !== 1) return content;
+        const element = node;
+        const img = element.querySelector("img");
+        const figcaption = element.querySelector("figcaption");
+        let markdown = "";
+        let mainImgMd = "";
+        if (img) {
+          const src = img.getAttribute("src") || "";
+          const alt = img.getAttribute("alt") || "";
+          const title = img.getAttribute("title");
+          mainImgMd = title ? `![${alt}](${src} "${title}")` : `![${alt}](${src})`;
+        }
+        let processedContent = content.trim();
+        if (mainImgMd) {
+          markdown = mainImgMd;
+          const imgPlaceholder = `![${img?.getAttribute("alt") || ""}](${img?.getAttribute("src") || ""})`;
+          processedContent = processedContent.replace(imgPlaceholder, "").trim();
+        }
+        if (figcaption) {
+          const captionText = figcaption.textContent?.trim();
+          if (captionText) {
+            markdown += `
+
+_${captionText}_`;
+            processedContent = processedContent.replace(captionText, "").trim();
+            processedContent = processedContent.replace(/^_+|_+$/g, "").trim();
+          }
+        }
+        if (processedContent) {
+          if (processedContent.length > 10 || /[a-zA-Z0-9]/.test(processedContent)) {
+            markdown += `
+
+${processedContent}`;
+          }
+        }
+        return "\n\n" + markdown.trim() + "\n\n";
+      }
+    });
+    this.turndownService.addRule("image", {
+      filter: (node) => {
+        return node.nodeType === 1 && node.nodeName === "IMG" && !!node.getAttribute("src");
+      },
+      replacement: (_content, node) => {
+        const element = node;
+        const src = element.getAttribute("src") || "";
+        const alt = element.getAttribute("alt") || "";
+        const title = element.getAttribute("title");
+        return title ? `
+
+![${alt}](${src} "${title}")
+
+` : `
+
+![${alt}](${src})
+
+`;
+      }
+    });
+    this.turndownService.addRule("code-block", {
+      filter: (node) => {
+        if (node.nodeType !== 1) return false;
+        const element = node;
+        const isPre = element.tagName.toLowerCase() === "pre";
+        if (!isPre) return false;
+        const hasCodeChild = element.querySelector("code") !== null;
+        const hasCodeClass = /highlight|syntax|code|listing|source/i.test(element.className);
+        const hasLangAttribute = !!element.getAttribute("lang") || !!element.getAttribute("language");
+        return hasCodeChild || hasCodeClass || hasLangAttribute;
+      },
+      replacement: (content, node) => {
+        if (node.nodeType !== 1) return content.trim();
+        const element = node;
+        let language = "";
+        const codeElement = element.querySelector("code");
+        language = element.getAttribute("lang") || element.getAttribute("language") || (codeElement ? codeElement.getAttribute("lang") || codeElement.getAttribute("language") : "") || "";
+        if (!language) {
+          const classes = (element.className + " " + (codeElement?.className || "")).split(" ").filter(Boolean);
+          for (const cls of classes) {
+            for (const prefix of CODE_BLOCK_LANG_PREFIXES) {
+              if (cls.startsWith(prefix)) {
+                language = cls.substring(prefix.length);
+                break;
+              }
+            }
+            if (language) break;
+          }
+        }
+        const cleanedContent = content.trim();
+        return `
+
+\`\`\`${language}
+${cleanedContent}
+\`\`\`
+
+`;
+      }
+    });
+    this.turndownService.addRule("inlineCode", {
+      filter: (node) => node.nodeName === "CODE" && node.parentNode?.nodeName !== "PRE",
+      replacement: (content) => {
+        const trimmed = content.trim();
+        if (!trimmed) return "";
+        let delimiter = "`";
+        if (trimmed.includes("`")) {
+          delimiter = "``";
+          if (trimmed.startsWith("`") || trimmed.endsWith("`")) {
+            return `${delimiter} ${trimmed} ${delimiter}`;
+          }
+        }
+        return delimiter + trimmed + delimiter;
+      }
+    });
+  }
+  // --- HTML Preprocessing ---
+  preprocessHTML(html) {
+    try {
+      html = this.cleanupHtml(html);
+      const root = (0, import_node_html_parser.parse)(html, {
+        comment: false,
+        blockTextElements: { script: true, style: true, noscript: true }
+      });
+      if (root.nodeType === 3) {
+        return root.textContent ?? "";
+      } else if (root.nodeType !== 1) {
+        console.warn("Unexpected root node type after parsing:", root.nodeType);
+        return root.toString();
+      }
+      const rootElement = root;
+      PREPROCESSING_REMOVE_SELECTORS.forEach((selector) => {
+        try {
+          rootElement.querySelectorAll(selector).forEach((el) => el.remove());
+        } catch (e) {
+          console.warn(`Skipping invalid selector during preprocessing: ${selector}`, e);
+        }
+      });
+      this.removeHighLinkDensityElements(rootElement, DEFAULT_LINK_DENSITY_THRESHOLD);
+      const metadata = this.extractDocumentMetadata(rootElement);
+      const isForum = this.detectForumPage(rootElement);
+      let contentElement = rootElement;
+      if (isForum) {
+        contentElement = this.extractForumContentElement(rootElement);
+      } else {
+        contentElement = this.extractArticleContentElement(rootElement);
+      }
+      let contentHtml = contentElement instanceof import_node_html_parser.HTMLElement ? contentElement.outerHTML : contentElement.textContent;
+      contentHtml = this.cleanupContentHtml(contentHtml || "");
+      const metadataString = metadata.length > 0 ? metadata.join("\n\n") + "\n\n---\n\n" : "";
+      return metadataString + contentHtml;
+    } catch (error) {
+      console.error("HTML preprocessing failed:", error);
+      return this.cleanupHtml(html);
+    }
+  }
+  cleanupHtml(html) {
+    return html.replace(/AMIL:\[=-,amilft[^\s]*/g, "").replace(/\{\{\s*[^}\s]+\s*}}/g, "").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+  }
+  cleanupContentHtml(content) {
+    return content.replace(/\s*data-(?:reactid|reactroot|react-|testid|v-|js-|qa-|cy-)[^=\s]*\s*=\s*(?:"[^"]*"|'[^']*'|\S+)/g, "").replace(/\s*ng-[^=\s]*\s*=\s*(?:"[^"]*"|'[^']*'|\S+)/g, "").replace(/\s*_ngcontent-[^\s]*\s*=""/g, "").replace(/\s*class\s*=\s*"(ng-|mat-)[^"]*"/g, "").replace(/<!--[\s\S]*?-->/g, "").replace(/([ \t])+/g, " ").replace(/\s*\n\s*/g, "\n").trim();
+  }
+  removeHighLinkDensityElements(element, threshold) {
+    const potentialBoilerplate = element.querySelectorAll(
+      "div, nav, ul, aside, section, .sidebar, .widget, .menu, [role='navigation'], [role='menubar']"
+    );
+    for (const el of Array.from(potentialBoilerplate)) {
+      if (!(el instanceof import_node_html_parser.HTMLElement)) continue;
+      const textContent = el.textContent || "";
+      if (textContent.length < MIN_LINK_DENSITY_TEXT_LENGTH) continue;
+      const links = el.querySelectorAll("a");
+      if (links.length < 3) continue;
+      const textLength = textContent.length;
+      let linkTextLength = 0;
+      el.querySelectorAll("a").forEach((link) => {
+        if (link.closest("a") === link) {
+          linkTextLength += link.textContent?.length || 0;
+        }
+      });
+      if (textLength === 0) continue;
+      const density = linkTextLength / textLength;
+      if (density > threshold) {
+        const containsMainContent = el.querySelector('main, article, [role="main"], [role="article"]') !== null;
+        const isMainContent = MAIN_CONTENT_SELECTORS.some((selector) => {
+          try {
+            return el.matches(selector);
+          } catch {
+            return false;
+          }
+        });
+        if (!containsMainContent && !isMainContent) {
+          el.remove();
+        }
+      }
+    }
+  }
+  extractDocumentMetadata(root) {
+    const metadata = [];
+    const addedMeta = /* @__PURE__ */ new Set();
+    const addMeta = (key, value, isTitle = false) => {
+      const cleanedValue = value?.trim();
+      if (cleanedValue && !addedMeta.has(key.toLowerCase())) {
+        if (isTitle) {
+          metadata.unshift(`# ${cleanedValue}`);
+        } else {
+          metadata.push(`**${key}:** ${cleanedValue}`);
+        }
+        addedMeta.add(key.toLowerCase());
+      }
+    };
+    addMeta("Title", root.querySelector("meta[property='og:title']")?.getAttribute("content"), true);
+    addMeta("Title", root.querySelector("meta[name='twitter:title']")?.getAttribute("content"), true);
+    addMeta("Title", root.querySelector("meta[name='DC.title']")?.getAttribute("content"), true);
+    addMeta("Title", root.querySelector("title")?.textContent, true);
+    addMeta("Description", root.querySelector("meta[property='og:description']")?.getAttribute("content"));
+    addMeta("Description", root.querySelector("meta[name='twitter:description']")?.getAttribute("content"));
+    addMeta("Description", root.querySelector("meta[name='description']")?.getAttribute("content"));
+    addMeta("Description", root.querySelector("meta[name='DC.description']")?.getAttribute("content"));
+    addMeta("Author", root.querySelector("meta[name='author']")?.getAttribute("content"));
+    addMeta("Author", root.querySelector("meta[property='article:author']")?.getAttribute("content"));
+    addMeta("Author", root.querySelector("[rel='author']")?.textContent);
+    addMeta("Published", root.querySelector("meta[property='article:published_time']")?.getAttribute("content"));
+    addMeta("Published", root.querySelector("meta[name='publish-date']")?.getAttribute("content"));
+    addMeta("Published", root.querySelector("time[itemprop='datePublished']")?.getAttribute("datetime"));
+    addMeta("Published", root.querySelector("time")?.getAttribute("datetime"));
+    addMeta("URL", root.querySelector("link[rel='canonical']")?.getAttribute("href"));
+    addMeta("URL", root.querySelector("meta[property='og:url']")?.getAttribute("content"));
+    const jsonLdScripts = root.querySelectorAll("script[type='application/ld+json']");
+    if (jsonLdScripts.length > 0) {
+      const jsonLdData = Array.from(jsonLdScripts).map((script) => {
+        try {
+          const textContent = script.textContent;
+          return textContent ? JSON.parse(textContent) : null;
+        } catch (e) {
+          return null;
+        }
+      }).filter((item) => item !== null);
+      if (jsonLdData.length > 0 && !addedMeta.has("json-ld")) {
+        metadata.push("<details><summary>JSON-LD Metadata</summary>\n");
+        metadata.push("```json", JSON.stringify(jsonLdData, null, 2), "```");
+        metadata.push("</details>");
+        addedMeta.add("json-ld");
+      }
+    }
+    return metadata;
+  }
+  detectForumPage(root) {
+    const countMatches = (selectors) => {
+      return selectors.reduce((count, selector) => {
+        try {
+          if (root) {
+            return count + root.querySelectorAll(selector).length;
+          }
+          return count;
+        } catch {
+          return count;
+        }
+      }, 0);
+    };
+    const commentCount = countMatches(FORUM_COMMENT_SELECTORS);
+    const threadCount = countMatches(FORUM_THREAD_SELECTORS);
+    const voteCount = countMatches(FORUM_VOTE_SELECTORS);
+    let isKnownForumHost = false;
+    try {
+      const canonicalUrl = root.querySelector('link[rel="canonical"]')?.getAttribute("href") || root.querySelector('meta[property="og:url"]')?.getAttribute("content");
+      if (canonicalUrl) {
+        const absoluteUrl = new URL(canonicalUrl, "http://example.com").toString();
+        const hostname = new URL(absoluteUrl).hostname.toLowerCase();
+        isKnownForumHost = hostname.includes("reddit.com") || hostname.includes("news.ycombinator.com") || hostname.includes("forum") || hostname.includes("discuss") || hostname.includes("community");
+      }
+    } catch (e) {
+      console.warn("Could not parse URL for forum detection:", e);
+    }
+    return commentCount >= MIN_FORUM_INDICATOR_COUNT || threadCount > 1 || // More than one thread item is stronger indicator
+    voteCount >= MIN_FORUM_INDICATOR_COUNT || isKnownForumHost;
+  }
+  // Tries to find the main content element for an article-like page
+  extractArticleContentElement(root) {
+    let bestCandidate = null;
+    let maxScore = -1;
+    for (const selector of MAIN_CONTENT_SELECTORS) {
+      try {
+        const elements = root.querySelectorAll(selector);
+        for (const element of Array.from(elements)) {
+          if (!(element instanceof import_node_html_parser.HTMLElement)) continue;
+          const textLength = (element.textContent || "").trim().length;
+          if (textLength < 100 && !element.querySelector("img, video, iframe, figure")) continue;
+          let score = textLength;
+          if (["ARTICLE", "MAIN"].includes(element.tagName)) score *= 1.5;
+          if (["main", "article"].includes(element.getAttribute("role") || "")) score *= 1.5;
+          if (["HEADER", "FOOTER", "NAV", "ASIDE"].includes(element.tagName)) score *= 0.3;
+          try {
+            if (
+              /* @ts-expect-error TODO: fix this */
+              element.matches(
+                '.sidebar, .widget, .menu, .nav, .header, .footer, [role="navigation"], [role="complementary"], [role="banner"]'
+              )
+            )
+              score *= 0.2;
+          } catch {
+          }
+          if (this.hasHighLinkDensity(element, 0.6)) {
+            score *= 0.5;
+          }
+          if (element.querySelectorAll("p").length > 2) score *= 1.2;
+          if (element.tagName === "BODY" && maxScore > 200) continue;
+          if (score > maxScore) {
+            maxScore = score;
+            bestCandidate = element;
+          }
+        }
+      } catch (e) {
+      }
+    }
+    return bestCandidate || root;
+  }
+  // Tries to find the main content element(s) for a forum-like page
+  extractForumContentElement(root) {
+    const tempContainer = (0, import_node_html_parser.parse)("<div></div>").firstChild;
+    try {
+      const mainPost = FORUM_MAIN_POST_SELECTORS.map((s) => root.querySelector(s)).find(
+        (el) => el instanceof import_node_html_parser.HTMLElement
+      );
+      if (mainPost) {
+        tempContainer.appendChild(mainPost.clone());
+      }
+    } catch (e) {
+      console.warn("Error finding forum main post:", e);
+    }
+    try {
+      const commentsContainer = FORUM_COMMENTS_CONTAINER_SELECTORS.map((s) => root.querySelector(s)).find(
+        (el) => el instanceof import_node_html_parser.HTMLElement
+      );
+      if (commentsContainer) {
+        const clonedComments = commentsContainer.clone();
+        if (clonedComments instanceof import_node_html_parser.HTMLElement) {
+          FORUM_OBVIOUS_NON_CONTENT_SELECTORS.forEach((selector) => {
+            try {
+              clonedComments.querySelectorAll(selector).forEach((el) => el.remove());
+            } catch {
+            }
+          });
+          tempContainer.appendChild(clonedComments);
+        }
+      }
+    } catch (e) {
+      console.warn("Error finding forum comments container:", e);
+    }
+    if (tempContainer.childNodes.length > 0) {
+      return tempContainer;
+    }
+    const body = root.querySelector("body");
+    if (body) {
+      const clonedBody = body.clone();
+      if (clonedBody instanceof import_node_html_parser.HTMLElement) {
+        FORUM_OBVIOUS_NON_CONTENT_SELECTORS.forEach((selector) => {
+          try {
+            clonedBody.querySelectorAll(selector).forEach((el) => el.remove());
+          } catch {
+          }
+        });
+        this.removeHighLinkDensityElements(clonedBody, DEFAULT_LINK_DENSITY_THRESHOLD);
+        return clonedBody;
+      }
+    }
+    return root;
+  }
+  // Helper function to check link density within an element
+  hasHighLinkDensity(element, threshold) {
+    const textContent = element.textContent || "";
+    if (textContent.length < MIN_LINK_DENSITY_TEXT_LENGTH) return false;
+    const links = element.querySelectorAll("a");
+    if (links.length < 3) return false;
+    const textLength = textContent.length;
+    let linkTextLength = 0;
+    element.querySelectorAll("a").forEach((link) => {
+      if (link.closest("a") === link) {
+        linkTextLength += link.textContent?.length || 0;
+      }
+    });
+    if (textLength === 0) return false;
+    return linkTextLength / textLength > threshold;
+  }
+  // --- Markdown Postprocessing ---
+  postprocessMarkdown(markdown, options) {
+    let processed = markdown;
+    processed = processed.replace(/^(\s*\n)?(#{1,6}\s.*)$/gm, "\n\n$2\n\n");
+    processed = processed.replace(/^(\s*\n)?(([\*\-+>]|\d+\.)\s)/gm, (_match, _p1, p2) => `
+
+${p2}`);
+    processed = processed.replace(
+      /(\n([\*\-+]|\d+\.)\s(?:(?!\n\n|\n {2,}|\n\t)[\s\S])*?)\n(?=([\*\-+]|\d+\.)\s)/g,
+      "$1"
+    );
+    processed = processed.replace(/\[\]\([^)]*\)/g, "");
+    processed = processed.replace(/!\[\]\([^)]*\)/g, "");
+    processed = processed.replace(/(!?\[[^\]]*\]\()(\/\/)/g, "$1https://");
+    const maxNewlines = "\n".repeat(POSTPROCESSING_MAX_CONSECUTIVE_NEWLINES + 1);
+    const newlineRegex = new RegExp(`${maxNewlines}+`, "g");
+    processed = processed.replace(newlineRegex, "\n".repeat(POSTPROCESSING_MAX_CONSECUTIVE_NEWLINES));
+    processed = processed.replace(/^[ \t]+|[ \t]+$/gm, "");
+    processed = processed.replace(/^(\s*\n)?(```(.*)\n[\s\S]*?\n```)(\s*\n)?/gm, "\n\n$2\n\n");
+    processed = processed.replace(/^(.{30,})$(\n\1)+/gm, "$1");
+    processed = processed.replace(/(\n---\n)(\S)/g, "$1\n$2");
+    if (options.maxContentLength && processed.length > options.maxContentLength) {
+      const truncatedPoint = processed.lastIndexOf(".", options.maxContentLength - 15);
+      const sliceEnd = truncatedPoint > options.maxContentLength / 2 ? truncatedPoint + 1 : options.maxContentLength;
+      processed = processed.slice(0, sliceEnd) + "... (truncated)";
+    }
+    return processed.trim();
+  }
+};
+
+// src/errors.ts
+init_cjs_shims();
+var FetchError = class _FetchError extends Error {
+  /** A specific error code (e.g., ERR_NAVIGATION_TIMEOUT, ERR_HTTP_ERROR). */
+  code;
+  /** The original error object, if available. */
+  originalError;
+  /** HTTP status code, if relevant. */
+  statusCode;
+  /**
+   * Creates an instance of FetchError.
+   * @param message The error message.
+   * @param code Optional error code string.
+   * @param originalError Optional original error.
+   * @param statusCode Optional HTTP status code.
+   */
+  constructor(message, code, originalError, statusCode) {
+    super(message);
+    this.name = "FetchError";
+    this.code = code;
+    this.originalError = originalError;
+    this.statusCode = statusCode;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FetchError);
+    }
+  }
+};
+
+// src/FetchEngine.ts
+var FetchEngineHttpError = class extends FetchError {
+  constructor(message, statusCode) {
+    super(message, "ERR_HTTP_ERROR", void 0, statusCode);
+    this.statusCode = statusCode;
+    this.name = "FetchEngineHttpError";
+  }
+};
+var FetchEngine = class _FetchEngine {
+  options;
+  static DEFAULT_OPTIONS = {
+    markdown: false
+  };
+  /**
+   * Creates an instance of FetchEngine.
+   * @param options Configuration options for the FetchEngine.
+   */
+  constructor(options = {}) {
+    this.options = { ..._FetchEngine.DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Fetches HTML or converts to Markdown from the specified URL.
+   *
+   * @param url The URL to fetch.
+   * @returns A Promise resolving to an HTMLFetchResult object.
+   * @throws {FetchEngineHttpError} If the HTTP response status is not ok (e.g., 404, 500).
+   * @throws {Error} If the content type is not HTML or for other network errors.
+   */
+  async fetchHTML(url, options) {
+    const effectiveOptions = { ...this.options, ...options };
+    let response;
+    try {
+      response = await fetch(url, {
+        redirect: "follow",
+        headers: {
+          // Standard browser-like headers
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+          "Accept-Language": "en-US,en;q=0.9"
+        }
+      });
+      if (!response.ok) {
+        throw new FetchEngineHttpError(`HTTP error! status: ${response.status}`, response.status);
+      }
+      const contentTypeHeader = response.headers.get("content-type");
+      if (!contentTypeHeader || !contentTypeHeader.includes("text/html")) {
+        throw new FetchError("Content-Type is not text/html", "ERR_NON_HTML_CONTENT");
+      }
+      const html = await response.text();
+      const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+      const title = titleMatch ? titleMatch[1].trim() : null;
+      let finalContent = html;
+      let finalContentType = "html";
+      if (effectiveOptions.markdown) {
+        try {
+          const converter = new MarkdownConverter();
+          finalContent = converter.convert(html);
+          finalContentType = "markdown";
+        } catch (conversionError) {
+          console.error(`Markdown conversion failed for ${url} (FetchEngine):`, conversionError);
+        }
+      }
+      return {
+        content: finalContent,
+        contentType: finalContentType,
+        title,
+        url: response.url,
+        // Use the final URL after redirects
+        isFromCache: false,
+        statusCode: response.status,
+        error: void 0
+      };
+    } catch (error) {
+      if (error instanceof FetchEngineHttpError || error instanceof FetchError && error.code === "ERR_NON_HTML_CONTENT") {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : "Unknown fetch error";
+      throw new FetchError(`Fetch failed: ${message}`, "ERR_FETCH_FAILED", error instanceof Error ? error : void 0);
+    }
+  }
+  /**
+   * Cleans up resources used by the engine.
+   * For FetchEngine, this is a no-op as it doesn't manage persistent resources.
+   * @returns A Promise that resolves when cleanup is complete.
+   */
+  async cleanup() {
+    return Promise.resolve();
+  }
+  /**
+   * Retrieves metrics for the engine.
+   * FetchEngine does not manage browsers, so it returns an empty array.
+   * @returns An empty array.
+   */
+  getMetrics() {
+    return [];
+  }
+};
+
+// src/PlaywrightEngine.ts
+init_cjs_shims();
+
+// src/browser/PlaywrightBrowserPool.ts
+init_cjs_shims();
+var import_playwright = require("playwright");
+var import_user_agents = __toESM(require("user-agents"), 1);
+var import_uuid = require("uuid");
+var import_p_queue = __toESM(require("p-queue"), 1);
+var import_playwright_extra = require("playwright-extra");
+var chromiumWithExtras;
+var StealthPluginInstance;
+async function loadDependencies() {
+  if (!chromiumWithExtras) {
+    chromiumWithExtras = (0, import_playwright_extra.addExtra)(import_playwright.chromium);
+    const StealthPluginModule = await Promise.resolve().then(() => __toESM(require_puppeteer_extra_plugin_stealth(), 1));
+    const stealthPluginFactory = typeof StealthPluginModule.default === "function" ? StealthPluginModule.default : StealthPluginModule;
+    if (typeof stealthPluginFactory !== "function") {
+      throw new Error("puppeteer-extra-plugin-stealth export is not a function or module structure is unexpected.");
+    }
+    StealthPluginInstance = stealthPluginFactory();
+    chromiumWithExtras.use(StealthPluginInstance);
+  }
+}
+var PlaywrightBrowserPool = class _PlaywrightBrowserPool {
+  pool = /* @__PURE__ */ new Set();
+  maxBrowsers;
+  maxPagesPerContext;
+  maxBrowserAge;
+  healthCheckInterval;
+  healthCheckTimer = null;
+  maxIdleTime;
+  isCleaningUp = false;
+  useHeadedMode;
+  blockedDomains;
+  blockedResourceTypes;
+  proxyConfig;
+  static DEFAULT_BLOCKED_DOMAINS = [
+    "doubleclick.net",
+    "google-analytics.com",
+    "googletagmanager.com",
+    "googlesyndication.com",
+    "googleadservices.com",
+    "adservice.google.com",
+    "facebook.net",
+    "fbcdn.net",
+    "connect.facebook.net",
+    "ads-twitter.com",
+    "platform.twitter.com",
+    "analytics.tiktok.com",
+    "ads.tiktok.com",
+    "amazon-adsystem.com",
+    "adnxs.com",
+    "criteo.com",
+    "scorecardresearch.com",
+    "quantserve.com",
+    "rubiconproject.com",
+    "pubmatic.com",
+    "taboola.com",
+    "outbrain.com"
+  ];
+  static DEFAULT_BLOCKED_RESOURCE_TYPES = ["image", "font", "media", "websocket"];
+  acquireQueue = new import_p_queue.default({ concurrency: 1 });
+  constructor(config = {}) {
+    this.maxBrowsers = config.maxBrowsers ?? 2;
+    this.maxPagesPerContext = config.maxPagesPerContext ?? 6;
+    this.maxBrowserAge = config.maxBrowserAge ?? 20 * 60 * 1e3;
+    this.healthCheckInterval = config.healthCheckInterval ?? 60 * 1e3;
+    this.useHeadedMode = config.useHeadedMode ?? false;
+    this.maxIdleTime = config.maxIdleTime ?? 5 * 60 * 1e3;
+    this.blockedDomains = config.blockedDomains && config.blockedDomains.length > 0 ? config.blockedDomains : _PlaywrightBrowserPool.DEFAULT_BLOCKED_DOMAINS;
+    this.blockedResourceTypes = config.blockedResourceTypes && config.blockedResourceTypes.length > 0 ? config.blockedResourceTypes : _PlaywrightBrowserPool.DEFAULT_BLOCKED_RESOURCE_TYPES;
+    this.proxyConfig = config.proxy;
+  }
+  async initialize() {
+    await loadDependencies();
+    if (this.isCleaningUp) return;
+    await this.ensureMinimumInstances();
+    this.scheduleHealthCheck();
+  }
+  scheduleHealthCheck() {
+    if (this.isCleaningUp) return;
+    if (this.healthCheckTimer) {
+      clearTimeout(this.healthCheckTimer);
+    }
+    if (this.healthCheckInterval > 0) {
+      this.healthCheckTimer = setTimeout(() => {
+        this.healthCheck().catch((_err) => {
+        });
+      }, this.healthCheckInterval);
+    }
+  }
+  async ensureMinimumInstances() {
+    if (this.isCleaningUp) return;
+    while (this.pool.size < this.maxBrowsers) {
+      try {
+        await this.createBrowserInstance();
+      } catch (error) {
+        break;
+      }
+    }
+  }
+  async createBrowserInstance() {
+    await loadDependencies();
+    const id = (0, import_uuid.v4)();
+    const launchOptions = {
+      headless: !this.useHeadedMode,
+      args: [
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-accelerated-2d-canvas",
+        "--no-first-run",
+        "--no-zygote",
+        "--disable-gpu",
+        "--mute-audio",
+        "--disable-background-networking"
+      ],
+      proxy: this.proxyConfig
+    };
+    const browser = await chromiumWithExtras.launch(launchOptions);
+    const context = await browser.newContext({
+      userAgent: new import_user_agents.default().toString(),
+      viewport: {
+        width: 1280 + Math.floor(Math.random() * 120),
+        height: 720 + Math.floor(Math.random() * 80)
+      },
+      javaScriptEnabled: true,
+      ignoreHTTPSErrors: true
+    });
+    await context.route("**/*", async (route) => {
+      const request = route.request();
+      const url = request.url();
+      const resourceType = request.resourceType();
+      try {
+        const hostname = new URL(url).hostname.toLowerCase();
+        if (this.blockedDomains.some((domain) => hostname.includes(domain)) || this.blockedResourceTypes.includes(resourceType)) {
+          await route.abort("aborted");
+        } else {
+          await route.continue();
+        }
+      } catch (_e) {
+        await route.continue();
+      }
+    });
+    const now = /* @__PURE__ */ new Date();
+    const metrics = {
+      id,
+      pagesCreated: 0,
+      activePages: 0,
+      lastUsed: now,
+      errors: 0,
+      createdAt: now,
+      isHealthy: true
+    };
+    const instance = {
+      id,
+      browser,
+      context,
+      pages: /* @__PURE__ */ new Set(),
+      metrics,
+      isHealthy: true,
+      disconnectedHandler: () => {
+      }
+    };
+    instance.disconnectedHandler = () => {
+      if (instance.isHealthy) {
+        instance.isHealthy = false;
+        instance.metrics.isHealthy = false;
+        this.healthCheck().catch((_err) => {
+        });
+      }
+    };
+    browser.on("disconnected", instance.disconnectedHandler);
+    this.pool.add(instance);
+    return instance;
+  }
+  acquirePage() {
+    return this.acquireQueue.add(async () => {
+      if (this.isCleaningUp) {
+        throw new Error("Pool is shutting down.");
+      }
+      let bestInstance = null;
+      for (const instance of this.pool) {
+        if (instance.isHealthy && instance.pages.size < this.maxPagesPerContext) {
+          if (!bestInstance || instance.pages.size < bestInstance.pages.size) {
+            bestInstance = instance;
+          }
+        }
+      }
+      if (!bestInstance && this.pool.size < this.maxBrowsers) {
+        try {
+          bestInstance = await this.createBrowserInstance();
+        } catch (error) {
+          throw new Error(`Failed to create new browser instance for acquisition: ${error.message}`);
+        }
+      }
+      if (!bestInstance) {
+        await this.ensureMinimumInstances();
+        for (const instance of this.pool) {
+          if (instance.isHealthy && instance.pages.size < this.maxPagesPerContext) {
+            if (!bestInstance || instance.pages.size < bestInstance.pages.size) {
+              bestInstance = instance;
+            }
+          }
+        }
+        if (!bestInstance) {
+          throw new Error("Failed to acquire Playwright page: No available or creatable browser instance.");
+        }
+      }
+      try {
+        const page = await bestInstance.context.newPage();
+        bestInstance.pages.add(page);
+        bestInstance.metrics.pagesCreated++;
+        bestInstance.metrics.activePages = bestInstance.pages.size;
+        bestInstance.metrics.lastUsed = /* @__PURE__ */ new Date();
+        page.on("close", () => {
+          bestInstance.pages.delete(page);
+          bestInstance.metrics.activePages = bestInstance.pages.size;
+          bestInstance.metrics.lastUsed = /* @__PURE__ */ new Date();
+        });
+        page.on("crash", () => {
+          bestInstance.metrics.errors++;
+          bestInstance.pages.delete(page);
+          bestInstance.isHealthy = false;
+          bestInstance.metrics.isHealthy = false;
+          this.healthCheck().catch((_err) => {
+          });
+        });
+        return page;
+      } catch (error) {
+        bestInstance.metrics.errors++;
+        bestInstance.isHealthy = false;
+        bestInstance.metrics.isHealthy = false;
+        this.healthCheck().catch((_err) => {
+        });
+        throw new Error(`Failed to create new page: ${error.message}`);
+      }
+    });
+  }
+  async healthCheck() {
+    if (this.isCleaningUp) return;
+    const now = /* @__PURE__ */ new Date();
+    const checks = [];
+    for (const instance of this.pool) {
+      checks.push(
+        (async () => {
+          if (!instance.isHealthy) {
+            return;
+          }
+          let shouldRemove = false;
+          let reason = "unknown";
+          if (!instance.browser.isConnected()) {
+            shouldRemove = true;
+            reason = "browser disconnected";
+          }
+          if (!shouldRemove && this.maxBrowserAge > 0 && now.getTime() - instance.metrics.createdAt.getTime() > this.maxBrowserAge) {
+            shouldRemove = true;
+            reason = "max age reached";
+          }
+          if (!shouldRemove && this.pool.size > 1 && // Only remove idle if pool has more than 1
+          instance.pages.size === 0 && this.maxIdleTime > 0 && now.getTime() - instance.metrics.lastUsed.getTime() > this.maxIdleTime) {
+            shouldRemove = true;
+            reason = "idle timeout";
+          }
+          if (shouldRemove) {
+            instance.isHealthy = false;
+            instance.metrics.isHealthy = false;
+            await this.closeAndRemoveInstance(instance, reason);
+          } else {
+            instance.isHealthy = true;
+            instance.metrics.isHealthy = true;
+          }
+        })().catch((_err) => {
+        })
+      );
+    }
+    try {
+      await Promise.allSettled(checks);
+    } finally {
+      await this.ensureMinimumInstances();
+      this.scheduleHealthCheck();
+    }
+  }
+  async closeAndRemoveInstance(instance, _reason) {
+    const removed = this.pool.delete(instance);
+    if (!removed) return;
+    instance.browser.off("disconnected", instance.disconnectedHandler);
+    try {
+      await instance.context.close();
+    } catch (_error) {
+    }
+    try {
+      await instance.browser.close();
+    } catch (_error) {
+    }
+  }
+  async releasePage(page) {
+    if (!page || page.isClosed()) return;
+    let ownerInstance;
+    for (const instance of this.pool) {
+      if (instance.pages.has(page)) {
+        ownerInstance = instance;
+        break;
+      }
+    }
+    try {
+      await page.close();
+      if (ownerInstance) {
+        ownerInstance.pages.delete(page);
+        ownerInstance.metrics.activePages = ownerInstance.pages.size;
+        ownerInstance.metrics.lastUsed = /* @__PURE__ */ new Date();
+      }
+    } catch (error) {
+      if (ownerInstance) {
+        ownerInstance.isHealthy = false;
+        ownerInstance.metrics.isHealthy = false;
+        ownerInstance.metrics.errors++;
+        ownerInstance.pages.delete(page);
+        ownerInstance.metrics.activePages = ownerInstance.pages.size;
+      }
+    }
+  }
+  async cleanup() {
+    if (this.isCleaningUp) return;
+    this.isCleaningUp = true;
+    if (this.healthCheckTimer) {
+      clearTimeout(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+    this.acquireQueue.clear();
+    await this.acquireQueue.onIdle();
+    const closePromises = [...this.pool].map((instance) => this.closeAndRemoveInstance(instance, "cleanup"));
+    this.pool.clear();
+    await Promise.allSettled(closePromises);
+    this.isCleaningUp = false;
+  }
+  getMetrics() {
+    return [...this.pool].map((instance) => ({
+      ...instance.metrics,
+      activePages: instance.pages.size,
+      isHealthy: instance.isHealthy
+    }));
+  }
+};
+
+// src/PlaywrightEngine.ts
+var import_p_queue2 = __toESM(require("p-queue"), 1);
+var import_axios = __toESM(require("axios"), 1);
+function delay(time) {
+  return new Promise((resolve) => setTimeout(resolve, time));
+}
+var PlaywrightEngine = class _PlaywrightEngine {
+  browserPool = null;
+  queue;
+  cache = /* @__PURE__ */ new Map();
+  config;
+  // Browser pooling safety flags
+  initializingBrowserPool = false;
+  isUsingHeadedMode = false;
+  // Tracks current pool mode
+  headedFallbackSites = /* @__PURE__ */ new Set();
+  // Stores domains marked for headed mode
+  // Default configuration - Ensure all required fields are present
+  static DEFAULT_CONFIG = {
+    concurrentPages: 3,
+    maxRetries: 3,
+    retryDelay: 5e3,
+    cacheTTL: 15 * 60 * 1e3,
+    useHttpFallback: true,
+    useHeadedModeFallback: false,
+    defaultFastMode: true,
+    simulateHumanBehavior: true,
+    maxBrowsers: 2,
+    maxPagesPerContext: 6,
+    maxBrowserAge: 20 * 60 * 1e3,
+    healthCheckInterval: 60 * 1e3,
+    poolBlockedDomains: [],
+    poolBlockedResourceTypes: [],
+    proxy: void 0,
+    useHeadedMode: false,
+    // ADDED default
+    markdown: true
+  };
+  /**
+   * Creates an instance of PlaywrightEngine.
+   *
+   * @param config Configuration options for the engine and its browser pool.
+   *               See `PlaywrightEngineConfig` for details.
+   */
+  constructor(config = {}) {
+    this.config = { ..._PlaywrightEngine.DEFAULT_CONFIG, ...config };
+    this.queue = new import_p_queue2.default({ concurrency: this.config.concurrentPages });
+  }
+  /**
+   * Initialize the browser pool with improved error handling and mode switching.
+   */
+  async initializeBrowserPool(useHeadedMode = false) {
+    if (this.browserPool && this.isUsingHeadedMode === useHeadedMode) {
+      return;
+    }
+    if (this.initializingBrowserPool) {
+      while (this.initializingBrowserPool) {
+        await delay(100);
+      }
+      if (this.browserPool && this.isUsingHeadedMode === useHeadedMode) {
+        return;
+      }
+    }
+    this.initializingBrowserPool = true;
+    try {
+      if (this.browserPool && this.isUsingHeadedMode !== useHeadedMode) {
+        await this.browserPool.cleanup();
+        this.browserPool = null;
+      }
+      this.isUsingHeadedMode = useHeadedMode;
+      this.browserPool = new PlaywrightBrowserPool({
+        maxBrowsers: this.config.maxBrowsers,
+        maxPagesPerContext: this.config.maxPagesPerContext,
+        maxBrowserAge: this.config.maxBrowserAge,
+        healthCheckInterval: this.config.healthCheckInterval,
+        useHeadedMode,
+        blockedDomains: this.config.poolBlockedDomains,
+        blockedResourceTypes: this.config.poolBlockedResourceTypes,
+        proxy: this.config.proxy
+      });
+      await this.browserPool.initialize();
+    } catch (error) {
+      this.browserPool = null;
+      this.isUsingHeadedMode = false;
+      throw error;
+    } finally {
+      this.initializingBrowserPool = false;
+    }
+  }
+  /**
+   * Fallback method using simple HTTP requests via Axios.
+   * Ensures return type matches HTMLFetchResult.
+   */
+  async fetchHTMLWithHttpFallback(url) {
+    try {
+      const response = await import_axios.default.get(url, {
+        headers: {
+          // Use more standard browser-like headers
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+          "Accept-Language": "en-US,en;q=0.9",
+          "Accept-Encoding": "gzip, deflate, br",
+          // Allow compression
+          Referer: "https://www.google.com/",
+          // Common referer
+          "Upgrade-Insecure-Requests": "1",
+          "Sec-Ch-Ua": '"Not A(Brand";v="99", "Google Chrome";v="121", "Chromium";v="121"',
+          "Sec-Ch-Ua-Mobile": "?0",
+          "Sec-Ch-Ua-Platform": '"Windows"',
+          "Sec-Fetch-Dest": "document",
+          "Sec-Fetch-Mode": "navigate",
+          "Sec-Fetch-Site": "cross-site",
+          "Sec-Fetch-User": "?1",
+          Connection: "keep-alive"
+          // Keep connection open
+          // Avoid Cache-Control/Pragma unless specifically needed
+        },
+        maxRedirects: 5,
+        timeout: 3e4,
+        responseType: "text",
+        // Decompress response automatically
+        decompress: true
+      });
+      const titleMatch = response.data.match(/<title[^>]*>([^<]+)<\/title>/i);
+      let title = titleMatch ? titleMatch[1].trim() : "";
+      if (!title && /<html>([^<]+)<\/html>/.test(response.data)) {
+        title = response.data.replace(/<\/?html>/g, "").trim();
+      }
+      const lowerHtml = response.data.toLowerCase();
+      const isChallengeOrBot = /cloudflare|checking your browser|please wait|verification|captcha|attention required/i.test(lowerHtml);
+      if (isChallengeOrBot) {
+        throw new FetchError("Received challenge page via HTTP fallback", "ERR_CHALLENGE_PAGE");
+      }
+      const originalHtml = response.data;
+      let finalContent = originalHtml;
+      let finalContentType = "html";
+      if (this.config.markdown) {
+        try {
+          const converter = new MarkdownConverter();
+          finalContent = converter.convert(originalHtml);
+          finalContentType = "markdown";
+        } catch (conversionError) {
+          console.error(`Markdown conversion failed for ${url} (HTTP fallback):`, conversionError);
+        }
+      }
+      return {
+        content: finalContent,
+        contentType: finalContentType,
+        title,
+        // title is extracted from original HTML
+        url: response.request?.res?.responseUrl || response.config.url || url,
+        isFromCache: false,
+        statusCode: response.status,
+        error: void 0
+      };
+    } catch (error) {
+      if (!(error instanceof FetchError)) {
+        throw new FetchError(`HTTP fallback failed: ${error.message}`, "ERR_HTTP_FALLBACK_FAILED", error);
+      }
+      throw error;
+    }
+  }
+  checkCache(url) {
+    const cached = this.cache.get(url);
+    if (cached && Date.now() - cached.timestamp < this.config.cacheTTL) {
+      return cached.result;
+    }
+    if (cached) {
+      this.cache.delete(url);
+    }
+    return null;
+  }
+  /**
+   * Safely check if a page is still usable and connected.
+   */
+  async isPageValid(page) {
+    if (!page || page.isClosed()) return false;
+    try {
+      if (!page.context().browser()?.isConnected()) return false;
+      await page.evaluate("1 + 1", { timeout: 1e3 });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Simulate human-like interactions on the page.
+   */
+  async simulateHumanBehavior(page) {
+    if (!await this.isPageValid(page)) return;
+    try {
+      const viewport = page.viewportSize();
+      if (!viewport) return;
+      await page.mouse.move(Math.random() * viewport.width, Math.random() * viewport.height / 3, { steps: 5 });
+      await delay(150 + Math.random() * 200);
+      await page.mouse.move(
+        Math.random() * viewport.width,
+        viewport.height / 2 + Math.random() * viewport.height / 2,
+        { steps: 10 }
+      );
+      await delay(200 + Math.random() * 300);
+      await page.evaluate(() => {
+        window.scrollBy({
+          top: window.innerHeight * (0.3 + Math.random() * 0.4),
+          behavior: "smooth"
+        });
+      });
+      await delay(400 + Math.random() * 600);
+      await page.evaluate(() => {
+        window.scrollBy({
+          top: window.innerHeight * (0.2 + Math.random() * 0.3),
+          behavior: "smooth"
+        });
+      });
+      await delay(300 + Math.random() * 400);
+    } catch (_error) {
+    }
+  }
+  /**
+   * Adds a result to the in-memory cache.
+   */
+  addToCache(url, result) {
+    if (this.config.cacheTTL <= 0) return;
+    const entry = {
+      result: { ...result, isFromCache: true },
+      // Mark as cached
+      timestamp: Date.now()
+    };
+    this.cache.set(url, entry);
+  }
+  /**
+   * Public method to fetch HTML. Delegates to the internal recursive fetch method.
+   *
+   * @param url The URL to fetch.
+   * @param options Optional settings for this specific fetch operation.
+   * @param options.fastMode Overrides the engine's `defaultFastMode` configuration for this request.
+   * @returns A Promise resolving to an HTMLFetchResult object.
+   * @throws {FetchError} If the fetch fails after all retries or encounters critical errors.
+   */
+  async fetchHTML(url, options = {}) {
+    const fetchConfig = {
+      ...this.config,
+      markdown: options.markdown === void 0 ? this.config.markdown : options.markdown,
+      fastMode: options.fastMode === void 0 ? this.config.defaultFastMode : options.fastMode
+    };
+    return this._fetchRecursive(url, fetchConfig, 0, 0);
+  }
+  /**
+   * Internal recursive method to handle fetching with retries.
+   *
+   * @param url URL to fetch
+   * @param currentConfig The merged configuration including markdown option
+   * @param retryAttempt Current retry attempt number (starts at 0)
+   * @param parentRetryCount Tracks retries related to pool initialization errors (starts at 0)
+   * @returns Promise resolving to HTMLFetchResult
+   */
+  async _fetchRecursive(url, currentConfig, retryAttempt, parentRetryCount) {
+    const useFastMode = currentConfig.fastMode;
+    if (retryAttempt === 0 && parentRetryCount === 0) {
+      const cachedResult = this.checkCache(url);
+      if (cachedResult) {
+        if (currentConfig.markdown && !cachedResult.content.startsWith("#") && !cachedResult.content.includes("\n\n---\n\n")) {
+          try {
+            const converter = new MarkdownConverter();
+            cachedResult.content = converter.convert(cachedResult.content);
+          } catch (e) {
+            console.error("Failed to convert cached result to markdown", e);
+          }
+        } else if (!currentConfig.markdown && (cachedResult.content.startsWith("#") || cachedResult.content.includes("\n\n---\n\n"))) {
+          console.warn("Cached result is Markdown, but HTML was requested. Re-fetching.");
+          this.cache.delete(url);
+          return this._fetchRecursive(url, currentConfig, 0, 0);
+        }
+        return cachedResult;
+      }
+    }
+    try {
+      if (currentConfig.useHttpFallback && retryAttempt === 0 && parentRetryCount === 0) {
+        try {
+          const httpResult = await this.fetchHTMLWithHttpFallback(url);
+          if (this.config.cacheTTL > 0) {
+            this.addToCache(url, httpResult);
+          }
+          return httpResult;
+        } catch (httpError) {
+          if (httpError instanceof FetchError && httpError.code === "ERR_CHALLENGE_PAGE") {
+          } else {
+          }
+        }
+      }
+      const useHeadedMode = currentConfig.useHeadedModeFallback && (retryAttempt >= 2 || this.shouldUseHeadedMode(url)) || currentConfig.useHeadedMode;
+      try {
+        if (!this.browserPool || this.isUsingHeadedMode !== useHeadedMode) {
+          await this.initializeBrowserPool(useHeadedMode);
+        }
+      } catch (initError) {
+        if (parentRetryCount < 1) {
+          await delay(currentConfig.retryDelay);
+          return this._fetchRecursive(url, currentConfig, retryAttempt, parentRetryCount + 1);
+        }
+        throw new FetchError(
+          `Pool init failed: ${initError.message}`,
+          "ERR_POOL_INIT_FAILED",
+          initError
+        );
+      }
+      if (!this.browserPool) {
+        throw new FetchError("Browser pool unavailable.", "ERR_POOL_UNAVAILABLE");
+      }
+      const result = await this.queue.add(
+        () => this.fetchWithPlaywright(url, this.browserPool, useFastMode, currentConfig.markdown)
+      );
+      if (result && this.config.cacheTTL > 0) {
+        this.addToCache(url, result);
+      }
+      if (!result) {
+        throw new FetchError("Playwright fetch queued but no result.", "ERR_QUEUE_NO_RESULT");
+      }
+      return result;
+    } catch (error) {
+      if (useFastMode && retryAttempt === 0 && parentRetryCount === 0) {
+        return this._fetchRecursive(url, { ...currentConfig, fastMode: false }, 0, parentRetryCount);
+      }
+      if (retryAttempt < currentConfig.maxRetries) {
+        await delay(currentConfig.retryDelay);
+        return this._fetchRecursive(url, currentConfig, retryAttempt + 1, parentRetryCount);
+      }
+      const finalError = error instanceof FetchError ? error : new FetchError(`Fetch failed: ${error.message}`, "ERR_FETCH_FAILED", error);
+      throw new FetchError(
+        `Fetch failed after ${currentConfig.maxRetries} retries: ${finalError.message}`,
+        finalError.code,
+        finalError.originalError || error
+      );
+    }
+  }
+  /**
+   * Performs the actual page fetch using a Playwright page from the pool.
+   * Ensures return type matches HTMLFetchResult.
+   */
+  async fetchWithPlaywright(url, pool, fastMode, convertToMarkdown) {
+    let page = null;
+    try {
+      page = await pool.acquirePage();
+      await this.applyBlockingRules(page, fastMode);
+      let response = null;
+      try {
+        response = await page.goto(url, {
+          waitUntil: "domcontentloaded",
+          timeout: 6e4
+        });
+      } catch (navigationError) {
+        throw new FetchError(
+          `Playwright navigation failed: ${navigationError.message}`,
+          "ERR_NAVIGATION",
+          navigationError
+        );
+      }
+      if (!response) {
+        throw new FetchError("Playwright navigation did not return a response.", "ERR_NO_RESPONSE");
+      }
+      if (!response.ok()) {
+        throw new FetchError(
+          `HTTP error status received: ${response.status()}`,
+          "ERR_HTTP_ERROR",
+          void 0,
+          response.status()
+        );
+      }
+      const contentType = response.headers()["content-type"] || "";
+      if (!contentType.includes("html")) {
+        throw new FetchError(`Invalid content type received: ${contentType}`, "ERR_NON_HTML_CONTENT");
+      }
+      if (!fastMode && this.config.simulateHumanBehavior) {
+        await this.simulateHumanBehavior(page);
+      }
+      const html = await page.content();
+      const title = await page.title();
+      const finalUrl = page.url();
+      const status = response?.status();
+      let finalContent = html;
+      let finalContentType = "html";
+      if (convertToMarkdown) {
+        try {
+          const converter = new MarkdownConverter();
+          finalContent = converter.convert(html);
+          finalContentType = "markdown";
+        } catch (conversionError) {
+          console.error(`Markdown conversion failed for ${url} (Playwright):`, conversionError);
+        }
+      }
+      return {
+        content: finalContent,
+        contentType: finalContentType,
+        title: title || null,
+        url: finalUrl,
+        isFromCache: false,
+        statusCode: status,
+        error: void 0
+      };
+    } finally {
+      if (page) {
+        await pool.releasePage(page);
+      }
+    }
+  }
+  async applyBlockingRules(page, fastMode) {
+    const blockedResources = fastMode ? this.config.poolBlockedResourceTypes.concat(["image", "font", "stylesheet", "media"]) : this.config.poolBlockedResourceTypes;
+    const blockedDomains = this.config.poolBlockedDomains;
+    if (blockedResources.length > 0 || blockedDomains.length > 0) {
+      try {
+        await page.route("**/*", (route) => {
+          const resourceType = route.request().resourceType();
+          const requestUrl = route.request().url();
+          if (blockedResources.includes(resourceType)) {
+            return route.abort();
+          }
+          if (blockedDomains.some(
+            (pattern) => new RegExp(pattern.replace(/\./g, "\\.").replace(/\*/g, ".*")).test(requestUrl)
+          )) {
+            return route.abort();
+          }
+          return route.continue();
+        });
+      } catch (_error) {
+      }
+    }
+  }
+  /**
+   * Cleans up resources used by the engine, primarily closing browser instances in the pool.
+   *
+   * It is crucial to call this method when finished with the engine instance to release resources.
+   * @returns A Promise that resolves when cleanup is complete.
+   */
+  async cleanup() {
+    try {
+      await this.queue.onIdle();
+      this.queue.clear();
+      if (this.browserPool) {
+        await this.browserPool.cleanup();
+        this.browserPool = null;
+      }
+      this.isUsingHeadedMode = false;
+    } catch (_error) {
+    }
+  }
+  /**
+   * Retrieves metrics from the underlying browser pool.
+   * @returns An array of BrowserMetrics objects, one for each active browser instance, or an empty array if the pool is not initialized.
+   */
+  getMetrics() {
+    if (this.browserPool) {
+      return this.browserPool.getMetrics();
+    }
+    return [];
+  }
+  // Helper to check if a specific domain is marked for headed mode
+  shouldUseHeadedMode(url) {
+    if (!this.config.useHeadedModeFallback) return false;
+    try {
+      const domain = new URL(url).hostname;
+      return this.headedFallbackSites.has(domain);
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/HybridEngine.ts
+init_cjs_shims();
+var HybridEngine = class {
+  fetchEngine;
+  playwrightEngine;
+  config;
+  // Store config for potential per-request PW overrides
+  constructor(config = {}) {
+    this.fetchEngine = new FetchEngine({ markdown: config.markdown });
+    this.playwrightEngine = new PlaywrightEngine(config);
+    this.config = config;
+  }
+  async fetchHTML(url, options = {}) {
+    try {
+      const fetchResult = await this.fetchEngine.fetchHTML(url);
+      return fetchResult;
+    } catch (fetchError) {
+      console.warn(`FetchEngine failed for ${url}: ${fetchError.message}. Falling back to PlaywrightEngine.`);
+      const playwrightOptions = {
+        ...this.config,
+        // Start with base config given to HybridEngine
+        ...options
+        // Override with per-request options
+      };
+      try {
+        const playwrightResult = await this.playwrightEngine.fetchHTML(url, playwrightOptions);
+        return playwrightResult;
+      } catch (playwrightError) {
+        console.error(`PlaywrightEngine fallback failed for ${url}: ${playwrightError.message}`);
+        throw playwrightError;
+      }
+    }
+  }
+  /**
+   * Delegates getMetrics to the PlaywrightEngine.
+   */
+  getMetrics() {
+    return this.playwrightEngine.getMetrics();
+  }
+  /**
+   * Calls cleanup on both underlying engines.
+   */
+  async cleanup() {
+    await Promise.allSettled([
+      this.fetchEngine.cleanup(),
+      // Although a no-op, call for consistency
+      this.playwrightEngine.cleanup()
+    ]);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FetchEngine,
+  HybridEngine,
+  PlaywrightEngine
+});
+/*! Bundled license information:
+
+for-in/index.js:
+  (*!
+   * for-in <https://github.com/jonschlinkert/for-in>
+   *
+   * Copyright (c) 2014-2017, Jon Schlinkert.
+   * Released under the MIT License.
+   *)
+
+for-own/index.js:
+  (*!
+   * for-own <https://github.com/jonschlinkert/for-own>
+   *
+   * Copyright (c) 2014-2017, Jon Schlinkert.
+   * Released under the MIT License.
+   *)
+
+is-buffer/index.js:
+  (*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+
+merge-deep/index.js:
+  (*!
+   * merge-deep <https://github.com/jonschlinkert/merge-deep>
+   *
+   * Copyright (c) 2014-2015, Jon Schlinkert.
+   * Licensed under the MIT License.
+   *)
+
+puppeteer-extra-plugin/dist/index.esm.js:
+  (*!
+   * puppeteer-extra-plugin v3.2.2 by berstend
+   * https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra-plugin
+   * @license MIT
+   *)
+*/
+//# sourceMappingURL=index.cjs.map