@wordbricks/playwright-mcp 0.1.25 → 0.1.26

package/lib/playwrightTransformer.js

@@ -0,0 +1,520 @@
+import { memoize, pipe } from "@fxts/core";
+import { alt_sc, apply, buildLexer, extractByTokenRange, kmid, makeParserModule, rep_sc, seq, tok, } from "typescript-parsec";
+// Pure utility functions
+export const escapeString = (str) => str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+const isBlank = (str) => str.trim() === "";
+export const createHelperCall = (helper, ...args) => `__pwHelpers.${helper}(${args.map((a) => `'${escapeString(a)}'`).join(", ")})`;
+var SelTokKind;
+(function (SelTokKind) {
+    SelTokKind[SelTokKind["HasText"] = 0] = "HasText";
+    SelTokKind[SelTokKind["Contains"] = 1] = "Contains";
+    SelTokKind[SelTokKind["Text"] = 2] = "Text";
+    SelTokKind[SelTokKind["Visible"] = 3] = "Visible";
+    SelTokKind[SelTokKind["Has"] = 4] = "Has";
+    SelTokKind[SelTokKind["NthMatch"] = 5] = "NthMatch";
+    SelTokKind[SelTokKind["LParen"] = 6] = "LParen";
+    SelTokKind[SelTokKind["RParen"] = 7] = "RParen";
+    SelTokKind[SelTokKind["Comma"] = 8] = "Comma";
+    SelTokKind[SelTokKind["WS"] = 9] = "WS";
+    SelTokKind[SelTokKind["DQString"] = 10] = "DQString";
+    SelTokKind[SelTokKind["SQString"] = 11] = "SQString";
+    SelTokKind[SelTokKind["BQString"] = 12] = "BQString";
+    SelTokKind[SelTokKind["Regex"] = 13] = "Regex";
+    SelTokKind[SelTokKind["Other"] = 14] = "Other";
+})(SelTokKind || (SelTokKind = {}));
+const selectorLexer = buildLexer([
+    [true, /^:has-text/g, SelTokKind.HasText],
+    [true, /^:contains/g, SelTokKind.Contains],
+    [true, /^:text/g, SelTokKind.Text],
+    [true, /^:visible\b/g, SelTokKind.Visible],
+    [true, /^:has\b/g, SelTokKind.Has],
+    [true, /^:nth-match\b/g, SelTokKind.NthMatch],
+    [true, /^\(/g, SelTokKind.LParen],
+    [true, /^\)/g, SelTokKind.RParen],
+    [true, /^,/g, SelTokKind.Comma],
+    [false, /^\s+/g, SelTokKind.WS],
+    [true, /^"(?:[^"\\]|\\.)*"/g, SelTokKind.DQString],
+    [true, /^'(?:[^'\\]|\\.)*'/g, SelTokKind.SQString],
+    [true, /^`(?:[^`\\]|\\.)*`/g, SelTokKind.BQString],
+    [true, /^\/(?:[^/\\]|\\.)+\/[a-z]*/gi, SelTokKind.Regex],
+    [true, /^[\s\S]/g, SelTokKind.Other],
+]);
+// text args can be "..." or '...' or `...` or /.../flags
+const TEXT_ARG = alt_sc(apply(tok(SelTokKind.DQString), (t) => t.text.slice(1, t.text.length - 1)), apply(tok(SelTokKind.SQString), (t) => t.text.slice(1, t.text.length - 1)), apply(tok(SelTokKind.BQString), (t) => t.text.slice(1, t.text.length - 1)), apply(tok(SelTokKind.Regex), (t) => t.text));
+// Keep for generic quoted (used where we want the raw quoted text, not regex)
+const QUOTED = alt_sc(tok(SelTokKind.DQString), tok(SelTokKind.SQString), tok(SelTokKind.BQString));
+// Recursive string parser for :has(...) argument
+const HasArgModule = makeParserModule({
+    ITEM: (m) => alt_sc(apply(QUOTED, (t) => t.text), apply(tok(SelTokKind.Regex), (t) => t.text), // allow regex inside :has inner
+    apply(tok(SelTokKind.Has), (t) => t.text), apply(tok(SelTokKind.HasText), (t) => t.text), apply(tok(SelTokKind.Contains), (t) => t.text), apply(tok(SelTokKind.Text), (t) => t.text), apply(tok(SelTokKind.Visible), (t) => t.text), apply(tok(SelTokKind.NthMatch), (t) => t.text), apply(tok(SelTokKind.Comma), (t) => t.text), // allow comma in inner (selector lists)
+    apply(tok(SelTokKind.Other), (t) => t.text), apply(seq(tok(SelTokKind.LParen), m.ARG, tok(SelTokKind.RParen)), (v) => "(" + v[1] + ")")),
+    ARG: (m) => apply(rep_sc(m.ITEM), (arr) => arr.join("")),
+});
+// first arg of :nth-match — same as ARG but *without* comma tokens
+const HasArgNoCommaModule = makeParserModule({
+    ITEM: (m) => alt_sc(apply(QUOTED, (t) => t.text), apply(tok(SelTokKind.Regex), (t) => t.text), apply(tok(SelTokKind.Has), (t) => t.text), apply(tok(SelTokKind.HasText), (t) => t.text), apply(tok(SelTokKind.Contains), (t) => t.text), apply(tok(SelTokKind.Text), (t) => t.text), apply(tok(SelTokKind.Visible), (t) => t.text), apply(tok(SelTokKind.NthMatch), (t) => t.text), apply(tok(SelTokKind.Other), (t) => t.text), apply(seq(tok(SelTokKind.LParen), m.ARG, tok(SelTokKind.RParen)), (v) => "(" + v[1] + ")")),
+    ARG: (m) => apply(rep_sc(m.ITEM), (arr) => arr.join("")),
+});
+const HAS_ARG = HasArgModule.ARG;
+const NTH_ARG_NO_COMMA = HasArgNoCommaModule.ARG;
+const PseudoModule = makeParserModule({
+    HAS: () => apply(kmid(seq(tok(SelTokKind.Has), tok(SelTokKind.LParen)), HAS_ARG, tok(SelTokKind.RParen)), (inner) => ({ kind: "has", inner })),
+    HAS_TEXT: () => apply(kmid(seq(tok(SelTokKind.HasText), tok(SelTokKind.LParen)), TEXT_ARG, tok(SelTokKind.RParen)), (text) => ({ kind: "hasText", text })),
+    CONTAINS: () => apply(kmid(seq(tok(SelTokKind.Contains), tok(SelTokKind.LParen)), TEXT_ARG, tok(SelTokKind.RParen)), (text) => ({ kind: "contains", text })),
+    TEXT: () => apply(kmid(seq(tok(SelTokKind.Text), tok(SelTokKind.LParen)), TEXT_ARG, tok(SelTokKind.RParen)), (text) => ({ kind: "text", text })),
+    VISIBLE: () => apply(tok(SelTokKind.Visible), () => ({ kind: "visible" })),
+    // :nth-match(<selector>, <index>)
+    NTH_MATCH: () => apply(kmid(seq(tok(SelTokKind.NthMatch), tok(SelTokKind.LParen)), seq(NTH_ARG_NO_COMMA, // first arg string (no commas)
+    apply(rep_sc(tok(SelTokKind.WS)), () => ""), // optional spaces
+    tok(SelTokKind.Comma), apply(rep_sc(tok(SelTokKind.WS)), () => ""), // optional spaces
+    TEXT_ARG), tok(SelTokKind.RParen)), (v) => {
+        const inner = v[0];
+        const idxRaw = v[4];
+        const index = Number.parseInt(idxRaw, 10);
+        return { kind: "nthMatch", inner, index: isFinite(index) ? index : 1 };
+    }),
+    ANY: (m) => alt_sc(m.HAS, m.HAS_TEXT, m.CONTAINS, m.TEXT, m.VISIBLE, m.NTH_MATCH),
+});
+const parseFirstPseudo = (selector) => {
+    const start = selectorLexer.parse(selector);
+    if (!start)
+        return { kind: "none" };
+    let t = start;
+    while (t) {
+        const parsed = PseudoModule.ANY.parse(t);
+        if (parsed.successful && parsed.candidates.length > 0) {
+            const cand = parsed.candidates[0];
+            const consumed = extractByTokenRange(selector, cand.firstToken, cand.nextToken).length;
+            const prefix = selector.slice(0, t.pos.index);
+            const base = prefix + selector.slice(t.pos.index + consumed);
+            const res = cand.result;
+            if (res.kind === "has")
+                return { kind: "has", base, inner: res.inner };
+            if (res.kind === "visible")
+                return { kind: "visible", base };
+            if (res.kind === "hasText")
+                return { kind: "hasText", base, text: res.text };
+            if (res.kind === "contains")
+                return { kind: "contains", base, text: res.text };
+            if (res.kind === "nthMatch")
+                return { kind: "nthMatch", base, inner: res.inner, index: res.index };
+            return { kind: "text", base, text: res.text };
+        }
+        t = t.next;
+    }
+    return { kind: "none" };
+};
+var SkipTokKind;
+(function (SkipTokKind) {
+    SkipTokKind[SkipTokKind["LineComment"] = 0] = "LineComment";
+    SkipTokKind[SkipTokKind["BlockComment"] = 1] = "BlockComment";
+    SkipTokKind[SkipTokKind["DQString"] = 2] = "DQString";
+    SkipTokKind[SkipTokKind["SQString"] = 3] = "SQString";
+    SkipTokKind[SkipTokKind["BQString"] = 4] = "BQString";
+    SkipTokKind[SkipTokKind["WS"] = 5] = "WS";
+    SkipTokKind[SkipTokKind["LParen"] = 6] = "LParen";
+    SkipTokKind[SkipTokKind["RParen"] = 7] = "RParen";
+    SkipTokKind[SkipTokKind["Dot"] = 8] = "Dot";
+    SkipTokKind[SkipTokKind["QuerySelector"] = 9] = "QuerySelector";
+    SkipTokKind[SkipTokKind["QuerySelectorAll"] = 10] = "QuerySelectorAll";
+    SkipTokKind[SkipTokKind["Identifier"] = 11] = "Identifier";
+    SkipTokKind[SkipTokKind["Other"] = 12] = "Other";
+})(SkipTokKind || (SkipTokKind = {}));
+const skipLexer = buildLexer([
+    [true, /^\/\/[^\n]*/g, SkipTokKind.LineComment],
+    [true, /^\/\*[\s\S]*?\*\//g, SkipTokKind.BlockComment],
+    [true, /^"(?:[^"\\]|\\.)*"/g, SkipTokKind.DQString],
+    [true, /^'(?:[^'\\]|\\.)*'/g, SkipTokKind.SQString],
+    [true, /^`(?:[^`\\]|\\.)*`/g, SkipTokKind.BQString],
+    [true, /^\s+/g, SkipTokKind.WS],
+    [true, /^\(/g, SkipTokKind.LParen],
+    [true, /^\)/g, SkipTokKind.RParen],
+    [true, /^\./g, SkipTokKind.Dot],
+    [true, /^querySelectorAll\b/g, SkipTokKind.QuerySelectorAll],
+    [true, /^querySelector\b/g, SkipTokKind.QuerySelector],
+    [true, /^[A-Za-z_$][A-Za-z0-9_$]*/g, SkipTokKind.Identifier],
+    [true, /^[\s\S]/g, SkipTokKind.Other],
+]);
+const SKIP_CALL_QUOTED = alt_sc(tok(SkipTokKind.DQString), tok(SkipTokKind.SQString), tok(SkipTokKind.BQString));
+// Zero-or-more space/comments -> string
+const WS_OR_COMMENT = alt_sc(tok(SkipTokKind.WS), tok(SkipTokKind.LineComment), tok(SkipTokKind.BlockComment));
+const SP0 = apply(rep_sc(WS_OR_COMMENT), (ts) => ts.map((t) => t.text).join(""));
+// receiver := Identifier ('.' Identifier)*
+const RECEIVER = apply(seq(tok(SkipTokKind.Identifier), rep_sc(seq(tok(SkipTokKind.Dot), tok(SkipTokKind.Identifier)))), (v) => {
+    const head = v[0].text;
+    const tail = v[1]
+        .map((p) => p[0].text + p[1].text)
+        .join("");
+    return head + tail;
+});
+const SegmentModule = makeParserModule({
+    RAW: () => apply(alt_sc(tok(SkipTokKind.LParen), tok(SkipTokKind.RParen), tok(SkipTokKind.WS), tok(SkipTokKind.LineComment), tok(SkipTokKind.BlockComment), tok(SkipTokKind.DQString), tok(SkipTokKind.SQString), tok(SkipTokKind.BQString), tok(SkipTokKind.QuerySelectorAll), tok(SkipTokKind.QuerySelector), tok(SkipTokKind.Identifier), tok(SkipTokKind.Dot), tok(SkipTokKind.Other)), (t) => ({ kind: "raw", text: t.text })),
+    CALL_ONE: () => apply(seq(RECEIVER, tok(SkipTokKind.Dot), tok(SkipTokKind.QuerySelector), SP0, tok(SkipTokKind.LParen), SP0, SKIP_CALL_QUOTED, SP0, tok(SkipTokKind.RParen)), (v) => {
+        const lit = v[6];
+        return {
+            kind: "call",
+            method: "one",
+            selector: lit.text.slice(1, lit.text.length - 1),
+            original: v[0] +
+                v[1].text +
+                v[2].text +
+                v[3] +
+                v[4].text +
+                v[5] +
+                v[6].text +
+                v[7] +
+                v[8].text,
+        };
+    }),
+    CALL_ALL: () => apply(seq(RECEIVER, tok(SkipTokKind.Dot), tok(SkipTokKind.QuerySelectorAll), SP0, tok(SkipTokKind.LParen), SP0, SKIP_CALL_QUOTED, SP0, tok(SkipTokKind.RParen)), (v) => {
+        const lit = v[6];
+        return {
+            kind: "call",
+            method: "all",
+            selector: lit.text.slice(1, lit.text.length - 1),
+            original: v[0] +
+                v[1].text +
+                v[2].text +
+                v[3] +
+                v[4].text +
+                v[5] +
+                v[6].text +
+                v[7] +
+                v[8].text,
+        };
+    }),
+    SEGMENT: (m) => alt_sc(m.CALL_ALL, m.CALL_ONE, m.RAW),
+});
+const PROGRAM = rep_sc(SegmentModule.SEGMENT);
+// Helper functions template
+export const helperFunctions = `
+;(() => {
+  if (window.__pwHelpers)
+    return;
+  window.__pwHelpers = (() => {
+  const isVisible = (el) => {
+    const s = window.getComputedStyle(el);
+    return s.display !== 'none' && s.visibility !== 'hidden' && el.offsetParent !== null;
+  };
+  // string or /regex/flags -> predicate
+  const toMatcher = (needle) => {
+    if (typeof needle === 'string' && /^\\/(?:[^\\\\/]|\\\\.)+\\/[a-z]*$/i.test(needle)) {
+      const m = needle.match(/^\\/(.*)\\/([a-z]*)$/i);
+      try { const re = new RegExp(m[1], m[2]); return (s) => typeof s === 'string' && re.test(s); }
+      catch { /* fall through */ }
+    }
+    return (s) => typeof s === 'string' && s.includes(needle);
+  };
+  const hasText = (el, text) => {
+    const match = toMatcher(text);
+    return el.textContent && match(el.textContent);
+  };
+  const processSelector = (sel) => sel.replace(/>>/g, ' ');
+  const normalizeScoped = (sel) => {
+    const trimmed = sel.trim();
+    if (trimmed.startsWith('>') || trimmed.startsWith('+') || trimmed.startsWith('~'))
+      return ':scope ' + trimmed;
+    if (!/^:scope\\b/.test(trimmed))
+      return ':scope ' + trimmed;
+    return trimmed;
+  };
+  // multi-pseudo support for inner selectors (used by :has())
+  const matchSelectorWithPseudos = (root, sel) => {
+    // peel off known pseudos and turn them into filters
+    const filters = [];
+    // collect text/contains/has-text
+    sel = sel.replace(/:(?:contains|has-text|text)\\((\\"(?:[^"\\\\]|\\\\.)*\\"|'(?:[^'\\\\]|\\\\.)*'|\\\`(?:[^\\\`\\\\]|\\\\.)*\\\`|\\/(?:[^\\\\/]|\\\\.)+\\/[a-z]*)\\)/gi, (m, arg) => {
+      // strip quotes if present; regex stays as /.../flags
+      let v = arg;
+      const qc = v[0];
+      if (qc === '"' || qc === "'" || qc === '\`') v = v.slice(1, -1);
+      const pred = (el) => hasText(el, v);
+      filters.push(pred);
+      return '';
+    });
+    // collect :visible
+    sel = sel.replace(/:visible\\b/gi, () => {
+      filters.push((el) => isVisible(el));
+      return '';
+    });
+    const without = (sel.trim() || '*');
+    const scoped = normalizeScoped(processSelector(without));
+    const nodes = Array.from(root.querySelectorAll(scoped));
+    if (!filters.length) return nodes;
+    return nodes.filter(n => filters.every(f => f(n)));
+  };
+
+  return {
+    hasText: (selector, text) => Array.from(document.querySelectorAll(selector)).find(el => hasText(el, text)),
+    hasTextAll: (selector, text) => Array.from(document.querySelectorAll(selector)).filter(el => hasText(el, text)),
+    visible: (selector) => Array.from(document.querySelectorAll(selector)).find(el => isVisible(el)),
+    visibleAll: (selector) => Array.from(document.querySelectorAll(selector)).filter(el => isVisible(el)),
+    has: (baseSelector, innerSelector) => Array.from(document.querySelectorAll(baseSelector)).find(el => matchSelectorWithPseudos(el, innerSelector).length > 0),
+    hasAll: (baseSelector, innerSelector) => Array.from(document.querySelectorAll(baseSelector)).filter(el => matchSelectorWithPseudos(el, innerSelector).length > 0),
+    text: (text) => {
+      const match = toMatcher(text); // regex-aware
+      const walker = document.createTreeWalker(
+        document.body,
+        NodeFilter.SHOW_TEXT,
+        null
+      );
+      let node;
+      while (node = walker.nextNode()) {
+        if (node.textContent && match(node.textContent)) {
+          return node.parentElement;
+        }
+      }
+      return null;
+    },
+    // plural version (used by querySelectorAll('text=...'))
+    textAll: (text) => {
+      const match = toMatcher(text);
+      const out = [];
+      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, null);
+      let node;
+      while (node = walker.nextNode()) {
+        if (node.textContent && match(node.textContent) && node.parentElement) {
+          out.push(node.parentElement);
+        }
+      }
+      return out;
+    },
+    // nth-match helpers
+    nthMatch: (baseSelector, innerSelector, indexStr) => {
+      const idx = Math.max(1, parseInt(indexStr, 10) || 1) - 1;
+      const bases = (baseSelector && baseSelector.trim())
+        ? Array.from(document.querySelectorAll(baseSelector))
+        : [document];
+      const all = [];
+      for (const b of bases) {
+        const nodes = matchSelectorWithPseudos(b, innerSelector);
+        for (const n of nodes) all.push(n);
+      }
+      return all[idx] || null;
+    },
+    nthMatchAll: (baseSelector, innerSelector, indexStr) => {
+      const el = window.__pwHelpers.nthMatch(baseSelector, innerSelector, indexStr);
+      return el ? [el] : [];
+    },
+    querySelector: (selector) => document.querySelector(processSelector(selector)),
+    querySelectorAll: (selector) => document.querySelectorAll(processSelector(selector))
+  };
+  })();
+})();
+`;
+// ----- Transformers -----
+export const transformHasText = ({ script, needsHelpers }) => {
+    if (!script.includes(":has-text("))
+        return { script, needsHelpers };
+    const result = transformSelectorCalls(script, (selector, method) => {
+        const parsed = parseFirstPseudo(selector);
+        if (parsed.kind !== "hasText")
+            return null;
+        // if base is empty, behave like :text() — search globally
+        if (isBlank(parsed.base)) {
+            return method === "all"
+                ? createHelperCall("hasTextAll", "*", parsed.text)
+                : createHelperCall("text", parsed.text);
+        }
+        return method === "all"
+            ? createHelperCall("hasTextAll", parsed.base, parsed.text)
+            : createHelperCall("hasText", parsed.base, parsed.text);
+    });
+    return {
+        script: result.output,
+        needsHelpers: needsHelpers || result.changed,
+    };
+};
+export const transformVisible = ({ script, needsHelpers }) => {
+    if (!script.includes(":visible"))
+        return { script, needsHelpers };
+    const result = transformSelectorCalls(script, (selector, method) => {
+        const parsed = parseFirstPseudo(selector);
+        if (parsed.kind !== "visible")
+            return null;
+        return method === "all"
+            ? createHelperCall("visibleAll", parsed.base)
+            : createHelperCall("visible", parsed.base);
+    });
+    return {
+        script: result.output,
+        needsHelpers: needsHelpers || result.changed,
+    };
+};
+export const transformText = ({ script, needsHelpers }) => {
+    if (!script.includes(":text("))
+        return { script, needsHelpers };
+    const result = transformSelectorCalls(script, (selector, method) => {
+        const parsed = parseFirstPseudo(selector);
+        if (parsed.kind !== "text")
+            return null;
+        if (isBlank(parsed.base)) {
+            return method === "all"
+                ? createHelperCall("hasTextAll", "*", parsed.text)
+                : createHelperCall("text", parsed.text);
+        }
+        return method === "all"
+            ? createHelperCall("hasTextAll", parsed.base, parsed.text)
+            : createHelperCall("hasText", parsed.base, parsed.text);
+    });
+    return {
+        script: result.output,
+        needsHelpers: needsHelpers || result.changed,
+    };
+};
+// Support playwright "text=..." engine (and "X >> text=...")
+export const transformTextEngine = ({ script, needsHelpers }) => {
+    const result = transformSelectorCalls(script, (selector, method) => {
+        const raw = selector.trim();
+        // Case 1: entire selector is text=...
+        const m1 = raw.match(/^\s*text\s*=\s*(.+)\s*$/);
+        if (m1) {
+            const arg = m1[1].trim();
+            const val = unwrapPossibleQuotesOrKeepRegex(arg);
+            return method === "all"
+                ? createHelperCall("textAll", val)
+                : createHelperCall("text", val);
+        }
+        // Case 2: X >> text=...
+        const m2 = raw.match(/^(.*?)>>\s*text\s*=\s*(.+)\s*$/);
+        if (m2) {
+            const base = m2[1].trim() || "*";
+            const arg = m2[2].trim();
+            const val = unwrapPossibleQuotesOrKeepRegex(arg);
+            return method === "all"
+                ? createHelperCall("hasTextAll", base, val)
+                : createHelperCall("hasText", base, val);
+        }
+        return null;
+    });
+    return {
+        script: result.output,
+        needsHelpers: needsHelpers || result.changed,
+    };
+};
+// Utility used only by transformTextEngine
+const unwrapPossibleQuotesOrKeepRegex = (s) => {
+    const q = s[0];
+    if ((q === '"' || q === "'" || q === "`") &&
+        s.length >= 2 &&
+        s[s.length - 1] === q)
+        return s.slice(1, -1);
+    // keep /.../flags as-is
+    return s;
+};
+export const transformContains = ({ script, needsHelpers }) => {
+    if (!script.includes(":contains("))
+        return { script, needsHelpers };
+    const result = transformSelectorCalls(script, (selector, method) => {
+        const parsed = parseFirstPseudo(selector);
+        if (parsed.kind !== "contains")
+            return null;
+        return method === "all"
+            ? createHelperCall("hasTextAll", parsed.base, parsed.text)
+            : createHelperCall("hasText", parsed.base, parsed.text);
+    });
+    return {
+        script: result.output,
+        needsHelpers: needsHelpers || result.changed,
+    };
+};
+export const transformHas = ({ script, needsHelpers }) => {
+    if (!script.includes(":has("))
+        return { script, needsHelpers };
+    const result = transformSelectorCalls(script, (selector, method) => {
+        const parsed = parseFirstPseudo(selector);
+        if (parsed.kind !== "has")
+            return null;
+        return method === "all"
+            ? createHelperCall("hasAll", parsed.base, parsed.inner)
+            : createHelperCall("has", parsed.base, parsed.inner);
+    });
+    return {
+        script: result.output,
+        needsHelpers: needsHelpers || result.changed,
+    };
+};
+// :nth-match(...)
+export const transformNthMatch = ({ script, needsHelpers }) => {
+    if (!script.includes(":nth-match("))
+        return { script, needsHelpers };
+    const result = transformSelectorCalls(script, (selector, method) => {
+        const parsed = parseFirstPseudo(selector);
+        if (parsed.kind !== "nthMatch")
+            return null;
+        // If base is empty, treat as global
+        const base = (parsed.base || "").trim();
+        if (method === "all")
+            return createHelperCall("nthMatchAll", base, parsed.inner, String(parsed.index));
+        return createHelperCall("nthMatch", base, parsed.inner, String(parsed.index));
+    });
+    return {
+        script: result.output,
+        needsHelpers: needsHelpers || result.changed,
+    };
+};
+export const transformDescendant = ({ script, needsHelpers }) => {
+    if (!script.includes(">>"))
+        return { script, needsHelpers };
+    const result = transformSelectorCalls(script, (selector, method) => {
+        if (!selector.includes(">>"))
+            return null;
+        return method === "all"
+            ? createHelperCall("querySelectorAll", selector)
+            : createHelperCall("querySelector", selector);
+    });
+    return {
+        script: result.output,
+        needsHelpers: needsHelpers || result.changed,
+    };
+};
+// Inject helpers if needed
+export const injectHelpers = ({ script, needsHelpers }) => needsHelpers
+    ? {
+        script: helperFunctions +
+            "\n/* Playwright selectors automatically transformed */\n" +
+            script,
+        needsHelpers,
+    }
+    : { script, needsHelpers };
+// Main transformation pipeline
+export const transformPlaywrightSyntax = (script) => pipe({ script, needsHelpers: false }, transformHas, transformHasText, transformVisible, transformText, transformContains, transformNthMatch, transformTextEngine, transformDescendant, injectHelpers);
+// Memoized version for performance
+export const memoizedTransform = memoize(transformPlaywrightSyntax);
+// Public API
+export const transformScript = (originalScript) => {
+    const result = memoizedTransform(originalScript);
+    return result.script;
+};
+// Testing utilities
+export const testTransformation = (input, expected) => {
+    const { script } = transformPlaywrightSyntax(input);
+    return script === expected;
+};
+const transformSelectorCalls = (code, rewriter) => {
+    const start = skipLexer.parse(code);
+    if (!start)
+        return { output: code, changed: false };
+    const parsed = PROGRAM.parse(start);
+    if (!parsed.successful || parsed.candidates.length === 0)
+        return { output: code, changed: false };
+    const segments = parsed.candidates[0].result;
+    let changed = false;
+    const out = [];
+    for (const seg of segments) {
+        if (seg.kind === "call") {
+            const replacement = rewriter(seg.selector, seg.method);
+            if (replacement) {
+                out.push(replacement);
+                changed = true;
+            }
+            else {
+                out.push(seg.original);
+            }
+        }
+        else {
+            out.push(seg.text);
+        }
+    }
+    return { output: out.join(""), changed };
+};

package/lib/program.js

@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Option, program } from "commander";
+import { contextFactory } from "./browserContextFactory.js";
+import { BrowserServerBackend } from "./browserServerBackend.js";
+import { commaSeparatedList, resolveCLIConfig, semicolonSeparatedList, } from "./config.js";
+import { Context } from "./context.js";
+import { ExtensionContextFactory } from "./extension/extensionContextFactory.js";
+import { InProcessTransport } from "./mcp/inProcessTransport.js";
+import { ProxyBackend } from "./mcp/proxyBackend.js";
+import * as mcpServer from "./mcp/server.js";
+import * as mcpTransport from "./mcp/transport.js";
+import { packageJSON } from "./utils/package.js";
+program
+    .version("Version " + packageJSON.version)
+    .name(packageJSON.name)
+    .option("--allowed-origins <origins>", "semicolon-separated list of origins to allow the browser to request. Default is to allow all.", semicolonSeparatedList)
+    .option("--blocked-origins <origins>", "semicolon-separated list of origins to block the browser from requesting. Blocklist is evaluated before allowlist. If used without the allowlist, requests not matching the blocklist are still allowed.", semicolonSeparatedList)
+    .option("--block-service-workers", "block service workers")
+    .option("--browser <browser>", "browser or chrome channel to use, possible values: chrome, firefox, webkit, msedge.")
+    .option("--caps <caps>", "comma-separated list of additional capabilities to enable, possible values: vision, pdf.", commaSeparatedList)
+    .option("--cdp-endpoint <endpoint>", "CDP endpoint to connect to.")
+    .option("--config <path>", "path to the configuration file.")
+    .option("--device <device>", 'device to emulate, for example: "iPhone 15"')
+    .option("--executable-path <path>", "path to the browser executable.")
+    .option("--headless", "run browser in headless mode, headed by default")
+    .option("--host <host>", "host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.")
+    .option("--ignore-https-errors", "ignore https errors")
+    .option("--init-script <path>", "path to a JavaScript file to inject into all pages using addInitScript.")
+    .option("--isolated", "keep the browser profile in memory, do not save it to disk.")
+    .option("--image-responses <mode>", 'whether to send image responses to the client. Can be "allow" or "omit", Defaults to "allow".')
+    .option("--no-sandbox", "disable the sandbox for all process types that are normally sandboxed.")
+    .option("--output-dir <path>", "path to the directory for output files.")
+    .option("--port <port>", "port to listen on for SSE transport.")
+    .option("--proxy-bypass <bypass>", 'comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"')
+    .option("--proxy-server <proxy>", 'specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"')
+    .option("--save-session", "Whether to save the Playwright MCP session into the output directory.")
+    .option("--save-trace", "Whether to save the Playwright Trace of the session into the output directory.")
+    .option("--storage-state <path>", "path to the storage state file for isolated sessions.")
+    .option("--user-agent <ua string>", "specify user agent string")
+    .option("--user-data-dir <path>", "path to the user data directory. If not specified, a temporary directory will be created.")
+    .option("--viewport-size <size>", 'specify browser viewport size in pixels, for example "1280, 720"')
+    .option("--window-position <x,y>", 'specify Chrome window position in pixels, for example "100,200"')
+    .option("--window-size <width,height>", 'specify Chrome window size in pixels, for example "1280,720"')
+    .option("--app <url>", "launch browser in app mode with the specified URL")
+    .addOption(new Option("--extension", 'Connect to a running browser instance (Edge/Chrome only). Requires the "Playwright MCP Bridge" browser extension to be installed.').hideHelp())
+    .addOption(new Option("--connect-tool", "Allow to switch between different browser connection methods.").hideHelp())
+    .addOption(new Option("--loop-tools", "Run loop tools").hideHelp())
+    .addOption(new Option("--vision", "Legacy option, use --caps=vision instead").hideHelp())
+    .action(async (options) => {
+    setupExitWatchdog();
+    if (options.vision) {
+        // eslint-disable-next-line no-console
+        console.error("The --vision option is deprecated, use --caps=vision instead");
+        options.caps = "vision";
+    }
+    const config = await resolveCLIConfig(options);
+    if (options.extension) {
+        const contextFactory = createExtensionContextFactory(config);
+        const serverBackendFactory = () => new BrowserServerBackend(config, contextFactory);
+        await mcpTransport.start(serverBackendFactory, config.server);
+        return;
+    }
+    const browserContextFactory = contextFactory(config);
+    const providers = [
+        mcpProviderForBrowserContextFactory(config, browserContextFactory),
+    ];
+    if (options.connectTool)
+        providers.push(mcpProviderForBrowserContextFactory(config, createExtensionContextFactory(config)));
+    await mcpTransport.start(() => new ProxyBackend(providers), config.server);
+});
+function setupExitWatchdog() {
+    let isExiting = false;
+    const handleExit = async () => {
+        if (isExiting)
+            return;
+        isExiting = true;
+        setTimeout(() => process.exit(0), 15000);
+        await Context.disposeAll();
+        process.exit(0);
+    };
+    process.stdin.on("close", handleExit);
+    process.on("SIGINT", handleExit);
+    process.on("SIGTERM", handleExit);
+}
+function createExtensionContextFactory(config) {
+    return new ExtensionContextFactory(config.browser.launchOptions.channel || "chrome", config.browser.userDataDir);
+}
+function mcpProviderForBrowserContextFactory(config, browserContextFactory) {
+    return {
+        name: browserContextFactory.name,
+        description: browserContextFactory.description,
+        connect: async () => {
+            const server = mcpServer.createServer(new BrowserServerBackend(config, browserContextFactory), false);
+            return new InProcessTransport(server);
+        },
+    };
+}
+void program.parseAsync(process.argv);