@treegress.com/treegress-browser-core 1.59.0-treegress.3

package/lib/tools/customDomSnapshotFormatter.js

@@ -0,0 +1,658 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var customDomSnapshotFormatter_exports = {};
+__export(customDomSnapshotFormatter_exports, {
+  customDomStableLocatorKey: () => customDomStableLocatorKey,
+  formatCustomDomSnapshot: () => formatCustomDomSnapshot,
+  isCustomDomSnapshotEnvelope: () => isCustomDomSnapshotEnvelope
+});
+module.exports = __toCommonJS(customDomSnapshotFormatter_exports);
+const kCustomDomVerificationMarker = "[custom-dom]";
+const kInputTypeToRole = {
+  button: "button",
+  checkbox: "checkbox",
+  email: "textbox",
+  number: "textbox",
+  password: "textbox",
+  radio: "radio",
+  reset: "button",
+  search: "textbox",
+  submit: "button",
+  tel: "textbox",
+  text: "textbox",
+  url: "textbox"
+};
+function isCustomDomSnapshotEnvelope(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const envelope = value;
+  if (envelope.backend !== "custom-dom")
+    return false;
+  const page = envelope.page;
+  if (!page || typeof page !== "object")
+    return false;
+  return !!page.frameTree;
+}
+function customDomStableLocatorKey(framePath, stableId) {
+  return `${framePath.join(".") || "root"}::${stableId}`;
+}
+function formatCustomDomSnapshot(envelope) {
+  const state = {
+    nextRef: 1,
+    aliasToStableId: /* @__PURE__ */ new Map(),
+    locatorPlans: /* @__PURE__ */ new Map()
+  };
+  const lines = renderFrameSnapshot(envelope.page.frameTree, [], "", state);
+  return {
+    snapshot: lines.join("\n"),
+    aliasToStableId: state.aliasToStableId,
+    locatorPlans: state.locatorPlans
+  };
+}
+function renderFrameSnapshot(frame, framePath, indent, state) {
+  const root = asTreeNode(frame.dom);
+  if (!root)
+    return [];
+  let childFrameIndex = 0;
+  const lines = renderNode(root, true, indent);
+  while (childFrameIndex < frame.childFrames.length) {
+    const childFrame = frame.childFrames[childFrameIndex++];
+    const pathIndex = childFrame.childFrameIndex ?? childFrameIndex - 1;
+    lines.push(`${indent}- iframe:`);
+    lines.push(...renderFrameSnapshot(childFrame, [...framePath, pathIndex], indent + "  ", state));
+  }
+  return lines;
+  function renderNode(node, isRoot, lineIndent) {
+    const tag = readString(node.tag)?.toLowerCase() || "node";
+    const ref = maybeAssignAlias(node, frame, framePath, state, isRoot, tag);
+    const { label, consumedChildAlt } = formatNodeLabel(node, tag, ref);
+    const nested = [];
+    for (const child of readChildren(node)) {
+      const compact = compactMediaChild(child, consumedChildAlt, lineIndent + "  ");
+      if (compact !== void 0) {
+        if (compact)
+          nested.push(compact);
+        continue;
+      }
+      nested.push(...renderNode(child, false, lineIndent + "  "));
+    }
+    if (tag === "iframe" && childFrameIndex < frame.childFrames.length) {
+      const childFrame = frame.childFrames[childFrameIndex++];
+      const pathIndex = childFrame.childFrameIndex ?? childFrameIndex - 1;
+      nested.push(...renderFrameSnapshot(childFrame, [...framePath, pathIndex], lineIndent + "  ", state));
+    }
+    const hasNested = nested.length > 0;
+    let line = `${lineIndent}- ${label}${hasNested ? ":" : ""}`;
+    if (isRoot)
+      line += ` ${kCustomDomVerificationMarker}`;
+    return [line, ...nested];
+  }
+}
+function maybeAssignAlias(node, frame, framePath, state, isRoot, tag) {
+  const stableId = readString(node.id);
+  if (!stableId)
+    return;
+  if (!shouldExposeRef(node, isRoot, tag))
+    return;
+  const locatorPlan = readRecord(frame.locatorPlans)?.[stableId];
+  if (!locatorPlan || typeof locatorPlan !== "object")
+    return;
+  const key = customDomStableLocatorKey(framePath, stableId);
+  if (!state.locatorPlans.has(key))
+    state.locatorPlans.set(key, locatorPlan);
+  const ref = `e${state.nextRef++}`;
+  state.aliasToStableId.set(ref, {
+    ref,
+    stableId,
+    frameId: frame.frameId,
+    framePath: [...framePath]
+  });
+  return ref;
+}
+function shouldExposeRef(node, isRoot, tag) {
+  if (isRoot)
+    return true;
+  if (readBoolean(node.isInteractive))
+    return true;
+  if (tag === "iframe")
+    return true;
+  if (readString(node.text))
+    return true;
+  if (readString(node.accessibleName))
+    return true;
+  return false;
+}
+function formatNodeLabel(node, tag, ref) {
+  const nodeRecord = node;
+  const attributes = readRecord(nodeRecord.attributes) || {};
+  const explicitRole = readString(nodeRecord.role) || readString(attributes.role);
+  const semantic = inferRole(tag, explicitRole, attributes);
+  const { name, consumedChildAlt, source: nameSource, extras: namingExtras } = resolveNodeName(node, tag, attributes);
+  const text = readString(nodeRecord.text);
+  const value = readString(attributes.value);
+  const actionHint = resolveActionHint(attributes.onclick);
+  const namingExtraKeys = new Set(namingExtras.map((extra) => extra.key));
+  const parts = [semantic.role];
+  if (name)
+    parts.push(quoteValue(name));
+  if (semantic.level !== void 0)
+    parts.push(`[level=${semantic.level}]`);
+  parts.push(...formatNamingExtraBadges(namingExtras));
+  parts.push(...formatControlBadges(tag, attributes, name, nameSource));
+  if (readBoolean(nodeRecord.isInteractive))
+    parts.push("[interactive]");
+  if (hasPointerCursor(nodeRecord, attributes, tag))
+    parts.push("[cursor=pointer]");
+  if (nodeRecord.isVisible === false)
+    parts.push("[hidden]");
+  if (readBoolean(nodeRecord.isFocused))
+    parts.push("[active]");
+  if (readBoolean(nodeRecord.isDisabled))
+    parts.push("[disabled]");
+  if (readBoolean(nodeRecord.isChecked))
+    parts.push("[checked]");
+  if (readBoolean(nodeRecord.isSelected))
+    parts.push("[selected]");
+  if (isContentEditable(attributes))
+    parts.push("[contenteditable]");
+  parts.push(...formatAriaBadges(attributes));
+  if (actionHint)
+    parts.push(`[action=${actionHint}]`);
+  const rawOnclick = formatRawOnclick(attributes.onclick);
+  if (rawOnclick)
+    parts.push(`[onclick=${quoteValue(rawOnclick)}]`);
+  parts.push(...formatStructuralHintBadges(nodeRecord, tag, semantic.role, attributes, name, explicitRole, namingExtraKeys));
+  if (ref)
+    parts.push(`[ref=${ref}]`);
+  const suffix = formatTextSuffix(node, semantic.role, value, text, name);
+  let label = parts.join(" ");
+  if (suffix)
+    label += `: ${suffix}`;
+  return { label, consumedChildAlt };
+}
+function inferRole(tag, explicitRole, attributes) {
+  if (explicitRole === "heading") {
+    const headingLevel = readHeadingLevel(attributes["aria-level"], tag);
+    return headingLevel === void 0 ? { role: explicitRole } : { role: explicitRole, level: headingLevel };
+  }
+  if (explicitRole)
+    return { role: explicitRole };
+  if (tag === "iframe")
+    return { role: "iframe" };
+  const heading = tag.match(/^h([1-6])$/);
+  if (heading)
+    return { role: "heading", level: Number(heading[1]) };
+  if (tag === "button")
+    return { role: "button" };
+  if (tag === "a")
+    return { role: "link" };
+  if (tag === "textarea")
+    return { role: "textbox" };
+  if (tag === "select")
+    return { role: "combobox" };
+  if (tag === "option")
+    return { role: "option" };
+  if (isContentEditable(attributes))
+    return { role: "textbox" };
+  if (tag === "input") {
+    const inputType = (readString(attributes.type) || "text").toLowerCase();
+    return { role: kInputTypeToRole[inputType] || "textbox" };
+  }
+  return { role: tag || "node" };
+}
+function formatTextSuffix(node, role, value, text, name) {
+  const normalizedValue = normalizeText(value);
+  const normalizedText = normalizeText(text);
+  const inlineHint = buildInlineTextHint(node, normalizedText);
+  let suffix;
+  if (role === "textbox" && normalizedValue !== void 0)
+    suffix = /^\d+(\.\d+)?$/.test(normalizedValue) ? quoteValue(normalizedValue) : normalizedValue;
+  else if (normalizedText !== void 0 && normalizedText !== name)
+    suffix = normalizedText;
+  else if (normalizedValue !== void 0 && normalizedValue !== name)
+    suffix = normalizedValue;
+  if (inlineHint) {
+    if (!suffix)
+      return inlineHint;
+    if (!suffix.includes(inlineHint))
+      return `${suffix} [inline: ${inlineHint}]`;
+  }
+  if (suffix !== void 0)
+    return suffix;
+  return;
+}
+function resolveNodeName(node, tag, attributes) {
+  const nodeRecord = node;
+  const accessibleName = normalizeText(readString(nodeRecord.accessibleName));
+  const text = normalizeText(readString(nodeRecord.text));
+  const ariaLabel = normalizeText(readString(attributes["aria-label"]));
+  const ariaLabelledBy = normalizeText(readString(attributes["aria-labelledby"]));
+  const alt = normalizeText(readString(attributes.alt));
+  const childAlt = readImmediateChildAlt(node);
+  const placeholder = normalizeText(readString(attributes.placeholder));
+  const title = normalizeText(readString(attributes.title));
+  const testIdHint = readPreferredTestId(attributes);
+  const formFieldName = normalizeText(readString(attributes.name));
+  const semanticClassName = readDescriptiveSemanticClassName(attributes.class);
+  const srcName = extractSourceName(attributes.src);
+  const candidates = [];
+  const pushCandidate = (value, source, badgeKey) => {
+    const normalized = normalizeText(value);
+    if (!normalized)
+      return;
+    candidates.push({ value: normalized, source, badgeKey });
+  };
+  pushCandidate(ariaLabel, "aria-label");
+  if (ariaLabelledBy && accessibleName)
+    pushCandidate(accessibleName, "aria-labelledby");
+  const explicitSources = [ariaLabel, alt, childAlt, placeholder, title, testIdHint?.value, formFieldName, semanticClassName, srcName, text];
+  if (accessibleName && !explicitSources.some((value) => valuesEquivalent(accessibleName, value)))
+    pushCandidate(accessibleName, "accessibleName");
+  pushCandidate(alt, "alt");
+  pushCandidate(childAlt, "child-alt");
+  pushCandidate(placeholder, "placeholder");
+  pushCandidate(title, "title", "title");
+  if (testIdHint)
+    pushCandidate(testIdHint.value, testIdHint.key, testIdHint.key);
+  pushCandidate(formFieldName, "name", "name");
+  if (tag === "img")
+    pushCandidate(srcName, "src", "src");
+  pushCandidate(text, "text");
+  if (!candidates.length)
+    return { extras: [] };
+  const [winner, ...rest] = candidates;
+  const extras = [];
+  for (const candidate of rest) {
+    if (!candidate.badgeKey)
+      continue;
+    if (valuesEquivalent(candidate.value, winner.value))
+      continue;
+    if (extras.some((extra) => extra.key === candidate.badgeKey && valuesEquivalent(extra.value, candidate.value)))
+      continue;
+    extras.push({ key: candidate.badgeKey, value: candidate.value });
+  }
+  const consumedChildAlt = childAlt && valuesEquivalent(childAlt, winner.value) ? childAlt : void 0;
+  return {
+    name: winner.value,
+    source: winner.source,
+    consumedChildAlt,
+    extras
+  };
+}
+function readImmediateChildAlt(node) {
+  for (const child of readChildren(node)) {
+    const childRecord = child;
+    const childAttributes = readRecord(childRecord.attributes) || {};
+    const childAlt = normalizeText(readString(childAttributes.alt));
+    if (childAlt)
+      return childAlt;
+  }
+  return;
+}
+function resolveActionHint(onclick) {
+  const raw = readString(onclick);
+  if (!raw)
+    return;
+  const normalized = raw.toLowerCase();
+  if (normalized === "event.stoppropagation()")
+    return;
+  if (normalized.includes("queryselector") && normalized.includes("dropdown-list"))
+    return "toggle-dropdown";
+  if (normalized.includes("classlist.toggle"))
+    return "toggle";
+  if (normalized.includes("style.display") && normalized.includes("none") && normalized.includes("block"))
+    return "toggle-visibility";
+  const alertMatch = raw.match(/alert\((['"`])(.+?)\1\)/i);
+  if (alertMatch) {
+    const action = normalizeActionHint(alertMatch[2].replace(/\bclicked\b/i, ""));
+    if (action)
+      return action;
+  }
+  return "onclick";
+}
+function formatRawOnclick(value) {
+  const raw = readString(value);
+  if (!raw)
+    return;
+  if (raw.length <= 50)
+    return raw;
+  return raw.slice(0, 47) + "...";
+}
+function normalizeActionHint(value) {
+  const normalized = normalizeText(value)?.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!normalized)
+    return;
+  return normalized;
+}
+function formatNamingExtraBadges(extras) {
+  return extras.map((extra) => `[${extra.key}=${formatBadgeValue(extra.value)}]`);
+}
+function formatControlBadges(tag, attributes, name, nameSource) {
+  const parts = [];
+  const inputType = normalizeText(readString(attributes.type))?.toLowerCase();
+  if (tag === "input" && inputType && inputType !== "text")
+    parts.push(`[type=${formatBadgeValue(inputType)}]`);
+  const placeholder = normalizeText(readString(attributes.placeholder));
+  if (placeholder && nameSource !== "placeholder" && placeholder !== name)
+    parts.push(`[placeholder=${formatBadgeValue(placeholder)}]`);
+  if (hasTruthyAttribute(attributes, "required"))
+    parts.push("[required]");
+  if (hasTruthyAttribute(attributes, "readonly") || attributeEquals(attributes["aria-readonly"], "true"))
+    parts.push("[readonly]");
+  const boundedAttributes = [
+    { key: "min", badge: "min" },
+    { key: "max", badge: "max" },
+    { key: "step", badge: "step" },
+    { key: "minlength", badge: "minlength" },
+    { key: "maxlength", badge: "maxlength" },
+    { key: "pattern", badge: "pattern" }
+  ];
+  for (const bounded of boundedAttributes) {
+    const value = readAttributeValue(attributes[bounded.key]);
+    if (value)
+      parts.push(`[${bounded.badge}=${formatBadgeValue(value)}]`);
+  }
+  return parts;
+}
+function formatAriaBadges(attributes) {
+  const parts = [];
+  const badges = [
+    { key: "aria-expanded", badge: "expanded" },
+    { key: "aria-haspopup", badge: "haspopup" },
+    { key: "aria-controls", badge: "controls" },
+    { key: "aria-describedby", badge: "describedby" },
+    { key: "aria-labelledby", badge: "labelledby" }
+  ];
+  for (const item of badges) {
+    const value = readAttributeValue(attributes[item.key]);
+    if (value)
+      parts.push(`[${item.badge}=${formatBadgeValue(value)}]`);
+  }
+  return parts;
+}
+function formatStructuralHintBadges(nodeRecord, tag, role, attributes, name, explicitRole, usedNamingExtraKeys) {
+  if (!isGenericContainerRole(tag, role) || explicitRole)
+    return [];
+  if (!readBoolean(nodeRecord.isInteractive) && nodeRecord.isVisible !== false)
+    return [];
+  const parts = [];
+  const classHint = readSemanticClassHint(attributes.class);
+  if (classHint && !usedNamingExtraKeys.has("class"))
+    parts.push(`[class=${formatBadgeValue(classHint)}]`);
+  for (const [key, value] of readAllowedDataHints(attributes)) {
+    if (usedNamingExtraKeys.has(key))
+      continue;
+    parts.push(`[${key}=${formatBadgeValue(value)}]`);
+  }
+  if (!parts.length)
+    return parts;
+  if (name && readBoolean(nodeRecord.isInteractive))
+    return parts.slice(0, 1);
+  return parts;
+}
+function buildInlineTextHint(node, existingText) {
+  const childTexts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const child of readChildren(node)) {
+    const childRecord = child;
+    if (readBoolean(childRecord.isInteractive))
+      continue;
+    if (childRecord.isVisible === false)
+      continue;
+    if (!isInlineTextChild(childRecord))
+      continue;
+    const childText = normalizeText(readString(childRecord.text));
+    if (!childText)
+      continue;
+    if (containsText(existingText, childText))
+      continue;
+    const key = childText.toLowerCase();
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    childTexts.push(childText);
+  }
+  if (!childTexts.length)
+    return;
+  return childTexts.join(", ");
+}
+function isInlineTextChild(nodeRecord) {
+  const tag = readString(nodeRecord.tag)?.toLowerCase();
+  if (!tag || tag === "svg" || tag === "img")
+    return false;
+  const display = readString(readRecord(nodeRecord.computedStyle)?.display)?.toLowerCase();
+  if (display === "inline" || display === "inline-block")
+    return true;
+  return ["strong", "em", "b", "i", "mark", "small", "code"].includes(tag);
+}
+function containsText(haystack, needle) {
+  if (!haystack)
+    return false;
+  return haystack.toLowerCase().includes(needle.toLowerCase());
+}
+function isGenericContainerRole(tag, role) {
+  if (tag !== role)
+    return false;
+  return ["div", "span", "section", "article", "aside", "main", "header", "footer", "nav", "form", "li"].includes(tag);
+}
+function readSemanticClassHint(value) {
+  const className = readString(value);
+  if (!className)
+    return;
+  const semanticTokens = className.split(/\s+/).filter((token) => {
+    if (!token)
+      return false;
+    const normalized = token.toLowerCase();
+    if (normalized.length < 3)
+      return false;
+    if (/^(css|sc|jsx|chakra|mantine|ant|Mui|css-)/i.test(token))
+      return false;
+    if (/^[a-f0-9_-]{6,}$/i.test(token))
+      return false;
+    return /(icon|btn|button|toggle|switch|dropdown|menu|tab|modal|dialog|tooltip|popover|select|option|search|input|form|nav|sidebar|card|item|avatar|chip|badge|panel|list)/i.test(token);
+  });
+  if (!semanticTokens.length)
+    return;
+  return semanticTokens.join(" ");
+}
+function readDescriptiveSemanticClassName(value) {
+  const classHint = readSemanticClassHint(value);
+  if (!classHint)
+    return;
+  const normalized = classHint.toLowerCase().split(/\s+/);
+  const genericOnly = normalized.every((token) => ["icon", "icon-btn", "btn", "button", "item", "panel", "list", "card"].includes(token));
+  if (genericOnly)
+    return;
+  return classHint;
+}
+function readPreferredTestId(attributes) {
+  const keys = ["data-testid", "data-test-id", "data-test", "data-qa", "data-cy"];
+  for (const key of keys) {
+    const value = readAttributeValue(attributes[key]);
+    if (value)
+      return { key, value };
+  }
+  return;
+}
+function readAllowedDataHints(attributes) {
+  const hints = [];
+  const allowedKeys = ["data-testid", "data-test-id", "data-test", "data-qa", "data-cy", "data-action", "data-tooltip", "data-type", "data-state", "data-label", "data-name"];
+  for (const key of allowedKeys) {
+    const value = readAttributeValue(attributes[key]);
+    if (value)
+      hints.push([key, value]);
+  }
+  return hints;
+}
+function hasTruthyAttribute(attributes, key) {
+  if (!Object.prototype.hasOwnProperty.call(attributes, key))
+    return false;
+  const value = attributes[key];
+  if (value === false || value === null || value === void 0)
+    return false;
+  if (typeof value === "string")
+    return value.toLowerCase() !== "false";
+  return true;
+}
+function attributeEquals(value, expected) {
+  return readAttributeValue(value)?.toLowerCase() === expected;
+}
+function readAttributeValue(value) {
+  if (typeof value === "string")
+    return normalizeText(value);
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (value === true)
+    return "true";
+  if (value === false)
+    return "false";
+  return;
+}
+function formatBadgeValue(value) {
+  return /^[a-z0-9._:-]+$/i.test(value) ? value : quoteValue(value);
+}
+function hasPointerCursor(nodeRecord, attributes, tag) {
+  const computedCursor = readString(readRecord(nodeRecord.computedStyle)?.cursor);
+  const hasPointer = computedCursor === "pointer" || styleContainsPointerCursor(attributes.style);
+  if (!hasPointer)
+    return false;
+  if (readBoolean(nodeRecord.isInteractive))
+    return true;
+  if (hasInlineHandler(attributes))
+    return true;
+  if (tag === "a" || tag === "button" || tag === "summary")
+    return true;
+  if (readString(nodeRecord.text) || readString(nodeRecord.accessibleName))
+    return true;
+  return false;
+}
+function compactMediaChild(node, consumedChildAlt, indent) {
+  const nodeRecord = node;
+  const tag = readString(nodeRecord.tag)?.toLowerCase();
+  if (tag !== "svg" && tag !== "img")
+    return void 0;
+  if (tag === "svg")
+    return `${indent}- img [tag=svg]`;
+  const attributes = readRecord(nodeRecord.attributes) || {};
+  const alt = normalizeText(readString(attributes.alt));
+  const altBadge = alt && alt !== consumedChildAlt ? ` [alt=${quoteValue(alt)}]` : "";
+  return `${indent}- img${altBadge}`;
+}
+function quoteValue(value) {
+  return JSON.stringify(normalizeText(value) || value);
+}
+function normalizeText(value) {
+  if (!value)
+    return;
+  const normalized = value.replace(/\s+/g, " ").replace(/\s+([.,;:!?])/g, "$1").trim();
+  if (!normalized)
+    return;
+  if (normalized.length <= 200)
+    return normalized;
+  return normalized.slice(0, 197) + "...";
+}
+function isContentEditable(attributes) {
+  const value = readString(attributes.contenteditable);
+  return !!value && value.toLowerCase() !== "false";
+}
+function readChildren(node) {
+  const raw = node.children;
+  if (!Array.isArray(raw))
+    return [];
+  const children = [];
+  for (const child of raw) {
+    const parsed = asTreeNode(child);
+    if (parsed)
+      children.push(parsed);
+  }
+  return children;
+}
+function asTreeNode(value) {
+  if (!value || typeof value !== "object")
+    return;
+  return value;
+}
+function readRecord(value) {
+  if (!value || typeof value !== "object")
+    return;
+  return value;
+}
+function readString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  return trimmed;
+}
+function readBoolean(value) {
+  return value === true;
+}
+function readHeadingLevel(value, tag) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0)
+    return value;
+  if (typeof value === "string" && /^\d+$/.test(value))
+    return Number(value);
+  const heading = tag.match(/^h([1-6])$/);
+  if (heading)
+    return Number(heading[1]);
+  return;
+}
+function styleContainsPointerCursor(value) {
+  const style = readString(value);
+  if (!style)
+    return false;
+  return /(?:^|;)\s*cursor\s*:\s*pointer\s*(?:;|$)/i.test(style);
+}
+function hasInlineHandler(attributes) {
+  for (const [key, value] of Object.entries(attributes)) {
+    if (!key.startsWith("on"))
+      continue;
+    if (readAttributeValue(value))
+      return true;
+  }
+  return false;
+}
+function valuesEquivalent(left, right) {
+  if (!left || !right)
+    return false;
+  return comparableText(left) === comparableText(right);
+}
+function comparableText(value) {
+  return normalizeText(value)?.toLowerCase().replace(/['"`]/g, "").trim() || "";
+}
+function extractSourceName(value) {
+  const src = readString(value);
+  if (!src || src.startsWith("data:"))
+    return;
+  try {
+    const url = new URL(src, "http://example.invalid");
+    const pathname = url.pathname.split("/").pop();
+    return normalizeText(pathname || src);
+  } catch {
+    const fileName = src.split(/[/?#]/).filter(Boolean).pop();
+    return normalizeText(fileName);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  customDomStableLocatorKey,
+  formatCustomDomSnapshot,
+  isCustomDomSnapshotEnvelope
+});

package/lib/tools/devtools.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var devtools_exports = {};
+__export(devtools_exports, {
+  default: () => devtools_default
+});
+module.exports = __toCommonJS(devtools_exports);
+var import_mcpBundle = require("../mcpBundle");
+var import_tool = require("./tool");
+const devtoolsConnect = (0, import_tool.defineTool)({
+  capability: "devtools",
+  skillOnly: true,
+  schema: {
+    name: "browser_devtools_start",
+    title: "Start browser DevTools",
+    description: "Start browser DevTools",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    const { url } = await browserContext._devtoolsStart();
+    response.addTextResult("Server is listening on: " + url);
+  }
+});
+var devtools_default = [devtoolsConnect];