@absolutejs/rag 0.10.0 → 0.12.0

package/dist/web/playwright.js

@@ -0,0 +1,341 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/web/playwright.ts
+import { chromium } from "playwright-core";
+
+// src/web/transport.ts
+import { lookup } from "dns/promises";
+import { isIP } from "net";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+import { brotliDecompressSync, gunzipSync, inflateSync } from "zlib";
+
+class WebReadError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "WebReadError";
+  }
+}
+var isPublicWebAddress = (address) => {
+  if (isIP(address) === 4) {
+    const [a = 0, b = 0, c = 0] = address.split(".").map(Number);
+    return !(a === 0 || a === 10 || a === 127 || a >= 224 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && (b === 168 || b === 0 || b === 88 && c === 99) || a === 198 && (b === 18 || b === 19 || b === 51 && c === 100) || a === 203 && b === 0 && c === 113);
+  }
+  const value = address.toLowerCase();
+  return isIP(value) === 6 && /^[23]/u.test(value) && !/^2001:(?:db8|0):/u.test(value) && !value.startsWith("2002:");
+};
+var validatePublicWebUrl = (raw) => {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new WebReadError("invalid_url", "Provide a valid public HTTP or HTTPS URL.");
+  }
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.port && !["80", "443"].includes(url.port))
+    throw new WebReadError("blocked_url", "Only public HTTP/HTTPS URLs on standard ports are supported.");
+  const host = url.hostname.replace(/^\[|\]$/gu, "").toLowerCase();
+  if (host === "localhost" || /\.(?:localhost|local|internal)$/u.test(host) || isIP(host) && !isPublicWebAddress(host))
+    throw new WebReadError("blocked_url", "Private and local network destinations are not allowed.");
+  return url;
+};
+var fetchPublicWebResource = async (raw, options = {}) => {
+  const signal = options.signal ?? AbortSignal.timeout(15000);
+  const maxBytes = options.maxBytes ?? 5000000;
+  let url = validatePublicWebUrl(raw);
+  const redirects = [];
+  let method = options.method ?? "GET";
+  let body = options.body;
+  for (let hop = 0;hop <= 5; hop++) {
+    signal.throwIfAborted();
+    const host = url.hostname.replace(/^\[|\]$/gu, "");
+    const addresses = await lookup(host, { all: true });
+    if (!addresses.length || addresses.some(({ address }) => !isPublicWebAddress(address)))
+      throw new WebReadError("blocked_url", "The destination resolved to a private or reserved network.");
+    signal.throwIfAborted();
+    const selected = addresses.find(({ family }) => family === 4) ?? addresses[0];
+    const response = await new Promise((resolve, reject) => {
+      const request = url.protocol === "https:" ? httpsRequest : httpRequest;
+      const req = request({
+        protocol: url.protocol,
+        hostname: selected.address,
+        family: selected.family,
+        servername: isIP(host) ? undefined : host,
+        port: url.port || undefined,
+        path: url.pathname + url.search,
+        method,
+        signal,
+        agent: false,
+        headers: {
+          "user-agent": "onSparkReader/1.0 (+https://onspark.com)",
+          accept: "*/*",
+          "accept-encoding": "identity",
+          ...options.headers,
+          host: url.host
+        }
+      }, (res) => {
+        const chunks = [];
+        let bytes = 0;
+        res.on("error", reject);
+        res.on("data", (chunk) => {
+          bytes += chunk.length;
+          if (bytes > maxBytes) {
+            const error = new WebReadError("too_large", "The response exceeded the website read limit.");
+            res.destroy(error);
+            reject(error);
+          } else
+            chunks.push(chunk);
+        });
+        res.on("end", () => {
+          try {
+            let data = Buffer.concat(chunks);
+            const encoding = res.headers["content-encoding"];
+            const limits = { maxOutputLength: maxBytes };
+            if (encoding === "gzip")
+              data = gunzipSync(data, limits);
+            else if (encoding === "br")
+              data = brotliDecompressSync(data, limits);
+            else if (encoding === "deflate")
+              data = inflateSync(data, limits);
+            const headers = Object.fromEntries(Object.entries(res.headers).filter(([key]) => ![
+              "content-encoding",
+              "content-length",
+              "transfer-encoding",
+              "set-cookie"
+            ].includes(key)).map(([key, value]) => [
+              key,
+              Array.isArray(value) ? value.join(", ") : value ?? ""
+            ]));
+            resolve({
+              url: url.href,
+              status: res.statusCode ?? 502,
+              headers,
+              body: data
+            });
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+      req.on("error", reject);
+      if (body)
+        req.write(body);
+      req.end();
+    });
+    if (options.redirect === "manual")
+      return response;
+    if ([301, 302, 303, 307, 308].includes(response.status) && response.headers.location) {
+      const next = validatePublicWebUrl(new URL(response.headers.location, url).href);
+      redirects.push({
+        from: url.href,
+        to: next.href,
+        kind: "http",
+        status: response.status
+      });
+      url = next;
+      if (response.status === 303 || [301, 302].includes(response.status) && method === "POST") {
+        method = "GET";
+        body = undefined;
+      }
+      continue;
+    }
+    return { ...response, redirects };
+  }
+  throw new WebReadError("redirect_limit", "The site exceeded the redirect limit.");
+};
+
+// src/web/playwright.ts
+var createPlaywrightWebRenderer = (options = {}) => {
+  let browser;
+  let launching;
+  const launch = async () => {
+    if (browser?.isConnected())
+      return browser;
+    launching ??= chromium.launch({
+      headless: true,
+      executablePath: options.executablePath,
+      args: ["--disable-dev-shm-usage"]
+    });
+    try {
+      browser = await launching;
+      return browser;
+    } finally {
+      launching = undefined;
+    }
+  };
+  const renderOnce = async (url, { signal }) => {
+    validatePublicWebUrl(url);
+    signal.throwIfAborted();
+    const instance = await launch();
+    const context = await instance.newContext({
+      serviceWorkers: "block",
+      acceptDownloads: false
+    });
+    const abort = () => {
+      context.close().catch(() => {});
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    const redirects = [];
+    let count = 0, bytes = 0;
+    try {
+      await context.routeWebSocket("**/*", (socket) => socket.close());
+      await context.route("**/*", async (route) => {
+        const request = route.request();
+        try {
+          if (++count > 80 || bytes > 20000000 || ["image", "media", "font"].includes(request.resourceType()))
+            return await route.abort();
+          const body = request.postData() ?? undefined;
+          if (body && body.length > 1e5)
+            return await route.abort();
+          const original = request.headers();
+          const headers = {};
+          for (const key of ["accept", "content-type", "origin", "user-agent"])
+            if (original[key])
+              headers[key] = original[key];
+          const response2 = await fetchPublicWebResource(request.url(), {
+            signal,
+            maxBytes: 5000000,
+            method: request.method(),
+            body,
+            headers,
+            redirect: "manual"
+          });
+          if (request.isNavigationRequest() && request.frame() === context.pages()[0]?.mainFrame() && [301, 302, 303, 307, 308].includes(response2.status) && response2.headers.location) {
+            redirects.push({
+              from: request.url(),
+              to: new URL(response2.headers.location, request.url()).href,
+              kind: "http",
+              status: response2.status
+            });
+          }
+          bytes += response2.body.byteLength;
+          await route.fulfill({
+            status: response2.status,
+            headers: response2.headers,
+            body: Buffer.from(response2.body)
+          });
+        } catch {
+          await route.abort().catch(() => {});
+        }
+      });
+      const page = await context.newPage();
+      let previousUrl = url;
+      page.on("framenavigated", (frame) => {
+        if (frame !== page.mainFrame() || !/^https?:/u.test(frame.url()))
+          return;
+        const next = frame.url();
+        if (next !== previousUrl && !redirects.some((hop) => hop.to === next))
+          redirects.push({ from: previousUrl, to: next, kind: "client" });
+        previousUrl = next;
+      });
+      const response = await page.goto(url, {
+        waitUntil: "domcontentloaded",
+        timeout: 25000
+      });
+      const settled = await page.waitForFunction(() => {
+        const root = document.querySelector("#root,#app,#__next,app-root,[ng-version]");
+        const rootText = root?.textContent?.trim() ?? "";
+        return document.body.innerText.trim().length > 100 && (!root || rootText.length > 20 && !/^(loading|please wait)/i.test(rootText));
+      }, undefined, { timeout: 8000 }).then(() => true, () => false);
+      await page.waitForTimeout(1200);
+      for (let step = 0;step < 3; step++) {
+        await page.evaluate(() => window.scrollBy(0, window.innerHeight));
+        await page.waitForTimeout(350);
+      }
+      await page.evaluate(() => {
+        document.querySelectorAll("details").forEach((element) => {
+          element.open = true;
+        });
+        window.scrollTo(0, 0);
+      });
+      signal.throwIfAborted();
+      const html = await page.content();
+      if (html.length > 5000000)
+        throw new WebReadError("too_large", "Rendered page exceeded the content limit.");
+      return {
+        html,
+        redirects,
+        settled,
+        text: await page.locator("body").innerText(),
+        url: page.url(),
+        status: response?.status() ?? 200
+      };
+    } finally {
+      signal.removeEventListener("abort", abort);
+      await context.close().catch(() => {});
+    }
+  };
+  const render = async (url, options2) => {
+    try {
+      return await renderOnce(url, options2);
+    } catch (error) {
+      if (options2.signal.aborted || browser?.isConnected())
+        throw error;
+      return renderOnce(url, options2);
+    }
+  };
+  return {
+    render,
+    ready: async () => {
+      await launch();
+    },
+    close: async () => {
+      await browser?.close();
+      browser = undefined;
+    }
+  };
+};
+export {
+  createPlaywrightWebRenderer
+};
+
+//# debugId=7A89F48E5D741A4264756E2164756E21
+//# sourceMappingURL=playwright.js.map

package/dist/web/playwright.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/web/playwright.ts", "../src/web/transport.ts"],
+  "sourcesContent": [
+    "import { chromium, type Browser } from \"playwright-core\";\nimport {\n  fetchPublicWebResource,\n  validatePublicWebUrl,\n  WebReadError,\n} from \"./transport\";\nimport type { WebRedirect } from \"./transport\";\nimport type { WebRenderer } from \"./index\";\n/** Fresh contexts share a browser, never cookies; all HTTP traffic uses pinned public DNS. */\nexport const createPlaywrightWebRenderer = (\n  options: { executablePath?: string } = {},\n) => {\n  let browser: Browser | undefined;\n  let launching: Promise<Browser> | undefined;\n  const launch = async () => {\n    if (browser?.isConnected()) return browser;\n    launching ??= chromium.launch({\n      headless: true,\n      executablePath: options.executablePath,\n      args: [\"--disable-dev-shm-usage\"],\n    });\n    try {\n      browser = await launching;\n      return browser;\n    } finally {\n      launching = undefined;\n    }\n  };\n  const renderOnce: WebRenderer = async (url, { signal }) => {\n    validatePublicWebUrl(url);\n    signal.throwIfAborted();\n    const instance = await launch();\n    const context = await instance.newContext({\n      serviceWorkers: \"block\",\n      acceptDownloads: false,\n    });\n    const abort = () => {\n      void context.close().catch(() => {});\n    };\n    signal.addEventListener(\"abort\", abort, { once: true });\n    const redirects: WebRedirect[] = [];\n    let count = 0,\n      bytes = 0;\n    try {\n      await context.routeWebSocket(\"**/*\", (socket) => socket.close());\n      await context.route(\"**/*\", async (route) => {\n        const request = route.request();\n        try {\n          if (\n            ++count > 80 ||\n            bytes > 20_000_000 ||\n            [\"image\", \"media\", \"font\"].includes(request.resourceType())\n          )\n            return await route.abort();\n          const body = request.postData() ?? undefined;\n          if (body && body.length > 100_000) return await route.abort();\n          const original = request.headers();\n          const headers: Record<string, string> = {};\n          for (const key of [\"accept\", \"content-type\", \"origin\", \"user-agent\"])\n            if (original[key]) headers[key] = original[key];\n          const response = await fetchPublicWebResource(request.url(), {\n            signal,\n            maxBytes: 5_000_000,\n            method: request.method(),\n            body,\n            headers,\n            redirect: \"manual\",\n          });\n          if (\n            request.isNavigationRequest() &&\n            request.frame() === context.pages()[0]?.mainFrame() &&\n            [301, 302, 303, 307, 308].includes(response.status) &&\n            response.headers.location\n          ) {\n            redirects.push({\n              from: request.url(),\n              to: new URL(response.headers.location, request.url()).href,\n              kind: \"http\",\n              status: response.status,\n            });\n          }\n          bytes += response.body.byteLength;\n          await route.fulfill({\n            status: response.status,\n            headers: response.headers,\n            body: Buffer.from(response.body),\n          });\n        } catch {\n          await route.abort().catch(() => {});\n        }\n      });\n      const page = await context.newPage();\n      let previousUrl = url;\n      page.on(\"framenavigated\", (frame) => {\n        if (frame !== page.mainFrame() || !/^https?:/u.test(frame.url()))\n          return;\n        const next = frame.url();\n        if (next !== previousUrl && !redirects.some((hop) => hop.to === next))\n          redirects.push({ from: previousUrl, to: next, kind: \"client\" });\n        previousUrl = next;\n      });\n      const response = await page.goto(url, {\n        waitUntil: \"domcontentloaded\",\n        timeout: 25000,\n      });\n      const settled = await page\n        .waitForFunction(\n          () => {\n            const root = document.querySelector(\n              \"#root,#app,#__next,app-root,[ng-version]\",\n            );\n            const rootText = root?.textContent?.trim() ?? \"\";\n            return (\n              document.body.innerText.trim().length > 100 &&\n              (!root ||\n                (rootText.length > 20 &&\n                  !/^(loading|please wait)/i.test(rootText)))\n            );\n          },\n          undefined,\n          { timeout: 8000 },\n        )\n        .then(\n          () => true,\n          () => false,\n        );\n      // Allow hydration and async content to settle after the first readable frame.\n      await page.waitForTimeout(1200);\n      // Bounded scrolling exposes common lazy-loaded sections without clicking actions.\n      for (let step = 0; step < 3; step++) {\n        await page.evaluate(() => window.scrollBy(0, window.innerHeight));\n        await page.waitForTimeout(350);\n      }\n      await page.evaluate(() => {\n        document.querySelectorAll(\"details\").forEach((element) => {\n          element.open = true;\n        });\n        window.scrollTo(0, 0);\n      });\n      signal.throwIfAborted();\n      const html = await page.content();\n      if (html.length > 5_000_000)\n        throw new WebReadError(\n          \"too_large\",\n          \"Rendered page exceeded the content limit.\",\n        );\n      return {\n        html,\n        redirects,\n        settled,\n        text: await page.locator(\"body\").innerText(),\n        url: page.url(),\n        status: response?.status() ?? 200,\n      };\n    } finally {\n      signal.removeEventListener(\"abort\", abort);\n      await context.close().catch(() => {});\n    }\n  };\n  const render: WebRenderer = async (url, options) => {\n    try {\n      return await renderOnce(url, options);\n    } catch (error) {\n      if (options.signal.aborted || browser?.isConnected()) throw error;\n      // A crashed worker may be replaced once; the same total deadline still applies.\n      return renderOnce(url, options);\n    }\n  };\n  return {\n    render,\n    ready: async () => {\n      await launch();\n    },\n    close: async () => {\n      await browser?.close();\n      browser = undefined;\n    },\n  };\n};\n",
+    "import { lookup } from \"node:dns/promises\";\nimport { isIP } from \"node:net\";\nimport { request as httpRequest } from \"node:http\";\nimport { request as httpsRequest } from \"node:https\";\nimport { brotliDecompressSync, gunzipSync, inflateSync } from \"node:zlib\";\n\nexport class WebReadError extends Error {\n  constructor(\n    public code: string,\n    message: string,\n  ) {\n    super(message);\n    this.name = \"WebReadError\";\n  }\n}\nexport const isPublicWebAddress = (address: string) => {\n  if (isIP(address) === 4) {\n    const [a = 0, b = 0, c = 0] = address.split(\".\").map(Number);\n    return !(\n      a === 0 ||\n      a === 10 ||\n      a === 127 ||\n      a >= 224 ||\n      (a === 100 && b >= 64 && b <= 127) ||\n      (a === 169 && b === 254) ||\n      (a === 172 && b >= 16 && b <= 31) ||\n      (a === 192 && (b === 168 || b === 0 || (b === 88 && c === 99))) ||\n      (a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100))) ||\n      (a === 203 && b === 0 && c === 113)\n    );\n  }\n  const value = address.toLowerCase();\n  return (\n    isIP(value) === 6 &&\n    /^[23]/u.test(value) &&\n    !/^2001:(?:db8|0):/u.test(value) &&\n    !value.startsWith(\"2002:\")\n  );\n};\nexport type WebRedirect = {\n  from: string;\n  to: string;\n  kind: \"http\" | \"client\";\n  status?: number;\n};\nexport type WebFetchResult = {\n  redirects?: WebRedirect[];\n  url: string;\n  status: number;\n  headers: Record<string, string>;\n  body: Uint8Array;\n};\nexport type WebFetchOptions = {\n  signal?: AbortSignal;\n  redirect?: \"follow\" | \"manual\";\n  maxBytes?: number;\n  method?: string;\n  body?: string;\n  headers?: Record<string, string>;\n};\nexport const validatePublicWebUrl = (raw: string) => {\n  let url: URL;\n  try {\n    url = new URL(raw);\n  } catch {\n    throw new WebReadError(\n      \"invalid_url\",\n      \"Provide a valid public HTTP or HTTPS URL.\",\n    );\n  }\n  if (\n    ![\"http:\", \"https:\"].includes(url.protocol) ||\n    url.username ||\n    url.password ||\n    (url.port && ![\"80\", \"443\"].includes(url.port))\n  )\n    throw new WebReadError(\n      \"blocked_url\",\n      \"Only public HTTP/HTTPS URLs on standard ports are supported.\",\n    );\n  const host = url.hostname.replace(/^\\[|\\]$/gu, \"\").toLowerCase();\n  if (\n    host === \"localhost\" ||\n    /\\.(?:localhost|local|internal)$/u.test(host) ||\n    (isIP(host) && !isPublicWebAddress(host))\n  )\n    throw new WebReadError(\n      \"blocked_url\",\n      \"Private and local network destinations are not allowed.\",\n    );\n  return url;\n};\n/** Pin the validated DNS answer into the connection, including every redirect. */\nexport const fetchPublicWebResource = async (\n  raw: string,\n  options: WebFetchOptions = {},\n): Promise<WebFetchResult> => {\n  const signal = options.signal ?? AbortSignal.timeout(15000);\n  const maxBytes = options.maxBytes ?? 5_000_000;\n  let url = validatePublicWebUrl(raw);\n  const redirects: WebRedirect[] = [];\n  let method = options.method ?? \"GET\";\n  let body = options.body;\n  for (let hop = 0; hop <= 5; hop++) {\n    signal.throwIfAborted();\n    const host = url.hostname.replace(/^\\[|\\]$/gu, \"\");\n    const addresses = await lookup(host, { all: true });\n    if (\n      !addresses.length ||\n      addresses.some(({ address }) => !isPublicWebAddress(address))\n    )\n      throw new WebReadError(\n        \"blocked_url\",\n        \"The destination resolved to a private or reserved network.\",\n      );\n    signal.throwIfAborted();\n    const selected =\n      addresses.find(({ family }) => family === 4) ?? addresses[0]!;\n    const response = await new Promise<WebFetchResult>((resolve, reject) => {\n      const request = url.protocol === \"https:\" ? httpsRequest : httpRequest;\n      const req = request(\n        {\n          protocol: url.protocol,\n          hostname: selected.address,\n          family: selected.family,\n          servername: isIP(host) ? undefined : host,\n          port: url.port || undefined,\n          path: url.pathname + url.search,\n          method,\n          signal,\n          agent: false,\n          headers: {\n            \"user-agent\": \"onSparkReader/1.0 (+https://onspark.com)\",\n            accept: \"*/*\",\n            \"accept-encoding\": \"identity\",\n            ...options.headers,\n            host: url.host,\n          },\n        },\n        (res) => {\n          const chunks: Buffer[] = [];\n          let bytes = 0;\n          res.on(\"error\", reject);\n          res.on(\"data\", (chunk: Buffer) => {\n            bytes += chunk.length;\n            if (bytes > maxBytes) {\n              const error = new WebReadError(\n                \"too_large\",\n                \"The response exceeded the website read limit.\",\n              );\n              res.destroy(error);\n              reject(error);\n            } else chunks.push(chunk);\n          });\n          res.on(\"end\", () => {\n            try {\n              let data: Uint8Array = Buffer.concat(chunks);\n              const encoding = res.headers[\"content-encoding\"];\n              const limits = { maxOutputLength: maxBytes };\n              if (encoding === \"gzip\") data = gunzipSync(data, limits);\n              else if (encoding === \"br\")\n                data = brotliDecompressSync(data, limits);\n              else if (encoding === \"deflate\") data = inflateSync(data, limits);\n              const headers = Object.fromEntries(\n                Object.entries(res.headers)\n                  .filter(\n                    ([key]) =>\n                      ![\n                        \"content-encoding\",\n                        \"content-length\",\n                        \"transfer-encoding\",\n                        \"set-cookie\",\n                      ].includes(key),\n                  )\n                  .map(([key, value]) => [\n                    key,\n                    Array.isArray(value) ? value.join(\", \") : (value ?? \"\"),\n                  ]),\n              );\n              resolve({\n                url: url.href,\n                status: res.statusCode ?? 502,\n                headers,\n                body: data,\n              });\n            } catch (error) {\n              reject(error);\n            }\n          });\n        },\n      );\n      req.on(\"error\", reject);\n      if (body) req.write(body);\n      req.end();\n    });\n    if (options.redirect === \"manual\") return response;\n    if (\n      [301, 302, 303, 307, 308].includes(response.status) &&\n      response.headers.location\n    ) {\n      const next = validatePublicWebUrl(\n        new URL(response.headers.location, url).href,\n      );\n      redirects.push({\n        from: url.href,\n        to: next.href,\n        kind: \"http\",\n        status: response.status,\n      });\n      url = next;\n      if (\n        response.status === 303 ||\n        ([301, 302].includes(response.status) && method === \"POST\")\n      ) {\n        method = \"GET\";\n        body = undefined;\n      }\n      continue;\n    }\n    return { ...response, redirects };\n  }\n  throw new WebReadError(\n    \"redirect_limit\",\n    \"The site exceeded the redirect limit.\",\n  );\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;ACAA;AACA;AACA,oBAAS;AACT,oBAAS;AACT;AAAA;AAEO,MAAM,qBAAqB,MAAM;AAAA,EAE7B;AAAA,EADT,WAAW,CACF,MACP,SACA;AAAA,IACA,MAAM,OAAO;AAAA,IAHN;AAAA,IAIP,KAAK,OAAO;AAAA;AAEhB;AACO,IAAM,qBAAqB,CAAC,YAAoB;AAAA,EACrD,IAAI,KAAK,OAAO,MAAM,GAAG;AAAA,IACvB,OAAO,IAAI,GAAG,IAAI,GAAG,IAAI,KAAK,QAAQ,MAAM,GAAG,EAAE,IAAI,MAAM;AAAA,IAC3D,OAAO,EACL,MAAM,KACN,MAAM,MACN,MAAM,OACN,KAAK,OACJ,MAAM,OAAO,KAAK,MAAM,KAAK,OAC7B,MAAM,OAAO,MAAM,OACnB,MAAM,OAAO,KAAK,MAAM,KAAK,MAC7B,MAAM,QAAQ,MAAM,OAAO,MAAM,KAAM,MAAM,MAAM,MAAM,OACzD,MAAM,QAAQ,MAAM,MAAM,MAAM,MAAO,MAAM,MAAM,MAAM,QACzD,MAAM,OAAO,MAAM,KAAK,MAAM;AAAA,EAEnC;AAAA,EACA,MAAM,QAAQ,QAAQ,YAAY;AAAA,EAClC,OACE,KAAK,KAAK,MAAM,KAChB,SAAS,KAAK,KAAK,KACnB,CAAC,oBAAoB,KAAK,KAAK,KAC/B,CAAC,MAAM,WAAW,OAAO;AAAA;AAwBtB,IAAM,uBAAuB,CAAC,QAAgB;AAAA,EACnD,IAAI;AAAA,EACJ,IAAI;AAAA,IACF,MAAM,IAAI,IAAI,GAAG;AAAA,IACjB,MAAM;AAAA,IACN,MAAM,IAAI,aACR,eACA,2CACF;AAAA;AAAA,EAEF,IACE,CAAC,CAAC,SAAS,QAAQ,EAAE,SAAS,IAAI,QAAQ,KAC1C,IAAI,YACJ,IAAI,YACH,IAAI,QAAQ,CAAC,CAAC,MAAM,KAAK,EAAE,SAAS,IAAI,IAAI;AAAA,IAE7C,MAAM,IAAI,aACR,eACA,8DACF;AAAA,EACF,MAAM,OAAO,IAAI,SAAS,QAAQ,aAAa,EAAE,EAAE,YAAY;AAAA,EAC/D,IACE,SAAS,eACT,mCAAmC,KAAK,IAAI,KAC3C,KAAK,IAAI,KAAK,CAAC,mBAAmB,IAAI;AAAA,IAEvC,MAAM,IAAI,aACR,eACA,yDACF;AAAA,EACF,OAAO;AAAA;AAGF,IAAM,yBAAyB,OACpC,KACA,UAA2B,CAAC,MACA;AAAA,EAC5B,MAAM,SAAS,QAAQ,UAAU,YAAY,QAAQ,KAAK;AAAA,EAC1D,MAAM,WAAW,QAAQ,YAAY;AAAA,EACrC,IAAI,MAAM,qBAAqB,GAAG;AAAA,EAClC,MAAM,YAA2B,CAAC;AAAA,EAClC,IAAI,SAAS,QAAQ,UAAU;AAAA,EAC/B,IAAI,OAAO,QAAQ;AAAA,EACnB,SAAS,MAAM,EAAG,OAAO,GAAG,OAAO;AAAA,IACjC,OAAO,eAAe;AAAA,IACtB,MAAM,OAAO,IAAI,SAAS,QAAQ,aAAa,EAAE;AAAA,IACjD,MAAM,YAAY,MAAM,OAAO,MAAM,EAAE,KAAK,KAAK,CAAC;AAAA,IAClD,IACE,CAAC,UAAU,UACX,UAAU,KAAK,GAAG,cAAc,CAAC,mBAAmB,OAAO,CAAC;AAAA,MAE5D,MAAM,IAAI,aACR,eACA,4DACF;AAAA,IACF,OAAO,eAAe;AAAA,IACtB,MAAM,WACJ,UAAU,KAAK,GAAG,aAAa,WAAW,CAAC,KAAK,UAAU;AAAA,IAC5D,MAAM,WAAW,MAAM,IAAI,QAAwB,CAAC,SAAS,WAAW;AAAA,MACtE,MAAM,UAAU,IAAI,aAAa,WAAW,eAAe;AAAA,MAC3D,MAAM,MAAM,QACV;AAAA,QACE,UAAU,IAAI;AAAA,QACd,UAAU,SAAS;AAAA,QACnB,QAAQ,SAAS;AAAA,QACjB,YAAY,KAAK,IAAI,IAAI,YAAY;AAAA,QACrC,MAAM,IAAI,QAAQ;AAAA,QAClB,MAAM,IAAI,WAAW,IAAI;AAAA,QACzB;AAAA,QACA;AAAA,QACA,OAAO;AAAA,QACP,SAAS;AAAA,UACP,cAAc;AAAA,UACd,QAAQ;AAAA,UACR,mBAAmB;AAAA,aAChB,QAAQ;AAAA,UACX,MAAM,IAAI;AAAA,QACZ;AAAA,MACF,GACA,CAAC,QAAQ;AAAA,QACP,MAAM,SAAmB,CAAC;AAAA,QAC1B,IAAI,QAAQ;AAAA,QACZ,IAAI,GAAG,SAAS,MAAM;AAAA,QACtB,IAAI,GAAG,QAAQ,CAAC,UAAkB;AAAA,UAChC,SAAS,MAAM;AAAA,UACf,IAAI,QAAQ,UAAU;AAAA,YACpB,MAAM,QAAQ,IAAI,aAChB,aACA,+CACF;AAAA,YACA,IAAI,QAAQ,KAAK;AAAA,YACjB,OAAO,KAAK;AAAA,UACd,EAAO;AAAA,mBAAO,KAAK,KAAK;AAAA,SACzB;AAAA,QACD,IAAI,GAAG,OAAO,MAAM;AAAA,UAClB,IAAI;AAAA,YACF,IAAI,OAAmB,OAAO,OAAO,MAAM;AAAA,YAC3C,MAAM,WAAW,IAAI,QAAQ;AAAA,YAC7B,MAAM,SAAS,EAAE,iBAAiB,SAAS;AAAA,YAC3C,IAAI,aAAa;AAAA,cAAQ,OAAO,WAAW,MAAM,MAAM;AAAA,YAClD,SAAI,aAAa;AAAA,cACpB,OAAO,qBAAqB,MAAM,MAAM;AAAA,YACrC,SAAI,aAAa;AAAA,cAAW,OAAO,YAAY,MAAM,MAAM;AAAA,YAChE,MAAM,UAAU,OAAO,YACrB,OAAO,QAAQ,IAAI,OAAO,EACvB,OACC,EAAE,SACA,CAAC;AAAA,cACC;AAAA,cACA;AAAA,cACA;AAAA,cACA;AAAA,YACF,EAAE,SAAS,GAAG,CAClB,EACC,IAAI,EAAE,KAAK,WAAW;AAAA,cACrB;AAAA,cACA,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK,IAAI,IAAK,SAAS;AAAA,YACtD,CAAC,CACL;AAAA,YACA,QAAQ;AAAA,cACN,KAAK,IAAI;AAAA,cACT,QAAQ,IAAI,cAAc;AAAA,cAC1B;AAAA,cACA,MAAM;AAAA,YACR,CAAC;AAAA,YACD,OAAO,OAAO;AAAA,YACd,OAAO,KAAK;AAAA;AAAA,SAEf;AAAA,OAEL;AAAA,MACA,IAAI,GAAG,SAAS,MAAM;AAAA,MACtB,IAAI;AAAA,QAAM,IAAI,MAAM,IAAI;AAAA,MACxB,IAAI,IAAI;AAAA,KACT;AAAA,IACD,IAAI,QAAQ,aAAa;AAAA,MAAU,OAAO;AAAA,IAC1C,IACE,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG,EAAE,SAAS,SAAS,MAAM,KAClD,SAAS,QAAQ,UACjB;AAAA,MACA,MAAM,OAAO,qBACX,IAAI,IAAI,SAAS,QAAQ,UAAU,GAAG,EAAE,IAC1C;AAAA,MACA,UAAU,KAAK;AAAA,QACb,MAAM,IAAI;AAAA,QACV,IAAI,KAAK;AAAA,QACT,MAAM;AAAA,QACN,QAAQ,SAAS;AAAA,MACnB,CAAC;AAAA,MACD,MAAM;AAAA,MACN,IACE,SAAS,WAAW,OACnB,CAAC,KAAK,GAAG,EAAE,SAAS,SAAS,MAAM,KAAK,WAAW,QACpD;AAAA,QACA,SAAS;AAAA,QACT,OAAO;AAAA,MACT;AAAA,MACA;AAAA,IACF;AAAA,IACA,OAAO,KAAK,UAAU,UAAU;AAAA,EAClC;AAAA,EACA,MAAM,IAAI,aACR,kBACA,uCACF;AAAA;;;ADvNK,IAAM,8BAA8B,CACzC,UAAuC,CAAC,MACrC;AAAA,EACH,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,MAAM,SAAS,YAAY;AAAA,IACzB,IAAI,SAAS,YAAY;AAAA,MAAG,OAAO;AAAA,IACnC,cAAc,SAAS,OAAO;AAAA,MAC5B,UAAU;AAAA,MACV,gBAAgB,QAAQ;AAAA,MACxB,MAAM,CAAC,yBAAyB;AAAA,IAClC,CAAC;AAAA,IACD,IAAI;AAAA,MACF,UAAU,MAAM;AAAA,MAChB,OAAO;AAAA,cACP;AAAA,MACA,YAAY;AAAA;AAAA;AAAA,EAGhB,MAAM,aAA0B,OAAO,OAAO,aAAa;AAAA,IACzD,qBAAqB,GAAG;AAAA,IACxB,OAAO,eAAe;AAAA,IACtB,MAAM,WAAW,MAAM,OAAO;AAAA,IAC9B,MAAM,UAAU,MAAM,SAAS,WAAW;AAAA,MACxC,gBAAgB;AAAA,MAChB,iBAAiB;AAAA,IACnB,CAAC;AAAA,IACD,MAAM,QAAQ,MAAM;AAAA,MACb,QAAQ,MAAM,EAAE,MAAM,MAAM,EAAE;AAAA;AAAA,IAErC,OAAO,iBAAiB,SAAS,OAAO,EAAE,MAAM,KAAK,CAAC;AAAA,IACtD,MAAM,YAA2B,CAAC;AAAA,IAClC,IAAI,QAAQ,GACV,QAAQ;AAAA,IACV,IAAI;AAAA,MACF,MAAM,QAAQ,eAAe,QAAQ,CAAC,WAAW,OAAO,MAAM,CAAC;AAAA,MAC/D,MAAM,QAAQ,MAAM,QAAQ,OAAO,UAAU;AAAA,QAC3C,MAAM,UAAU,MAAM,QAAQ;AAAA,QAC9B,IAAI;AAAA,UACF,IACE,EAAE,QAAQ,MACV,QAAQ,YACR,CAAC,SAAS,SAAS,MAAM,EAAE,SAAS,QAAQ,aAAa,CAAC;AAAA,YAE1D,OAAO,MAAM,MAAM,MAAM;AAAA,UAC3B,MAAM,OAAO,QAAQ,SAAS,KAAK;AAAA,UACnC,IAAI,QAAQ,KAAK,SAAS;AAAA,YAAS,OAAO,MAAM,MAAM,MAAM;AAAA,UAC5D,MAAM,WAAW,QAAQ,QAAQ;AAAA,UACjC,MAAM,UAAkC,CAAC;AAAA,UACzC,WAAW,OAAO,CAAC,UAAU,gBAAgB,UAAU,YAAY;AAAA,YACjE,IAAI,SAAS;AAAA,cAAM,QAAQ,OAAO,SAAS;AAAA,UAC7C,MAAM,YAAW,MAAM,uBAAuB,QAAQ,IAAI,GAAG;AAAA,YAC3D;AAAA,YACA,UAAU;AAAA,YACV,QAAQ,QAAQ,OAAO;AAAA,YACvB;AAAA,YACA;AAAA,YACA,UAAU;AAAA,UACZ,CAAC;AAAA,UACD,IACE,QAAQ,oBAAoB,KAC5B,QAAQ,MAAM,MAAM,QAAQ,MAAM,EAAE,IAAI,UAAU,KAClD,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG,EAAE,SAAS,UAAS,MAAM,KAClD,UAAS,QAAQ,UACjB;AAAA,YACA,UAAU,KAAK;AAAA,cACb,MAAM,QAAQ,IAAI;AAAA,cAClB,IAAI,IAAI,IAAI,UAAS,QAAQ,UAAU,QAAQ,IAAI,CAAC,EAAE;AAAA,cACtD,MAAM;AAAA,cACN,QAAQ,UAAS;AAAA,YACnB,CAAC;AAAA,UACH;AAAA,UACA,SAAS,UAAS,KAAK;AAAA,UACvB,MAAM,MAAM,QAAQ;AAAA,YAClB,QAAQ,UAAS;AAAA,YACjB,SAAS,UAAS;AAAA,YAClB,MAAM,OAAO,KAAK,UAAS,IAAI;AAAA,UACjC,CAAC;AAAA,UACD,MAAM;AAAA,UACN,MAAM,MAAM,MAAM,EAAE,MAAM,MAAM,EAAE;AAAA;AAAA,OAErC;AAAA,MACD,MAAM,OAAO,MAAM,QAAQ,QAAQ;AAAA,MACnC,IAAI,cAAc;AAAA,MAClB,KAAK,GAAG,kBAAkB,CAAC,UAAU;AAAA,QACnC,IAAI,UAAU,KAAK,UAAU,KAAK,CAAC,YAAY,KAAK,MAAM,IAAI,CAAC;AAAA,UAC7D;AAAA,QACF,MAAM,OAAO,MAAM,IAAI;AAAA,QACvB,IAAI,SAAS,eAAe,CAAC,UAAU,KAAK,CAAC,QAAQ,IAAI,OAAO,IAAI;AAAA,UAClE,UAAU,KAAK,EAAE,MAAM,aAAa,IAAI,MAAM,MAAM,SAAS,CAAC;AAAA,QAChE,cAAc;AAAA,OACf;AAAA,MACD,MAAM,WAAW,MAAM,KAAK,KAAK,KAAK;AAAA,QACpC,WAAW;AAAA,QACX,SAAS;AAAA,MACX,CAAC;AAAA,MACD,MAAM,UAAU,MAAM,KACnB,gBACC,MAAM;AAAA,QACJ,MAAM,OAAO,SAAS,cACpB,0CACF;AAAA,QACA,MAAM,WAAW,MAAM,aAAa,KAAK,KAAK;AAAA,QAC9C,OACE,SAAS,KAAK,UAAU,KAAK,EAAE,SAAS,QACvC,CAAC,QACC,SAAS,SAAS,MACjB,CAAC,0BAA0B,KAAK,QAAQ;AAAA,SAGhD,WACA,EAAE,SAAS,KAAK,CAClB,EACC,KACC,MAAM,MACN,MAAM,KACR;AAAA,MAEF,MAAM,KAAK,eAAe,IAAI;AAAA,MAE9B,SAAS,OAAO,EAAG,OAAO,GAAG,QAAQ;AAAA,QACnC,MAAM,KAAK,SAAS,MAAM,OAAO,SAAS,GAAG,OAAO,WAAW,CAAC;AAAA,QAChE,MAAM,KAAK,eAAe,GAAG;AAAA,MAC/B;AAAA,MACA,MAAM,KAAK,SAAS,MAAM;AAAA,QACxB,SAAS,iBAAiB,SAAS,EAAE,QAAQ,CAAC,YAAY;AAAA,UACxD,QAAQ,OAAO;AAAA,SAChB;AAAA,QACD,OAAO,SAAS,GAAG,CAAC;AAAA,OACrB;AAAA,MACD,OAAO,eAAe;AAAA,MACtB,MAAM,OAAO,MAAM,KAAK,QAAQ;AAAA,MAChC,IAAI,KAAK,SAAS;AAAA,QAChB,MAAM,IAAI,aACR,aACA,2CACF;AAAA,MACF,OAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA,MAAM,MAAM,KAAK,QAAQ,MAAM,EAAE,UAAU;AAAA,QAC3C,KAAK,KAAK,IAAI;AAAA,QACd,QAAQ,UAAU,OAAO,KAAK;AAAA,MAChC;AAAA,cACA;AAAA,MACA,OAAO,oBAAoB,SAAS,KAAK;AAAA,MACzC,MAAM,QAAQ,MAAM,EAAE,MAAM,MAAM,EAAE;AAAA;AAAA;AAAA,EAGxC,MAAM,SAAsB,OAAO,KAAK,aAAY;AAAA,IAClD,IAAI;AAAA,MACF,OAAO,MAAM,WAAW,KAAK,QAAO;AAAA,MACpC,OAAO,OAAO;AAAA,MACd,IAAI,SAAQ,OAAO,WAAW,SAAS,YAAY;AAAA,QAAG,MAAM;AAAA,MAE5D,OAAO,WAAW,KAAK,QAAO;AAAA;AAAA;AAAA,EAGlC,OAAO;AAAA,IACL;AAAA,IACA,OAAO,YAAY;AAAA,MACjB,MAAM,OAAO;AAAA;AAAA,IAEf,OAAO,YAAY;AAAA,MACjB,MAAM,SAAS,MAAM;AAAA,MACrB,UAAU;AAAA;AAAA,EAEd;AAAA;",
+  "debugId": "7A89F48E5D741A4264756E2164756E21",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/rag",
-	"version": "0.10.0",
+	"version": "0.12.0",
 	"homepage": "https://github.com/absolutejs/rag",
 	"bugs": {
 		"url": "https://github.com/absolutejs/rag/issues"
@@ -61,14 +61,23 @@
 			"import": "./dist/manifest.js",
 			"types": "./dist/src/manifest.d.ts"
 		},
-		"./manifest.json": "./dist/manifest.json"
+		"./manifest.json": "./dist/manifest.json",
+		"./web": {
+			"import": "./dist/web/index.js",
+			"types": "./dist/src/web/index.d.ts"
+		},
+		"./web/playwright": {
+			"import": "./dist/web/playwright.js",
+			"types": "./dist/src/web/playwright.d.ts"
+		}
 	},
 	"absolutejs": {
 		"manifestContract": 2
 	},
 	"dependencies": {
 		"@absolutejs/manifest": "^0.9.0",
-		"@sinclair/typebox": "^0.34.0"
+		"@sinclair/typebox": "^0.34.0",
+		"linkedom": "0.18.13"
 	},
 	"peerDependencies": {
 		"@angular/core": "^21.0.0",
@@ -77,7 +86,8 @@
 		"svelte": "^5.35.2",
 		"vue": "^3.5.27",
 		"@absolutejs/sync": ">=2.14.0 <3",
-		"@absolutejs/ai": ">=0.0.54 <0.3"
+		"@absolutejs/ai": ">=0.0.54 <0.3",
+		"playwright-core": "^1.60.0"
 	},
 	"peerDependenciesMeta": {
 		"@angular/core": {
@@ -91,6 +101,9 @@
 		},
 		"vue": {
 			"optional": true
+		},
+		"playwright-core": {
+			"optional": true
 		}
 	},
 	"devDependencies": {
@@ -115,7 +128,8 @@
 		"svelte": "5.55.0",
 		"typescript": "5.9.3",
 		"typescript-eslint": "^8.56.1",
-		"vue": "3.5.27"
+		"vue": "3.5.27",
+		"playwright-core": "1.60.0"
 	},
 	"scripts": {
 		"build": "bun run scripts/build.ts && absolute-manifest emit",