@wordbricks/playwright-mcp 0.1.20 → 0.1.23

package/lib/mcp/transport.js

@@ -1,181 +0,0 @@
-/**
- * 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 crypto from 'crypto';
-import debug from 'debug';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SUPPORTED_PROTOCOL_VERSIONS, LATEST_PROTOCOL_VERSION, isInitializeRequest, isJSONRPCRequest } from '@modelcontextprotocol/sdk/types.js';
-import contentType from 'content-type';
-import getRawBody from 'raw-body';
-import { pipe } from '@fxts/core';
-import { httpAddressToString, startHttpServer } from '../utils/httpServer.js';
-import * as mcpServer from './server.js';
-// @see node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js
-const MAXIMUM_MESSAGE_SIZE = '4mb';
-export async function start(serverBackendFactory, options) {
-    if (options.port !== undefined) {
-        const httpServer = await startHttpServer(options);
-        startHttpTransport(httpServer, serverBackendFactory);
-    }
-    else {
-        await startStdioTransport(serverBackendFactory);
-    }
-}
-async function startStdioTransport(serverBackendFactory) {
-    await mcpServer.connect(serverBackendFactory, new StdioServerTransport(), false);
-}
-const testDebug = debug('pw:mcp:test');
-async function handleStreamableReinitiate(req, res, transport, serverBackendFactory, sessionId, serverInfos) {
-    const ct = req.headers['content-type'];
-    if (!ct || !ct.includes('application/json')) {
-        res.writeHead(415).end(JSON.stringify({
-            jsonrpc: '2.0',
-            error: {
-                code: -32000,
-                message: 'Unsupported Media Type: Content-Type must be application/json'
-            },
-            id: null
-        }));
-        return;
-    }
-    const parsedCt = contentType.parse(ct);
-    const encoding = parsedCt.parameters.charset;
-    const body = await pipe(getRawBody(req, {
-        limit: MAXIMUM_MESSAGE_SIZE,
-        encoding,
-    }), raw => raw.toString(), JSON.parse);
-    const msg = Array.isArray(body) ? (body.length === 1 ? body[0] : undefined) : body;
-    if (body && isJSONRPCRequest(msg) && isInitializeRequest(msg)) {
-        const requestedVersion = msg.params.protocolVersion;
-        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
-        const headers = {
-            'Content-Type': 'text/event-stream',
-            'Mcp-Session-Id': transport.sessionId
-        };
-        res.writeHead(200, headers);
-        const info = serverInfos.get(sessionId) || (() => {
-            const backend = serverBackendFactory();
-            return { name: backend.name, version: backend.version };
-        })();
-        const response = {
-            jsonrpc: '2.0',
-            id: msg.id,
-            result: {
-                protocolVersion,
-                capabilities: { tools: {} },
-                serverInfo: info,
-            }
-        };
-        res.write(`event: message\n`);
-        res.write(`data: ${JSON.stringify(response)}\n\n`);
-        res.end();
-        return;
-    }
-    return await transport.handleRequest(req, res, body);
-}
-async function handleSSE(serverBackendFactory, req, res, url, sessions) {
-    if (req.method === 'POST') {
-        const sessionId = url.searchParams.get('sessionId');
-        if (!sessionId) {
-            res.statusCode = 400;
-            return res.end('Missing sessionId');
-        }
-        const transport = sessions.get(sessionId);
-        if (!transport) {
-            res.statusCode = 404;
-            return res.end('Session not found');
-        }
-        return await transport.handlePostMessage(req, res);
-    }
-    else if (req.method === 'GET') {
-        const transport = new SSEServerTransport('/sse', res);
-        sessions.set(transport.sessionId, transport);
-        testDebug(`create SSE session: ${transport.sessionId}`);
-        await mcpServer.connect(serverBackendFactory, transport, false);
-        res.on('close', () => {
-            testDebug(`delete SSE session: ${transport.sessionId}`);
-            sessions.delete(transport.sessionId);
-        });
-        return;
-    }
-    res.statusCode = 405;
-    res.end('Method not allowed');
-}
-// Streamable transport: 'initialize' handling per MCP Lifecycle (Initialization) https://modelcontextprotocol.io/specification/draft/basic/lifecycle#initialization
-async function handleStreamable(serverBackendFactory, req, res, sessions, serverInfos) {
-    const sessionId = req.headers['mcp-session-id'];
-    if (sessionId) {
-        const transport = sessions.get(sessionId);
-        if (!transport) {
-            res.statusCode = 404;
-            res.end('Session not found');
-            return;
-        }
-        if (req.method === 'POST')
-            return await handleStreamableReinitiate(req, res, transport, serverBackendFactory, sessionId, serverInfos);
-        return await transport.handleRequest(req, res);
-    }
-    if (req.method === 'POST') {
-        const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => crypto.randomUUID(),
-            onsessioninitialized: async (sessionId) => {
-                testDebug(`create http session: ${transport.sessionId}`);
-                const serverInfo = await mcpServer.connect(serverBackendFactory, transport, false);
-                sessions.set(sessionId, transport);
-                serverInfos.set(sessionId, serverInfo);
-            }
-        });
-        transport.onclose = () => {
-            if (!transport.sessionId)
-                return;
-            sessions.delete(transport.sessionId);
-            serverInfos.delete(transport.sessionId);
-            testDebug(`delete http session: ${transport.sessionId}`);
-        };
-        await transport.handleRequest(req, res);
-        return;
-    }
-    res.statusCode = 400;
-    res.end('Invalid request');
-}
-function startHttpTransport(httpServer, serverBackendFactory) {
-    const sseSessions = new Map();
-    const streamableSessions = new Map();
-    const streamableServerInfos = new Map();
-    httpServer.on('request', async (req, res) => {
-        const url = new URL(`http://localhost${req.url}`);
-        if (url.pathname.startsWith('/sse'))
-            await handleSSE(serverBackendFactory, req, res, url, sseSessions);
-        else
-            await handleStreamable(serverBackendFactory, req, res, streamableSessions, streamableServerInfos);
-    });
-    const url = httpAddressToString(httpServer.address());
-    const message = [
-        `Listening on ${url}`,
-        'Put this in your client config:',
-        JSON.stringify({
-            'mcpServers': {
-                'playwright': {
-                    'url': `${url}/mcp`
-                }
-            }
-        }, undefined, 2),
-        'For legacy SSE transport support, you can use the /sse endpoint instead.',
-    ].join('\n');
-    // eslint-disable-next-line no-console
-    console.error(message);
-}

package/lib/playwrightTransformer.js

@@ -1,497 +0,0 @@
-import { pipe, memoize } from '@fxts/core';
-import { buildLexer, apply, seq, alt_sc, rep_sc, tok, kmid, extractByTokenRange, makeParserModule } 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, /^[^]/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 = 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, /^\/\*[^]*?\*\//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, /^[^]/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 };
-};