@playwright-repl/browser-extension 0.24.0

package/dist/sw-debugger-core.js

@@ -0,0 +1,1139 @@
+async function verifyText(page, text) {
+  if (await page.getByText(text).filter({ visible: true }).count() === 0)
+    throw new Error("Text not found: " + text);
+}
+async function verifyElement(page, role, name) {
+  if (await page.getByRole(role, { name }).count() === 0)
+    throw new Error("Element not found: " + role + ' "' + name + '"');
+}
+async function verifyValue(page, ref, expected) {
+  const el = page.locator('[aria-ref="' + ref + '"]');
+  const v = await el.inputValue();
+  if (v !== expected)
+    throw new Error('Expected "' + expected + '", got "' + v + '"');
+}
+async function verifyList(page, ref, items) {
+  const loc = page.locator('[aria-ref="' + ref + '"]');
+  for (const item of items) {
+    if (await loc.getByText(item).count() === 0)
+      throw new Error("Item not found: " + item);
+  }
+}
+async function verifyTitle(page, text) {
+  const title = await page.title();
+  if (!title.includes(text))
+    throw new Error('Title "' + title + '" does not contain "' + text + '"');
+}
+async function verifyUrl(page, text) {
+  const url = page.url();
+  if (!url.includes(text))
+    throw new Error('URL "' + url + '" does not contain "' + text + '"');
+}
+async function waitForText(page, text) {
+  await page.getByText(text).first().waitFor({ state: "visible", timeout: 1e4 });
+}
+async function verifyNoText(page, text) {
+  if (await page.getByText(text).filter({ visible: true }).count() > 0)
+    throw new Error("Text still visible: " + text);
+}
+async function verifyNoElement(page, role, name) {
+  if (await page.getByRole(role, { name }).count() > 0)
+    throw new Error("Element still exists: " + role + ' "' + name + '"');
+}
+async function verifyVisible(page, role, name) {
+  if (!await page.getByRole(role, { name }).isVisible())
+    throw new Error("Element not visible: " + role + ' "' + name + '"');
+}
+async function verifyInputValue(page, label, expected) {
+  let loc = page.getByLabel(label);
+  if (await loc.count() === 0) loc = page.getByRole("spinbutton", { name: label });
+  if (await loc.count() === 0) loc = page.getByRole("textbox", { name: label });
+  if (await loc.count() === 0) loc = page.getByRole("combobox", { name: label });
+  if (await loc.count() > 0) {
+    const el = loc.first();
+    const inputType = await el.evaluate((e) => e instanceof HTMLInputElement ? e.type : "");
+    if (inputType === "checkbox") {
+      const isChecked = await el.isChecked();
+      const expectChecked = ["checked", "true", "yes", "1"].includes(expected.toLowerCase());
+      if (isChecked !== expectChecked)
+        throw new Error('Expected "' + label + '" to be ' + expected + ", but was " + (isChecked ? "checked" : "unchecked"));
+      return;
+    }
+    const value = await el.inputValue();
+    if (String(value) !== String(expected))
+      throw new Error('Expected "' + expected + '", got "' + value + '" for "' + label + '"');
+    return;
+  }
+  const group = page.getByRole("group", { name: label });
+  if (await group.count() > 0) {
+    const checkedRadio = group.locator("input[type=radio]:checked");
+    if (await checkedRadio.count() === 0)
+      throw new Error('No radio button selected in group "' + label + '"');
+    const value = await checkedRadio.evaluate((e) => {
+      const lbl = document.querySelector('label[for="' + e.id + '"]');
+      return lbl ? lbl.textContent.trim() : e.value;
+    });
+    if (value !== expected)
+      throw new Error('Expected "' + expected + '" selected, got "' + value + '" in group "' + label + '"');
+    return;
+  }
+  throw new Error("Element not found for label: " + label);
+}
+async function actionByText(page, text, action, nth, exact) {
+  let loc = page.getByText(text, { exact: true });
+  if (!exact) {
+    if (await loc.count() === 0) loc = page.getByRole("button", { name: text });
+    if (await loc.count() === 0) loc = page.getByRole("link", { name: text });
+    if (await loc.count() === 0) loc = page.getByRole("textbox", { name: text });
+    if (await loc.count() === 0) loc = page.getByRole("combobox", { name: text });
+    if (await loc.count() === 0) loc = page.getByPlaceholder(text);
+    if (await loc.count() === 0) loc = page.getByText(text);
+  }
+  if (nth !== void 0) loc = loc.filter({ visible: true }).nth(nth);
+  await loc[action]();
+}
+async function fillByText(page, text, value, nth, exact) {
+  let loc = page.getByLabel(text);
+  if (!exact) {
+    if (await loc.count() === 0) loc = page.getByPlaceholder(text);
+    if (await loc.count() === 0) loc = page.getByRole("textbox", { name: text });
+  }
+  if (nth !== void 0) loc = loc.filter({ visible: true }).nth(nth);
+  await loc.fill(value);
+}
+async function selectByText(page, text, value, nth, exact) {
+  let loc = page.getByLabel(text);
+  if (!exact) {
+    if (await loc.count() === 0) loc = page.getByRole("combobox", { name: text });
+  }
+  if (nth !== void 0) loc = loc.filter({ visible: true }).nth(nth);
+  await loc.selectOption(value);
+}
+async function checkByText(page, text, nth, exact) {
+  if (!exact) {
+    const item = page.getByRole("listitem").filter({ hasText: text });
+    if (await item.count() > 0) {
+      const target = nth !== void 0 ? item.filter({ visible: true }).nth(nth) : item;
+      await target.getByRole("checkbox").check();
+      return;
+    }
+  }
+  let loc = page.getByLabel(text);
+  if (!exact) {
+    if (await loc.count() === 0) loc = page.getByRole("checkbox", { name: text });
+  }
+  if (nth !== void 0) loc = loc.filter({ visible: true }).nth(nth);
+  await loc.check();
+}
+async function uncheckByText(page, text, nth, exact) {
+  if (!exact) {
+    const item = page.getByRole("listitem").filter({ hasText: text });
+    if (await item.count() > 0) {
+      const target = nth !== void 0 ? item.filter({ visible: true }).nth(nth) : item;
+      await target.getByRole("checkbox").uncheck();
+      return;
+    }
+  }
+  let loc = page.getByLabel(text);
+  if (!exact) {
+    if (await loc.count() === 0) loc = page.getByRole("checkbox", { name: text });
+  }
+  if (nth !== void 0) loc = loc.filter({ visible: true }).nth(nth);
+  await loc.uncheck();
+}
+async function actionByRole(page, role, name, action, nth, inRole, inText) {
+  let loc = page.getByRole(role, { name, exact: true });
+  if (inRole !== void 0 && inText !== void 0) {
+    const cr = { list: "listitem" }[inRole] || inRole;
+    loc = page.getByRole(cr).filter({ hasText: inText }).getByRole(role, { name, exact: true });
+  }
+  if (nth !== void 0) loc = loc.nth(nth);
+  await loc[action]();
+}
+async function fillByRole(page, role, name, value, nth, inRole, inText) {
+  let loc = page.getByRole(role, { name, exact: true });
+  if (inRole !== void 0 && inText !== void 0) {
+    const cr = { list: "listitem" }[inRole] || inRole;
+    loc = page.getByRole(cr).filter({ hasText: inText }).getByRole(role, { name, exact: true });
+  }
+  if (nth !== void 0) loc = loc.nth(nth);
+  await loc.fill(value);
+}
+async function selectByRole(page, role, name, value, nth, inRole, inText) {
+  let loc = page.getByRole(role, { name, exact: true });
+  if (inRole !== void 0 && inText !== void 0) {
+    const cr = { list: "listitem" }[inRole] || inRole;
+    loc = page.getByRole(cr).filter({ hasText: inText }).getByRole(role, { name, exact: true });
+  }
+  if (nth !== void 0) loc = loc.nth(nth);
+  await loc.selectOption(value);
+}
+async function highlightByText(page, text, nth, exact) {
+  let loc = exact ? page.getByText(text, { exact: true }) : page.getByText(text);
+  const count = await loc.count();
+  if (nth !== void 0) loc = loc.filter({ visible: true }).nth(nth);
+  await loc.highlight();
+  return nth !== void 0 ? "Highlighted 1 of " + count : "Highlighted " + count + " element" + (count !== 1 ? "s" : "");
+}
+async function highlightByRole(page, role, name, nth) {
+  let loc = page.getByRole(role, { name, exact: true });
+  const count = await loc.count();
+  if (nth !== void 0) loc = loc.nth(nth);
+  await loc.highlight();
+  return nth !== void 0 ? "Highlighted 1 of " + count : "Highlighted " + count + " element" + (count !== 1 ? "s" : "");
+}
+async function highlightBySelector(page, selector, nth) {
+  let loc = page.locator(selector);
+  const count = await loc.count();
+  if (nth !== void 0) loc = loc.filter({ visible: true }).nth(nth);
+  await loc.highlight();
+  return nth !== void 0 ? "Highlighted 1 of " + count : "Highlighted " + count + " element" + (count !== 1 ? "s" : "");
+}
+async function highlightByRef(page, ref) {
+  const loc = page.locator("aria-ref=" + ref);
+  await loc.highlight();
+  return "Highlighted";
+}
+async function clearHighlight(page) {
+  await page.locator("#__pw_clear__").highlight().catch(() => {
+  });
+  return "Cleared";
+}
+async function chainAction(page, selector, action, value) {
+  const loc = page.locator(selector);
+  if (value !== void 0) await loc[action](value);
+  else await loc[action]();
+  return "Done";
+}
+async function goBack(page) {
+  await page.goBack();
+  return page.url();
+}
+async function goForward(page) {
+  await page.goForward();
+  return page.url();
+}
+async function gotoUrl(page, url) {
+  await page.goto(url);
+  return "Navigated to " + url;
+}
+async function reloadPage(page) {
+  await page.reload();
+  return "Reloaded";
+}
+async function waitMs(page, ms) {
+  await page.waitForTimeout(ms);
+  return "Waited " + ms + "ms";
+}
+async function getTitle(page) {
+  return await page.title();
+}
+async function getUrl(page) {
+  return page.url();
+}
+async function evalCode(page, code) {
+  const result = await page.evaluate(code);
+  return result !== void 0 ? JSON.stringify(result) : "undefined";
+}
+async function runCode(page, code) {
+  const AsyncFunction = runCode.constructor;
+  const trimmed = code.trim();
+  const isFnExpr = /^(async\s*)?\(|^(async\s+)?function\b/.test(trimmed);
+  const body = isFnExpr ? `return (${trimmed})(page)` : `return ${trimmed}`;
+  const fn = new AsyncFunction("page", body);
+  const result = await fn(page);
+  return result != null && typeof result !== "object" ? String(result) : "Done";
+}
+async function takeScreenshot(page, fullPage) {
+  const data = await page.screenshot({ type: "jpeg", fullPage: !!fullPage });
+  return { __image: data.toString("base64"), mimeType: "image/jpeg" };
+}
+async function takeSnapshot(page) {
+  if (typeof page.ariaSnapshot === "function") {
+    return await page.ariaSnapshot({ mode: "ai" });
+  }
+  if (typeof page._snapshotForAI === "function") {
+    const result = await page._snapshotForAI();
+    return result.full ?? String(result);
+  }
+  const title = await page.title();
+  const url = page.url();
+  return "Title: " + title + "\nURL: " + url;
+}
+async function refAction(page, ref, action, value) {
+  const loc = page.locator("aria-ref=" + ref);
+  if (await loc.count() === 0) throw new Error("Element " + ref + " not found. Run snapshot first.");
+  if (value !== void 0) await loc[action](value);
+  else await loc[action]();
+  return "Done";
+}
+async function pressKey(page, target, key) {
+  if (!target || target === key) {
+    await page.keyboard.press(target);
+    return "Pressed " + target;
+  }
+  const isRef = /^e\d+$/.test(target);
+  if (isRef) {
+    await page.locator("aria-ref=" + target).press(key);
+    return "Pressed " + key;
+  }
+  let loc = page.getByText(target, { exact: true });
+  if (await loc.count() === 0) loc = page.getByRole("textbox", { name: target });
+  if (await loc.count() === 0) loc = page.getByRole("combobox", { name: target });
+  if (await loc.count() === 0) loc = page.getByPlaceholder(target);
+  if (await loc.count() === 0) loc = page.getByText(target);
+  await loc.press(key);
+  return "Pressed " + key;
+}
+async function pressKeyByRole(page, role, name, key, nth, inRole, inText) {
+  let loc = page.getByRole(role, { name, exact: true });
+  if (inRole !== void 0 && inText !== void 0) {
+    const cr = { list: "listitem" }[inRole] || inRole;
+    loc = page.getByRole(cr).filter({ hasText: inText }).getByRole(role, { name, exact: true });
+  }
+  if (nth !== void 0) loc = loc.nth(nth);
+  await loc.press(key);
+  return "Pressed " + key;
+}
+async function typeText(page, text) {
+  await page.keyboard.type(text);
+  return "Typed";
+}
+async function localStorageGet(page, key) {
+  return await page.evaluate((k) => localStorage.getItem(k), key);
+}
+async function localStorageSet(page, key, value) {
+  await page.evaluate(([k, v]) => localStorage.setItem(k, v), [key, value]);
+  return "Set";
+}
+async function localStorageDelete(page, key) {
+  await page.evaluate((k) => localStorage.removeItem(k), key);
+  return "Deleted";
+}
+async function localStorageClear(page) {
+  await page.evaluate(() => localStorage.clear());
+  return "Cleared";
+}
+async function localStorageList(page) {
+  const items = await page.evaluate(() => {
+    const result = {};
+    for (let i = 0; i < localStorage.length; i++) {
+      const k = localStorage.key(i);
+      result[k] = localStorage.getItem(k);
+    }
+    return result;
+  });
+  return JSON.stringify(items, null, 2);
+}
+async function sessionStorageGet(page, key) {
+  return await page.evaluate((k) => sessionStorage.getItem(k), key);
+}
+async function sessionStorageSet(page, key, value) {
+  await page.evaluate(([k, v]) => sessionStorage.setItem(k, v), [key, value]);
+  return "Set";
+}
+async function sessionStorageDelete(page, key) {
+  await page.evaluate((k) => sessionStorage.removeItem(k), key);
+  return "Deleted";
+}
+async function sessionStorageClear(page) {
+  await page.evaluate(() => sessionStorage.clear());
+  return "Cleared";
+}
+async function sessionStorageList(page) {
+  const items = await page.evaluate(() => {
+    const result = {};
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const k = sessionStorage.key(i);
+      result[k] = sessionStorage.getItem(k);
+    }
+    return result;
+  });
+  return JSON.stringify(items, null, 2);
+}
+async function cookieList(page) {
+  const cookies = await page.context().cookies();
+  return JSON.stringify(cookies, null, 2);
+}
+async function cookieGet(page, name) {
+  const cookies = await page.context().cookies();
+  const c = cookies.find((c2) => c2.name === name);
+  return c ? JSON.stringify(c, null, 2) : "Cookie not found: " + name;
+}
+async function cookieSet(page, name, value) {
+  const url = page.url();
+  await page.context().addCookies([{ name, value, url }]);
+  return "Cookie set: " + name;
+}
+async function cookieDelete(page, name) {
+  await page.context().clearCookies({ name });
+  return "Cookie deleted: " + name;
+}
+async function cookieClear(page) {
+  await page.context().clearCookies();
+  return "Cleared";
+}
+async function dragDrop(page, source, target) {
+  const srcLoc = /^e\d+$/.test(source) ? page.locator("aria-ref=" + source) : page.getByText(source);
+  const tgtLoc = /^e\d+$/.test(target) ? page.locator("aria-ref=" + target) : page.getByText(target);
+  await srcLoc.dragTo(tgtLoc);
+  return "Dragged";
+}
+async function resizeViewport(page, width, height) {
+  await page.setViewportSize({ width: parseInt(width), height: parseInt(height) });
+  return "Resized to " + width + "x" + height;
+}
+async function takePdf(page) {
+  const data = await page.pdf();
+  return { __image: data.toString("base64"), mimeType: "application/pdf" };
+}
+async function getConsoleMessages(_page, clear) {
+  if (clear) {
+    globalThis.__consoleMessages = [];
+    return "Console cleared";
+  }
+  const msgs = globalThis.__consoleMessages || [];
+  return msgs.length === 0 ? "No console messages (listening...)" : msgs.join("\n");
+}
+async function getNetworkRequests(_page, clear, includeStatic) {
+  if (clear) {
+    globalThis.__networkRequests = [];
+    return "Network log cleared";
+  }
+  let reqs = globalThis.__networkRequests || [];
+  if (!includeStatic) {
+    const skip = /* @__PURE__ */ new Set(["stylesheet", "image", "font", "media", "other"]);
+    reqs = reqs.filter((r) => !skip.has(r.type));
+  }
+  return reqs.length === 0 ? "No network requests (listening...)" : reqs.map((r) => r.status + " " + r.method + " " + r.url).join("\n");
+}
+async function setDialogAccept(_page) {
+  globalThis.__dialogMode = "accept";
+  return "Dialogs will be auto-accepted";
+}
+async function setDialogDismiss(_page) {
+  globalThis.__dialogMode = "dismiss";
+  return "Dialogs will be auto-dismissed";
+}
+async function addRoute(page, pattern) {
+  if (!globalThis.__activeRoutes) globalThis.__activeRoutes = [];
+  const handler = (route) => route.abort();
+  await page.route(pattern, handler);
+  globalThis.__activeRoutes.push({ pattern, handler });
+  return "Route added (blocked): " + pattern;
+}
+async function listRoutes(_page) {
+  const routes = globalThis.__activeRoutes || [];
+  return routes.length === 0 ? "No active routes" : routes.map((r) => r.pattern).join("\n");
+}
+async function removeRoute(page, pattern) {
+  if (!globalThis.__activeRoutes || globalThis.__activeRoutes.length === 0)
+    return "No routes to remove";
+  const idx = globalThis.__activeRoutes.findIndex((r) => r.pattern === pattern);
+  if (idx === -1) return "Route not found: " + pattern;
+  await page.unroute(pattern, globalThis.__activeRoutes[idx].handler);
+  globalThis.__activeRoutes.splice(idx, 1);
+  return "Route removed: " + pattern;
+}
+async function tabList(_page) {
+  const activeTabId = globalThis.activeTabId;
+  const windowId = activeTabId ? (await chrome.tabs.get(activeTabId)).windowId : void 0;
+  const tabs = await chrome.tabs.query(windowId !== void 0 ? { windowId } : {});
+  return JSON.stringify(tabs.map((tab, i) => ({
+    index: i,
+    title: tab.title || "",
+    url: tab.url || "",
+    current: tab.id === activeTabId
+  })), null, 2);
+}
+async function tabNew(_page, url) {
+  const tabUrl = url || "about:blank";
+  const activeTabId = globalThis.activeTabId;
+  const windowId = activeTabId ? (await chrome.tabs.get(activeTabId)).windowId : void 0;
+  await chrome.tabs.create(windowId !== void 0 ? { url: tabUrl, windowId } : { url: tabUrl });
+  return "Opened new tab" + (url ? ": " + url : "");
+}
+async function tabClose(_page, index) {
+  const activeTabId = globalThis.activeTabId;
+  const windowId = activeTabId ? (await chrome.tabs.get(activeTabId)).windowId : void 0;
+  const tabs = await chrome.tabs.query(windowId !== void 0 ? { windowId } : {});
+  const tab = index !== void 0 ? tabs[index] : tabs.find((t) => t.id === activeTabId);
+  if (!tab?.id) throw new Error("Tab " + (index !== void 0 ? index : "current") + " not found");
+  const url = tab.url || "";
+  await chrome.tabs.remove(tab.id);
+  return "Closed: " + url;
+}
+async function tabSelect(_page, index) {
+  const activeTabId = globalThis.activeTabId;
+  const windowId = activeTabId ? (await chrome.tabs.get(activeTabId)).windowId : void 0;
+  const tabs = await chrome.tabs.query(windowId !== void 0 ? { windowId } : {});
+  const tab = tabs[index];
+  if (!tab?.id) throw new Error("Tab " + index + " not found");
+  const res = await globalThis.attachToTab(tab.id);
+  if (!res.ok) throw new Error(res.error || "Attach failed");
+  return "Selected tab " + index + ": " + (res.url || "");
+}
+const COMMANDS = {
+  "check": { desc: "Check a checkbox", usage: "check <text> | check <ref>" },
+  "clear": { desc: "Clear the console" },
+  "click": {
+    desc: "Click an element",
+    usage: "click <text> | click <ref>",
+    examples: ['click "Submit"', "click e5", 'click "Submit" --button right']
+  },
+  "cookie-clear": { desc: "Clear cookies" },
+  "cookie-delete": { desc: "Delete cookie", usage: "cookie-delete <name>" },
+  "cookie-get": { desc: "Get cookie", usage: "cookie-get <name>" },
+  "cookie-list": { desc: "List cookies" },
+  "console": { desc: "Show console messages", usage: "console [--clear]" },
+  "cookie-set": { desc: "Set cookie", usage: "cookie-set <name> <value>" },
+  "dblclick": { desc: "Double-click", usage: "dblclick <text> | dblclick <ref>" },
+  "dialog-accept": { desc: "Auto-accept dialogs" },
+  "dialog-dismiss": { desc: "Auto-dismiss dialogs" },
+  "drag": { desc: "Drag and drop", usage: "drag <source> <target>" },
+  "eval": {
+    desc: "Evaluate JavaScript",
+    usage: "eval <expression>",
+    examples: ["eval document.title"]
+  },
+  "export": { desc: "Export as Playwright test" },
+  "fill": {
+    desc: "Fill a form field",
+    usage: "fill <text|ref> <value>",
+    examples: ['fill "Email" "user@test.com"', 'fill e3 "hello"']
+  },
+  "go-back": { desc: "Go back" },
+  "go-forward": { desc: "Go forward" },
+  "goto": {
+    desc: "Navigate to a URL",
+    usage: "goto <url>",
+    examples: ["goto https://example.com"]
+  },
+  "help": {
+    desc: "Show available commands",
+    usage: "help [command]",
+    examples: ["help", "help click"]
+  },
+  "highlight": {
+    desc: "Highlight element on page",
+    usage: "highlight <text|selector>",
+    examples: ['highlight "Submit"', "highlight .btn-primary"]
+  },
+  "history": { desc: "Show command history" },
+  "history clear": { desc: "Clear command history" },
+  "hover": { desc: "Hover over element", usage: "hover <text> | hover <ref>" },
+  "locator": {
+    desc: "Generate Playwright locator for a ref",
+    usage: "locator <ref>",
+    examples: ["locator e5"]
+  },
+  "localstorage-clear": { desc: "Clear localStorage" },
+  "localstorage-delete": { desc: "Delete localStorage", usage: "localstorage-delete <key>" },
+  "localstorage-get": { desc: "Get localStorage", usage: "localstorage-get <key>" },
+  "localstorage-list": { desc: "List localStorage" },
+  "localstorage-set": { desc: "Set localStorage", usage: "localstorage-set <key> <value>" },
+  "network": { desc: "Show network requests", usage: "network [--clear] [--includeStatic]" },
+  "open": { desc: "Open the browser" },
+  "pdf": { desc: "Save page as PDF", usage: "pdf" },
+  "press": {
+    desc: "Press a keyboard key",
+    usage: "press <key> | press <ref> <key>",
+    examples: ["press Enter", "press e5 Tab"]
+  },
+  "reload": { desc: "Reload page" },
+  "resize": { desc: "Resize viewport", usage: "resize <width> <height>" },
+  "route": { desc: "Block requests by pattern", usage: "route <pattern>" },
+  "route-list": { desc: "List active routes" },
+  "run-code": { desc: "Run Playwright code", usage: "run-code <code>" },
+  "screenshot": { desc: "Take a screenshot", usage: "screenshot [--filename <file>] [--fullPage]" },
+  "select": {
+    desc: "Select dropdown option",
+    usage: "select <text|ref> <value>",
+    examples: ['select "Country" "US"']
+  },
+  "sessionstorage-clear": { desc: "Clear sessionStorage" },
+  "sessionstorage-delete": { desc: "Delete sessionStorage", usage: "sessionstorage-delete <key>" },
+  "sessionstorage-get": { desc: "Get sessionStorage", usage: "sessionstorage-get <key>" },
+  "sessionstorage-list": { desc: "List sessionStorage" },
+  "sessionstorage-set": { desc: "Set sessionStorage", usage: "sessionstorage-set <key> <value>" },
+  "snapshot": { desc: "Accessibility snapshot", usage: "snapshot [--filename <file>]" },
+  "tab-close": { desc: "Close tab", usage: "tab-close [index]" },
+  "tab-list": { desc: "List tabs" },
+  "tab-new": { desc: "New tab", usage: "tab-new [url]" },
+  "tab-select": { desc: "Select tab", usage: "tab-select <index>" },
+  "type": {
+    desc: "Type text key by key",
+    usage: "type <text>",
+    examples: ['type "hello world"']
+  },
+  "uncheck": { desc: "Uncheck a checkbox", usage: "uncheck <text> | uncheck <ref>" },
+  "unroute": { desc: "Remove a route", usage: "unroute <pattern>" },
+  "verify": {
+    desc: "Assert page state",
+    usage: "verify <type> <args>",
+    examples: ['verify title "My Page"', 'verify text "Hello"', 'verify element button "Submit"']
+  },
+  "verify-element": { desc: "Verify element exists by role", usage: "verify-element <role> <name>" },
+  "verify-no-element": { desc: "Verify element not exists", usage: "verify-no-element <role> <name>" },
+  "verify-no-text": { desc: "Verify text not visible", usage: "verify-no-text <text>" },
+  "verify-text": { desc: "Verify text visible", usage: "verify-text <text>" },
+  "verify-title": { desc: "Verify page title", usage: "verify-title <text>" },
+  "verify-url": { desc: "Verify page URL", usage: "verify-url <text>" },
+  "verify-value": { desc: "Verify input / checkbox / radio value", usage: "verify-value <ref|text> <value>" },
+  "verify-visible": { desc: "Verify element is visible by role", usage: "verify-visible <role> <name>" },
+  "tracing-start": { desc: "Start performance trace recording", usage: "tracing-start" },
+  "tracing-stop": { desc: "Stop tracing and save trace file", usage: "tracing-stop" },
+  "video-start": { desc: "Start recording the active tab", usage: "video-start" },
+  "video-stop": { desc: "Stop recording and save video", usage: "video-stop" },
+  "wait-for-text": {
+    desc: "Wait until text appears",
+    usage: "wait-for-text <text>",
+    examples: ['wait-for-text "Loading complete"']
+  }
+};
+const COMMAND_NAMES = Object.keys(COMMANDS);
+const CATEGORIES = {
+  "Navigation": ["goto", "open", "go-back", "go-forward", "reload"],
+  "Interaction": ["click", "dblclick", "fill", "type", "press", "hover", "select", "check", "uncheck", "drag"],
+  "Verification": ["verify", "verify-text", "verify-no-text", "verify-title", "verify-url", "verify-element", "verify-no-element", "verify-value", "verify-visible", "wait-for-text"],
+  "Inspection": ["snapshot", "locator", "screenshot", "pdf", "video-start", "video-stop", "tracing-start", "tracing-stop", "eval", "run-code", "console", "network"],
+  "Tabs": ["tab-list", "tab-new", "tab-close", "tab-select"],
+  "Cookies": ["cookie-list", "cookie-get", "cookie-set", "cookie-delete", "cookie-clear"],
+  "LocalStorage": ["localstorage-list", "localstorage-get", "localstorage-set", "localstorage-delete", "localstorage-clear"],
+  "SessionStorage": ["sessionstorage-list", "sessionstorage-get", "sessionstorage-set", "sessionstorage-delete", "sessionstorage-clear"],
+  "Other": ["highlight", "export", "resize", "dialog-accept", "dialog-dismiss", "route", "route-list", "unroute"]
+};
+const JS_CATEGORIES = {
+  "Navigation": ["page.goto(url)", "page.goBack()", "page.reload()", "..."],
+  "Locators": ["page.getByRole(role)", "page.getByText(text)", "page.locator(sel)", "page.getByTestId(id)", "..."],
+  "Actions": [".click()", ".fill(value)", ".press(key)", ".hover()", ".selectOption(value)", "..."],
+  "Query": [".textContent()", ".getAttribute(name)", ".isVisible()", ".count()", "..."],
+  "Assertions": ["expect(loc).toBeVisible()", ".toHaveText()", ".toHaveValue()", "expect(page).toHaveTitle()", ".toHaveURL()", "..."],
+  "Wait": ["page.waitForSelector(sel)", "page.waitForLoadState()", "page.waitForURL(url)"],
+  "Evaluate": ["page.evaluate(() => expr)"],
+  "Other": ["page.screenshot()", "page.keyboard.press(key)", "page.mouse.click(x, y)", "..."]
+};
+function isDirect(result) {
+  return "jsExpr" in result;
+}
+function ser(v) {
+  if (v === void 0) return "undefined";
+  return JSON.stringify(v);
+}
+function call(fn, ...args) {
+  return `await (${fn.toString()})(page, ${args.map(ser).join(", ")})`;
+}
+const BOOLEAN_OPTIONS = /* @__PURE__ */ new Set([
+  "headed",
+  "persistent",
+  "extension",
+  "submit",
+  "clear",
+  "fullPage",
+  "includeStatic",
+  "exact"
+]);
+function tokenize(line) {
+  const tokens = [];
+  let current = "";
+  let inQuote = null;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuote) {
+      if (ch === inQuote) {
+        inQuote = null;
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' || ch === "'") {
+      inQuote = ch;
+    } else if (ch === " " || ch === "	") {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+const RAW_COMMANDS = /* @__PURE__ */ new Set(["run-code", "eval"]);
+function parseInput(line) {
+  const tokens = tokenize(line);
+  if (tokens.length === 0) return null;
+  tokens[0] = tokens[0].toLowerCase();
+  if (RAW_COMMANDS.has(tokens[0])) {
+    const cmdLen = line.match(/^\s*\S+/)[0].length;
+    const rest = line.slice(cmdLen).trim();
+    return rest ? { _: [tokens[0], rest] } : { _: [tokens[0]] };
+  }
+  const positional = [];
+  const opts = {};
+  let i = 0;
+  while (i < tokens.length) {
+    if (tokens[i].startsWith("--")) {
+      const key = tokens[i].slice(2);
+      if (BOOLEAN_OPTIONS.has(key)) {
+        opts[key] = true;
+        i++;
+      } else if (key === "in" && i + 2 < tokens.length && !tokens[i + 1].startsWith("--") && !tokens[i + 2].startsWith("--")) {
+        opts["in-role"] = tokens[i + 1];
+        opts["in-text"] = tokens[i + 2];
+        i += 3;
+      } else if (i + 1 < tokens.length && !tokens[i + 1].startsWith("--")) {
+        opts[key] = tokens[i + 1];
+        i += 2;
+      } else {
+        opts[key] = true;
+        i++;
+      }
+    } else {
+      positional.push(tokens[i]);
+      i++;
+    }
+  }
+  return { _: positional, ...opts };
+}
+function resolveArgs(args) {
+  const cmdName = args._[0];
+  if (cmdName === "verify") {
+    const subType = args._[1];
+    const rest = args._.slice(2);
+    if (subType === "title" && rest.length > 0)
+      return { jsExpr: call(verifyTitle, rest.join(" ")) };
+    if (subType === "url" && rest.length > 0)
+      return { jsExpr: call(verifyUrl, rest.join(" ")) };
+    if (subType === "text" && rest.length > 0)
+      return { jsExpr: call(verifyText, rest.join(" ")) };
+    if (subType === "no-text" && rest.length > 0)
+      return { jsExpr: call(verifyNoText, rest.join(" ")) };
+    if (subType === "element" && rest.length >= 2)
+      return { jsExpr: call(verifyElement, rest[0], rest.slice(1).join(" ")) };
+    if (subType === "no-element" && rest.length >= 2)
+      return { jsExpr: call(verifyNoElement, rest[0], rest.slice(1).join(" ")) };
+    if (subType === "value" && rest.length >= 2)
+      return { jsExpr: call(verifyValue, rest[0], rest.slice(1).join(" ")) };
+    if (subType === "list" && rest.length >= 2)
+      return { jsExpr: call(verifyList, rest[0], rest.slice(1)) };
+  }
+  const TEXT_VERIFY_CMDS = /* @__PURE__ */ new Set(["verify-text", "verify-no-text", "verify-title", "verify-url"]);
+  const ELEMENT_VERIFY_CMDS = /* @__PURE__ */ new Set(["verify-element", "verify-no-element", "verify-visible"]);
+  const verifyFns = {
+    "verify-text": verifyText,
+    "verify-element": verifyElement,
+    "verify-visible": verifyVisible,
+    "verify-value": verifyValue,
+    "verify-list": verifyList,
+    "verify-title": verifyTitle,
+    "verify-url": verifyUrl,
+    "verify-no-text": verifyNoText,
+    "verify-no-element": verifyNoElement
+  };
+  if (verifyFns[cmdName]) {
+    const pos = args._.slice(1);
+    const fn = verifyFns[cmdName];
+    if (TEXT_VERIFY_CMDS.has(cmdName)) {
+      const text = pos.join(" ");
+      if (text) return { jsExpr: call(fn, text) };
+    } else if (ELEMENT_VERIFY_CMDS.has(cmdName)) {
+      if (pos[0] && pos.length >= 2) return { jsExpr: call(fn, pos[0], pos.slice(1).join(" ")) };
+    } else if (cmdName === "verify-value" && pos[0] && pos.length >= 2) {
+      const isRef = /^e\d+$/.test(pos[0]);
+      const valueFn = isRef ? verifyValue : verifyInputValue;
+      return { jsExpr: call(valueFn, pos[0], pos.slice(1).join(" ")) };
+    } else if (pos[0] && pos.length >= 2) {
+      const rest = cmdName === "verify-list" ? pos.slice(1) : pos.slice(1).join(" ");
+      return { jsExpr: call(fn, pos[0], rest) };
+    }
+  }
+  if (cmdName === "wait-for-text") {
+    const text = args._.slice(1).join(" ");
+    if (text) return { jsExpr: call(waitForText, text) };
+  }
+  if (cmdName === "goto" || cmdName === "open") {
+    const url = args._[1];
+    if (!url) return args;
+    return { jsExpr: call(gotoUrl, url) };
+  }
+  if (cmdName === "reload")
+    return { jsExpr: call(reloadPage) };
+  if (cmdName === "go-back")
+    return { jsExpr: call(goBack) };
+  if (cmdName === "go-forward")
+    return { jsExpr: call(goForward) };
+  if (cmdName === "title")
+    return { jsExpr: call(getTitle) };
+  if (cmdName === "url")
+    return { jsExpr: call(getUrl) };
+  if (cmdName === "wait") {
+    const ms = parseInt(args._[1]) || 1e3;
+    return { jsExpr: call(waitMs, ms) };
+  }
+  if (cmdName === "eval") {
+    const code = args._[1] || "";
+    return { jsExpr: call(evalCode, code) };
+  }
+  if (cmdName === "run-code") {
+    const code = args._[1] || "";
+    return { jsExpr: call(runCode, code) };
+  }
+  if (cmdName === "screenshot")
+    return { jsExpr: `JSON.stringify(await (${takeScreenshot.toString()})(page, ${!!args.fullPage}))` };
+  if (cmdName === "pdf")
+    return { jsExpr: `JSON.stringify(await (${takePdf.toString()})(page))` };
+  if (cmdName === "snapshot")
+    return { jsExpr: call(takeSnapshot) };
+  if (cmdName === "highlight") {
+    if (args.clear) return { jsExpr: call(clearHighlight) };
+    const loc = args._[1];
+    if (loc) {
+      if (/^e\d+$/.test(loc)) return { jsExpr: call(highlightByRef, loc) };
+      const nth = args.nth !== void 0 ? parseInt(String(args.nth), 10) : void 0;
+      const exact = args.exact ? true : void 0;
+      const isSelector = /[.#[\]>:=]/.test(loc);
+      if (!isSelector && args._.length >= 3 && /^[a-z]+$/.test(loc)) {
+        const name = args._.slice(2).join(" ");
+        return { jsExpr: call(highlightByRole, loc, name, nth) };
+      }
+      return isSelector ? { jsExpr: call(highlightBySelector, loc, nth) } : { jsExpr: call(highlightByText, loc, nth, exact) };
+    }
+  }
+  const LOCATOR_ACTIONS = {
+    click: "click",
+    dblclick: "dblclick",
+    hover: "hover",
+    check: "check",
+    uncheck: "uncheck",
+    fill: "fill",
+    select: "selectOption"
+  };
+  if (LOCATOR_ACTIONS[cmdName] && args._.some((a) => a.includes(">>"))) {
+    const action = LOCATOR_ACTIONS[cmdName];
+    const positional = args._.slice(1);
+    let lastChainIdx = -1;
+    for (let i = 0; i < positional.length; i++) {
+      if (positional[i] === ">>" || positional[i].includes(">>")) lastChainIdx = i;
+    }
+    const selectorEnd = positional[lastChainIdx] !== ">>" && positional[lastChainIdx]?.includes(">>") ? lastChainIdx : lastChainIdx + 1;
+    const selector = positional.slice(0, selectorEnd + 1).join(" ");
+    const rest = positional.slice(selectorEnd + 1).join(" ");
+    return { jsExpr: call(chainAction, selector, action, rest || void 0) };
+  }
+  const ROLE_ACTIONS = {
+    click: "click",
+    dblclick: "dblclick",
+    hover: "hover",
+    check: "check",
+    uncheck: "uncheck"
+  };
+  if (args._.length >= 3 && args._[1] && /^[a-z]+$/.test(args._[1]) && !args._.some((a) => a.includes(">>"))) {
+    const role = args._[1];
+    const nth = args.nth !== void 0 ? parseInt(String(args.nth), 10) : void 0;
+    const inRole = args["in-role"] !== void 0 ? String(args["in-role"]) : void 0;
+    const inText = args["in-text"] !== void 0 ? String(args["in-text"]) : void 0;
+    if (ROLE_ACTIONS[cmdName]) {
+      const name = args._.slice(2).join(" ");
+      return { jsExpr: call(actionByRole, role, name, ROLE_ACTIONS[cmdName], nth, inRole, inText) };
+    }
+    if (cmdName === "fill") {
+      return { jsExpr: call(fillByRole, role, args._[2], args._.slice(3).join(" ") || "", nth, inRole, inText) };
+    }
+    if (cmdName === "select") {
+      return { jsExpr: call(selectByRole, role, args._[2], args._.slice(3).join(" ") || "", nth, inRole, inText) };
+    }
+    if (cmdName === "press") {
+      const key = args._.slice(3).join(" ") || "";
+      return { jsExpr: call(pressKeyByRole, role, args._[2], key, nth, inRole, inText) };
+    }
+  }
+  const textFns = {
+    click: actionByText,
+    dblclick: actionByText,
+    hover: actionByText,
+    fill: fillByText,
+    select: selectByText,
+    check: checkByText,
+    uncheck: uncheckByText
+  };
+  if (textFns[cmdName] && args._[1] && !/^e\d+$/.test(args._[1]) && !args._.some((a) => a.includes(">>"))) {
+    const textArg = args._[1];
+    const extraArgs = args._.slice(2);
+    const fn = textFns[cmdName];
+    const nth = args.nth !== void 0 ? parseInt(String(args.nth), 10) : void 0;
+    const exact = args.exact ? true : void 0;
+    if (fn === actionByText)
+      return { jsExpr: call(fn, textArg, cmdName, nth, exact) };
+    if (cmdName === "fill" || cmdName === "select")
+      return { jsExpr: call(fn, textArg, extraArgs[0] || "", nth, exact) };
+    return { jsExpr: call(fn, textArg, nth, exact) };
+  }
+  const REF_ACTIONS = {
+    click: "click",
+    dblclick: "dblclick",
+    hover: "hover",
+    check: "check",
+    uncheck: "uncheck",
+    fill: "fill",
+    select: "selectOption",
+    type: "fill"
+  };
+  if (REF_ACTIONS[cmdName] && args._[1] && /^e\d+$/.test(args._[1])) {
+    const ref = args._[1];
+    const action = REF_ACTIONS[cmdName];
+    const value = args._.slice(2).join(" ") || void 0;
+    return { jsExpr: call(refAction, ref, action, value) };
+  }
+  if (cmdName === "press") {
+    const pos = args._.slice(1);
+    if (pos.length === 1) {
+      return { jsExpr: call(pressKey, pos[0], pos[0]) };
+    }
+    if (pos.length >= 2) {
+      return { jsExpr: call(pressKey, pos[0], pos[1]) };
+    }
+  }
+  if (cmdName === "type") {
+    const text = args._.slice(1).join(" ");
+    if (text) return { jsExpr: call(typeText, text) };
+  }
+  if (cmdName === "localstorage-get")
+    return { jsExpr: call(localStorageGet, args._[1]) };
+  if (cmdName === "localstorage-set")
+    return { jsExpr: call(localStorageSet, args._[1], args._.slice(2).join(" ")) };
+  if (cmdName === "localstorage-delete")
+    return { jsExpr: call(localStorageDelete, args._[1]) };
+  if (cmdName === "localstorage-clear")
+    return { jsExpr: call(localStorageClear) };
+  if (cmdName === "localstorage-list")
+    return { jsExpr: call(localStorageList) };
+  if (cmdName === "sessionstorage-get")
+    return { jsExpr: call(sessionStorageGet, args._[1]) };
+  if (cmdName === "sessionstorage-set")
+    return { jsExpr: call(sessionStorageSet, args._[1], args._.slice(2).join(" ")) };
+  if (cmdName === "sessionstorage-delete")
+    return { jsExpr: call(sessionStorageDelete, args._[1]) };
+  if (cmdName === "sessionstorage-clear")
+    return { jsExpr: call(sessionStorageClear) };
+  if (cmdName === "sessionstorage-list")
+    return { jsExpr: call(sessionStorageList) };
+  if (cmdName === "cookie-list")
+    return { jsExpr: call(cookieList) };
+  if (cmdName === "cookie-get")
+    return { jsExpr: call(cookieGet, args._[1]) };
+  if (cmdName === "cookie-set")
+    return { jsExpr: call(cookieSet, args._[1], args._.slice(2).join(" ")) };
+  if (cmdName === "cookie-delete")
+    return { jsExpr: call(cookieDelete, args._[1]) };
+  if (cmdName === "cookie-clear")
+    return { jsExpr: call(cookieClear) };
+  if (cmdName === "tab-list")
+    return { jsExpr: call(tabList) };
+  if (cmdName === "tab-new")
+    return { jsExpr: call(tabNew, args._[1]) };
+  if (cmdName === "tab-close") {
+    const idx = args._[1] ? parseInt(args._[1]) : void 0;
+    return { jsExpr: call(tabClose, idx) };
+  }
+  if (cmdName === "tab-select") {
+    const idx = args._[1] ? parseInt(args._[1]) : NaN;
+    if (isNaN(idx)) return args;
+    return { jsExpr: call(tabSelect, idx) };
+  }
+  if (cmdName === "drag" && args._[1] && args._[2])
+    return { jsExpr: call(dragDrop, args._[1], args._[2]) };
+  if (cmdName === "resize" && args._[1] && args._[2])
+    return { jsExpr: call(resizeViewport, args._[1], args._[2]) };
+  if (cmdName === "console")
+    return { jsExpr: call(getConsoleMessages, args.clear) };
+  if (cmdName === "network")
+    return { jsExpr: call(getNetworkRequests, args.clear, args.includeStatic) };
+  if (cmdName === "dialog-accept")
+    return { jsExpr: call(setDialogAccept) };
+  if (cmdName === "dialog-dismiss")
+    return { jsExpr: call(setDialogDismiss) };
+  if (cmdName === "route" && args._[1])
+    return { jsExpr: call(addRoute, args._[1]) };
+  if (cmdName === "route-list")
+    return { jsExpr: call(listRoutes) };
+  if (cmdName === "unroute" && args._[1])
+    return { jsExpr: call(removeRoute, args._[1]) };
+  return args;
+}
+function parseReplCommand(input) {
+  const tokens = tokenize(input.trim());
+  if (tokens.length === 0) return { error: "Empty command" };
+  const trimmed = input.trim().toLowerCase();
+  if (trimmed === "help") {
+    const lines = Object.entries(CATEGORIES).map(([cat, cmds]) => `  ${cat}: ${cmds.join(", ")}`).join("\n");
+    return { help: `Available commands:
+${lines}
+
+Type "help <command>" for details.` };
+  }
+  if (trimmed.startsWith("help ")) {
+    const cmd = trimmed.slice(5).trim();
+    if (cmd === "js" || cmd === "javascript") {
+      const jsLines = Object.entries(JS_CATEGORIES).map(([cat, methods]) => `  ${cat}: ${methods.join(", ")}`).join("\n");
+      return { help: `JavaScript mode — Playwright API:
+  Prefix with await for async methods
+
+${jsLines}` };
+    }
+    const info = COMMANDS[cmd];
+    if (!info) return { error: `Unknown command: "${cmd}". Type "help" for available commands.` };
+    const parts = [`${cmd} — ${info.desc}`];
+    if (info.usage) parts.push(`Usage: ${info.usage}`);
+    if (info.examples?.length) {
+      parts.push("Examples:");
+      for (const ex of info.examples) parts.push(`  ${ex}`);
+    }
+    return { help: parts.join("\n") };
+  }
+  if (trimmed.startsWith("locator ")) {
+    const ref = trimmed.slice("locator ".length).trim();
+    if (!ref) return { error: "Usage: locator <ref>\nExample: locator e5" };
+    return { jsExpr: `(await page.locator(${ser("aria-ref=" + ref)}).normalize()).toString()` };
+  }
+  const args = parseInput(input);
+  if (!args) return { error: "Empty command" };
+  const resolved = resolveArgs(args);
+  if (isDirect(resolved)) return resolved;
+  const cmdName = args._[0];
+  return { error: `Unknown command: "${cmdName}". Type "help" for commands.` };
+}
+const PW_COMMANDS = new Set(COMMAND_NAMES);
+function resolveConsoleMode(input) {
+  if (input.includes("\n")) return "js";
+  return detectMode(input);
+}
+const JS_KEYWORDS = /* @__PURE__ */ new Set(["await", "typeof", "delete", "void", "throw", "new", "yield", "async"]);
+function detectMode(input) {
+  const firstToken = input.trim().split(/\s+/)[0];
+  if (PW_COMMANDS.has(firstToken.toLowerCase())) return "pw";
+  if (/^[a-z][-a-z]*$/.test(firstToken) && !JS_KEYWORDS.has(firstToken) && input.includes(" ") && !/[.()=;{}[\]+*/<>!&|^~?:`]/.test(input)) return "pw";
+  return "js";
+}
+const execute = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  detectMode,
+  resolveConsoleMode
+}, Symbol.toStringTag, { value: "Module" }));
+let swTargetId = null;
+if (typeof chrome !== "undefined" && chrome.debugger) {
+  chrome.debugger.onDetach.addListener((source) => {
+    if (source.targetId === swTargetId) swTargetId = null;
+  });
+}
+function querySwTarget() {
+  const swUrl = `chrome-extension://${chrome.runtime.id}/background.js`;
+  return new Promise((resolve) => {
+    chrome.debugger.getTargets((targets) => {
+      const sw = targets.find((t) => t.type === "worker" && t.url === swUrl);
+      resolve(sw?.id ?? null);
+    });
+  });
+}
+async function findSwTarget() {
+  await chrome.runtime.sendMessage({ type: "ping" }).catch(() => {
+  });
+  for (let i = 0; i < 10; i++) {
+    const id = await querySwTarget();
+    if (id) return id;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return null;
+}
+async function ensureAttached() {
+  if (swTargetId) return swTargetId;
+  const targetId = await findSwTarget();
+  if (!targetId) throw new Error("Background worker target not found. Try reloading the extension.");
+  if (swTargetId === targetId) return targetId;
+  await new Promise((resolve, reject) => {
+    chrome.debugger.attach({ targetId }, "1.3", () => {
+      if (chrome.runtime.lastError) {
+        const msg = chrome.runtime.lastError.message ?? "";
+        if (/already attached/i.test(msg)) {
+          swTargetId = targetId;
+          resolve();
+        } else reject(new Error(msg));
+      } else {
+        chrome.debugger.sendCommand({ targetId }, "Runtime.enable", {}, () => {
+        });
+        swTargetId = targetId;
+        resolve();
+      }
+    });
+  });
+  return targetId;
+}
+function getTargetId() {
+  return swTargetId;
+}
+async function cdpSendCommand(method, params = {}) {
+  const targetId = await ensureAttached();
+  return new Promise((resolve, reject) => {
+    chrome.debugger.sendCommand({ targetId }, method, params, (result) => {
+      if (chrome.runtime.lastError) {
+        reject(new Error(chrome.runtime.lastError.message));
+      } else {
+        resolve(result);
+      }
+    });
+  });
+}
+async function cdpEval(expression, objectGroup = "console") {
+  const expr = expression.trimStart().startsWith("{") ? `(${expression})` : expression;
+  const targetId = await ensureAttached();
+  const result = await new Promise((resolve, reject) => {
+    chrome.debugger.sendCommand(
+      { targetId },
+      "Runtime.evaluate",
+      { expression: expr, awaitPromise: true, returnByValue: false, generatePreview: true, objectGroup, replMode: true },
+      (res) => {
+        if (chrome.runtime.lastError) {
+          swTargetId = null;
+          reject(new Error(chrome.runtime.lastError.message));
+        } else {
+          resolve(res);
+        }
+      }
+    );
+  });
+  if (result?.exceptionDetails) {
+    const msg = result.exceptionDetails.exception?.description ?? result.exceptionDetails.text ?? "Unknown error";
+    throw new Error(msg);
+  }
+  return result?.result;
+}
+async function cdpCallFunctionOn(objectId, functionDeclaration, returnByValue = true) {
+  return cdpSendCommand("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration,
+    returnByValue
+  });
+}
+async function cdpGetProperties(objectId) {
+  return cdpSendCommand("Runtime.getProperties", {
+    objectId,
+    ownProperties: true,
+    generatePreview: true
+  });
+}
+export {
+  COMMAND_NAMES as C,
+  JS_CATEGORIES as J,
+  cdpCallFunctionOn as a,
+  cdpSendCommand as b,
+  cdpEval as c,
+  detectMode as d,
+  cdpGetProperties as e,
+  CATEGORIES as f,
+  getTargetId as g,
+  COMMANDS as h,
+  execute as i,
+  parseReplCommand as p,
+  resolveConsoleMode as r
+};
+//# sourceMappingURL=sw-debugger-core.js.map