@yezack/chrome-devtools-mcp-108 0.0.0-stage → 1.10.2

package/build/src/tools/screenshot.js

@@ -0,0 +1,277 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+async function getSourceBox(page, element, fullPage) {
+    if (element) {
+        const viewport = page.viewport();
+        const [box, devicePixelRatio] = await Promise.all([
+            element.boundingBox(),
+            viewport
+                ? (viewport.deviceScaleFactor ?? 1)
+                : page.evaluate(() => window.devicePixelRatio),
+        ]);
+        return box ? { ...box, devicePixelRatio } : undefined;
+    }
+    if (fullPage) {
+        const dims = await page.evaluate(() => ({
+            width: Math.max(document.documentElement.scrollWidth, document.body?.scrollWidth ?? 0),
+            height: Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0),
+            devicePixelRatio: window.devicePixelRatio,
+        }));
+        if (dims.width <= 0 || dims.height <= 0) {
+            return undefined;
+        }
+        return {
+            x: 0,
+            y: 0,
+            width: dims.width,
+            height: dims.height,
+            devicePixelRatio: dims.devicePixelRatio,
+        };
+    }
+    const viewport = page.viewport();
+    if (viewport) {
+        return {
+            x: 0,
+            y: 0,
+            width: viewport.width,
+            height: viewport.height,
+            devicePixelRatio: viewport.deviceScaleFactor ?? 1,
+        };
+    }
+    // The browser is launched and connected with `defaultViewport: null`, so
+    // `page.viewport()` stays null until something emulates one. Fall back to the
+    // window's own dimensions, which is the area a viewport screenshot captures.
+    const dims = await page.evaluate(() => ({
+        width: window.innerWidth,
+        height: window.innerHeight,
+        devicePixelRatio: window.devicePixelRatio,
+    }));
+    if (dims.width <= 0 || dims.height <= 0) {
+        return undefined;
+    }
+    return {
+        x: 0,
+        y: 0,
+        width: dims.width,
+        height: dims.height,
+        devicePixelRatio: dims.devicePixelRatio,
+    };
+}
+function computeDownscaleClip(box, maxWidth, maxHeight) {
+    const widthScale = maxWidth !== undefined
+        ? Math.min(1, maxWidth / (box.width * box.devicePixelRatio))
+        : 1;
+    const heightScale = maxHeight !== undefined
+        ? Math.min(1, maxHeight / (box.height * box.devicePixelRatio))
+        : 1;
+    const scale = Math.min(widthScale, heightScale);
+    if (scale >= 1) {
+        return undefined;
+    }
+    // Skip degenerate sub-pixel results.
+    if (Math.round(box.width * box.devicePixelRatio * scale) < 1 ||
+        Math.round(box.height * box.devicePixelRatio * scale) < 1) {
+        return undefined;
+    }
+    return {
+        x: box.x,
+        y: box.y,
+        width: box.width,
+        height: box.height,
+        scale,
+    };
+}
+export const screenshot = definePageTool((args) => {
+    const { screenshotFormat, screenshotQuality, screenshotMaxWidth, screenshotMaxHeight, } = args;
+    const defaultFormat = screenshotFormat ?? 'png';
+    return {
+        name: 'take_screenshot',
+        description: `Take a screenshot of the page or element.`,
+        annotations: {
+            category: ToolCategory.DEBUGGING,
+            // Not read-only due to filePath param.
+            readOnlyHint: false,
+        },
+        schema: {
+            format: zod
+                .enum(['png', 'jpeg', 'webp'])
+                .default(defaultFormat)
+                .describe(`Type of format to save the screenshot as. Default is "${defaultFormat}"`),
+            quality: zod
+                .number()
+                .min(0)
+                .max(100)
+                .optional()
+                .describe('Compression quality for JPEG and WebP formats (0-100). Higher values mean better quality but larger file sizes. Ignored for PNG format.'),
+            uid: zod
+                .string()
+                .optional()
+                .describe('The uid of an element on the page from the page content snapshot. If omitted, takes a page screenshot.'),
+            fullPage: zod
+                .boolean()
+                .optional()
+                .describe('If set to true takes a screenshot of the full page instead of the currently visible viewport. Incompatible with uid.'),
+            filePath: zod
+                .string()
+                .optional()
+                .describe('The absolute path, or a path relative to the current working directory, to save the screenshot to instead of attaching it to the response.'),
+        },
+        blockedByDialog: true,
+        verifyFilesSchema: {
+            filePath: true,
+        },
+        handler: async (request, response, context) => {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (request.params.uid && request.params.fullPage) {
+                    throw new Error('Providing both "uid" and "fullPage" is not allowed.');
+                }
+                const page = request.page.pptrPage;
+                const element = __addDisposableResource(env_1, request.params.uid
+                    ? await request.page.getElementByUid(request.params.uid)
+                    : undefined, false);
+                const format = request.params.format;
+                const quality = format === 'png'
+                    ? undefined
+                    : (request.params.quality ?? screenshotQuality);
+                const fullPage = request.params.fullPage ?? false;
+                // `getElementByUid` mints a fresh ElementHandle per call, so dispose it
+                // once the capture is done to avoid leaking a remote object for the life
+                // of the page's execution context.
+                let screenshot;
+                // Compute a downscale clip when --screenshot-max-width or
+                // --screenshot-max-height is set and the source exceeds either bound.
+                // The smaller scale factor wins so both bounds are respected while
+                // preserving aspect ratio.
+                let clip;
+                if (screenshotMaxWidth !== undefined ||
+                    screenshotMaxHeight !== undefined) {
+                    const box = await getSourceBox(page, element, fullPage);
+                    if (box) {
+                        clip = computeDownscaleClip(box, screenshotMaxWidth, screenshotMaxHeight);
+                    }
+                }
+                if (clip) {
+                    // page.screenshot with clip lets the CDP scale param downscale the
+                    // capture for viewport, full-page and element shots alike. We rely on
+                    // Puppeteer's default of captureBeyondViewport=true when a clip is
+                    // present so element/full-page captures below the fold still work.
+                    screenshot = await page.screenshot({
+                        type: format,
+                        quality,
+                        optimizeForSpeed: true,
+                        clip,
+                    });
+                }
+                else if (element) {
+                    screenshot = await element.screenshot({
+                        type: format,
+                        quality,
+                        optimizeForSpeed: true,
+                    });
+                }
+                else {
+                    screenshot = await page.screenshot({
+                        type: format,
+                        fullPage,
+                        quality,
+                        optimizeForSpeed: true,
+                    });
+                }
+                if (request.params.uid) {
+                    response.appendResponseLine(`Took a screenshot of node with uid "${request.params.uid}".`);
+                }
+                else if (fullPage) {
+                    response.appendResponseLine('Took a screenshot of the full current page.');
+                }
+                else {
+                    response.appendResponseLine("Took a screenshot of the current page's viewport.");
+                }
+                // Narrow `format` at the point of use: in the factory form of
+                // definePageTool TS widens the Schema generic, which loses the literal
+                // union from zod.enum on request.params.format.
+                const extension = format === 'jpeg' ? '.jpeg' : format === 'webp' ? '.webp' : '.png';
+                if (request.params.filePath) {
+                    const result = await context.saveFile(screenshot, request.params.filePath, extension);
+                    response.appendResponseLine(`Saved screenshot to ${result.filename}.`);
+                }
+                else if (screenshot.length >= 2_000_000) {
+                    const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot${extension}`);
+                    response.appendResponseLine(`Saved screenshot to ${filepath}.`);
+                }
+                else {
+                    response.attachImage({
+                        mimeType: `image/${format}`,
+                        data: Buffer.from(screenshot).toString('base64'),
+                    });
+                }
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        },
+    };
+});
+//# sourceMappingURL=screenshot.js.map

package/build/src/tools/script.js

@@ -0,0 +1,232 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { defineTool, pageIdSchema } from './ToolDefinition.js';
+export const evaluateScript = defineTool((cliArgs) => {
+    return {
+        name: 'evaluate_script',
+        description: `Evaluate a JavaScript function inside the target page${cliArgs.categoryExtensions ? ' or service worker' : ''}. Returns the response as JSON, so returned values have to be JSON-serializable.`,
+        annotations: {
+            category: ToolCategory.DEBUGGING,
+            readOnlyHint: false,
+            conditions: ['javascriptEvaluation'],
+        },
+        schema: {
+            ...(cliArgs.pageIdRouting
+                ? cliArgs.categoryExtensions
+                    ? {
+                        pageId: zod
+                            .number()
+                            .optional()
+                            .describe('Targets a specific page by ID. Required when not evaluating in a service worker.'),
+                    }
+                    : pageIdSchema
+                : {}),
+            function: zod.string().describe(`A JavaScript function declaration to be executed by the tool in the target page.
+Example without arguments: \`() => document.title\` or \`async () => await fetch("example.com")\`.
+Example with arguments: \`(el) => el.innerText\`
+`),
+            args: zod
+                .array(zod
+                .string()
+                .describe('The uid of an element on the page from the page content snapshot'))
+                .optional()
+                .describe(`An optional list of arguments to pass to the function.`),
+            filePath: zod
+                .string()
+                .optional()
+                .describe('The absolute or relative path to a file to save the script output to. If omitted, the output is returned inline.'),
+            dialogAction: zod
+                .string()
+                .optional()
+                .describe('Handle dialogs while execution. "accept", "dismiss", or string for response of window.prompt. Defaults to accept.'),
+            waitForStableDom: zod
+                .boolean()
+                .optional()
+                .describe('Whether to wait for the DOM to settle. Pass false if the script only reads data. Defaults to true.'),
+            ...(cliArgs.categoryExtensions
+                ? {
+                    serviceWorkerId: zod
+                        .string()
+                        .optional()
+                        .describe(`The optional service worker id to evaluate the script in. If provided, 'pageId' should be omitted. Note: 'args' (element UIDs) cannot be used when evaluating in a service worker.`),
+                }
+                : {}),
+        },
+        blockedByDialog: true,
+        verifyFilesSchema: {
+            filePath: true,
+        },
+        handler: async (request, response, context) => {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const { serviceWorkerId, args: uidArgs, function: fnString, pageId, dialogAction, filePath, waitForStableDom, } = request.params;
+                if (cliArgs.categoryExtensions && serviceWorkerId) {
+                    if (uidArgs && uidArgs.length > 0) {
+                        throw new Error('args (element uids) cannot be used when evaluating in a service worker.');
+                    }
+                    if (pageId) {
+                        throw new Error('specify either a pageId or a serviceWorkerId.');
+                    }
+                    const worker = await getWebWorker(context, serviceWorkerId);
+                    const result = await context
+                        .getSelectedMcpPage()
+                        .waitForEventsAfterAction(async () => {
+                        await performEvaluation(worker, fnString, [], response, {
+                            filePath,
+                            context,
+                        });
+                    }, 
+                    // Service workers cannot interact with the DOM, so never wait for it.
+                    { handleDialog: dialogAction ?? 'accept', waitForStableDom: false });
+                    if (result.dialogHandled) {
+                        context.getSelectedMcpPage().clearDialog();
+                    }
+                    response.attachWaitForResult(result);
+                    return;
+                }
+                if (cliArgs.categoryExtensions && cliArgs.pageIdRouting && !pageId) {
+                    throw new Error('specify either a pageId or a serviceWorkerId.');
+                }
+                const mcpPage = cliArgs.pageIdRouting && request.params.pageId
+                    ? context.getPageById(request.params.pageId)
+                    : context.getSelectedMcpPage();
+                const page = mcpPage.pptrPage;
+                const args = [];
+                const stack = __addDisposableResource(env_1, new DisposableStack(), false);
+                const frames = new Set();
+                for (const uid of uidArgs ?? []) {
+                    const handle = await mcpPage.getElementByUid(uid);
+                    frames.add(handle.frame);
+                    stack.use(handle);
+                    args.push(handle);
+                }
+                const evaluatable = await getPageOrFrame(page, frames);
+                const result = await mcpPage.waitForEventsAfterAction(async () => {
+                    await performEvaluation(evaluatable, fnString, args, response, {
+                        filePath,
+                        context,
+                    });
+                }, { handleDialog: dialogAction ?? 'accept', waitForStableDom });
+                response.attachWaitForResult(result);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        },
+    };
+});
+const performEvaluation = async (evaluatable, fnString, args, response, options) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const fn = __addDisposableResource(env_2, await evaluatable.evaluateHandle(`(${fnString})`), false);
+        const result = await evaluatable.evaluate(async (fn, ...args) => {
+            // @ts-expect-error no types for function fn
+            return JSON.stringify(await fn(...args));
+        }, fn, ...args);
+        if (options?.filePath) {
+            const data = new TextEncoder().encode(result ?? 'undefined');
+            const { filename } = await options.context.saveFile(data, options.filePath, '.json');
+            response.appendResponseLine(`Script ran on page. Output saved to ${filename}.`);
+        }
+        else {
+            response.appendResponseLine('Script ran on page and returned:');
+            response.appendResponseLine('```json');
+            response.appendResponseLine(`${result}`);
+            response.appendResponseLine('```');
+        }
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
+};
+const getPageOrFrame = async (page, frames) => {
+    let pageOrFrame;
+    // We can't evaluate the element handle across frames
+    if (frames.size > 1) {
+        throw new Error("Elements from different frames can't be evaluated together.");
+    }
+    else {
+        pageOrFrame = [...frames.values()][0] ?? page;
+    }
+    return pageOrFrame;
+};
+const getWebWorker = async (context, serviceWorkerId) => {
+    const serviceWorkers = context.getExtensionServiceWorkers();
+    const serviceWorker = serviceWorkers.find((sw) => context.getExtensionServiceWorkerId(sw) === serviceWorkerId);
+    if (serviceWorker && serviceWorker.target) {
+        const worker = await serviceWorker.target.worker();
+        if (!worker) {
+            throw new Error('Service worker target not found.');
+        }
+        return worker;
+    }
+    else {
+        throw new Error('Service worker not found.');
+    }
+};
+//# sourceMappingURL=script.js.map

package/build/src/tools/slim/tools.js

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../../third_party/index.js';
+import { ToolCategory } from '../categories.js';
+import { definePageTool } from '../ToolDefinition.js';
+import { validateUrl } from '../../utils/url.js';
+export const screenshot = definePageTool(() => ({
+    name: 'screenshot',
+    description: `Takes a screenshot`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        // Not read-only due to filePath param.
+        readOnlyHint: false,
+    },
+    schema: {},
+    blockedByDialog: true,
+    verifyFilesSchema: {},
+    handler: async (request, response, context) => {
+        const page = request.page;
+        const screenshot = await page.pptrPage.screenshot({
+            type: 'png',
+            optimizeForSpeed: true,
+        });
+        const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot.png`);
+        response.appendResponseLine(filepath);
+    },
+}));
+export const navigate = definePageTool((args) => {
+    return {
+        name: 'navigate',
+        description: `Loads a URL`,
+        annotations: {
+            category: ToolCategory.NAVIGATION,
+            readOnlyHint: false,
+        },
+        schema: {
+            url: zod.string().describe('URL to navigate to'),
+        },
+        blockedByDialog: false,
+        verifyFilesSchema: {},
+        handler: async (request, response) => {
+            validateUrl(request.params.url, {
+                javascriptEvaluation: args?.javascriptEvaluation,
+                categoryExtensions: args?.categoryExtensions,
+            });
+            const page = request.page;
+            const options = {
+                timeout: 30_000,
+            };
+            const dialogHandler = (dialog) => {
+                if (dialog.type() === 'beforeunload') {
+                    response.appendResponseLine(`Accepted a beforeunload dialog.`);
+                    void dialog.accept();
+                    // We are not going to report the dialog like regular dialogs.
+                    page.clearDialog();
+                }
+            };
+            page.pptrPage.on('dialog', dialogHandler);
+            try {
+                await page.pptrPage.goto(request.params.url, options);
+                response.appendResponseLine(`Navigated to ${page.pptrPage.url()}.`);
+            }
+            finally {
+                page.pptrPage.off('dialog', dialogHandler);
+            }
+        },
+    };
+});
+export const evaluate = definePageTool(() => ({
+    name: 'evaluate',
+    description: `Evaluates a JavaScript script`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: false,
+        conditions: ['javascriptEvaluation'],
+    },
+    schema: {
+        script: zod.string().describe(`JS script to run on the page`),
+    },
+    blockedByDialog: true,
+    verifyFilesSchema: {},
+    handler: async (request, response) => {
+        const page = request.page;
+        try {
+            const result = await page.pptrPage.evaluate(request.params.script);
+            response.appendResponseLine(JSON.stringify(result));
+        }
+        catch (err) {
+            response.appendResponseLine(String(err.message));
+        }
+    },
+}));
+//# sourceMappingURL=tools.js.map

package/build/src/tools/snapshot.js

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool, timeoutSchema } from './ToolDefinition.js';
+export const takeSnapshot = definePageTool(() => ({
+    name: 'take_snapshot',
+    description: `Take a text snapshot of the target page based on the a11y tree. The snapshot lists page elements along with a unique
+identifier (uid). Always use the latest snapshot. Prefer taking a snapshot over taking a screenshot. The snapshot indicates the element selected
+in the DevTools Elements panel (if any).`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        // Not read-only due to filePath param.
+        readOnlyHint: false,
+    },
+    schema: {
+        verbose: zod
+            .boolean()
+            .optional()
+            .describe('Whether to include all possible information available in the full a11y tree. Default is false.'),
+        filePath: zod
+            .string()
+            .optional()
+            .describe('The absolute path, or a path relative to the current working directory, to save the snapshot to instead of attaching it to the response.'),
+    },
+    blockedByDialog: true,
+    verifyFilesSchema: {
+        filePath: true,
+    },
+    handler: async (request, response) => {
+        response.includeSnapshot({
+            verbose: request.params.verbose ?? false,
+            filePath: request.params.filePath,
+        });
+    },
+}));
+export const waitFor = definePageTool(() => ({
+    name: 'wait_for',
+    description: `Wait for the specified text to appear on the selected page.`,
+    annotations: {
+        category: ToolCategory.NAVIGATION,
+        readOnlyHint: true,
+    },
+    schema: {
+        text: zod
+            .array(zod.string())
+            .min(1)
+            .describe('Non-empty list of texts. Resolves when any value appears on the page.'),
+        ...timeoutSchema,
+    },
+    blockedByDialog: true,
+    verifyFilesSchema: {},
+    handler: async (request, response) => {
+        const page = request.page;
+        await page.waitForTextOnPage(request.params.text, request.params.timeout);
+        response.appendResponseLine(`Element matching one of ${JSON.stringify(request.params.text)} found.`);
+        response.includeSnapshot();
+    },
+}));
+//# sourceMappingURL=snapshot.js.map