@wordbricks/playwright-mcp 0.1.20 → 0.1.23

package/lib/tools/repl.js

@@ -1,402 +0,0 @@
-import { readFileSync } from 'fs';
-import { join } from 'path';
-import { z } from 'zod';
-import debug from 'debug';
-import ms from 'ms';
-import { defineTabTool } from './tool.js';
-import * as javascript from '../utils/codegen.js';
-import { truncate } from '../utils/truncate.js';
-import { transformScript } from '../playwrightTransformer.js';
-const EVALUATE_TIMEOUT_MS = ms('30s');
-const debugLog = debug('pw:mcp:repl');
-const replSchema = z.object({
-    script: z
-        .string()
-        .describe('JavaScript code to execute in the browser console.'),
-});
-const contextStates = new WeakMap();
-function getPageState(page) {
-    let pageStates = contextStates.get(page.context());
-    if (!pageStates) {
-        pageStates = new WeakMap();
-        contextStates.set(page.context(), pageStates);
-    }
-    let state = pageStates.get(page);
-    if (!state) {
-        state = {
-            librariesInjected: false,
-            consoleListenerSetup: false,
-        };
-        pageStates.set(page, state);
-    }
-    return state;
-}
-// Helpers
-async function setupConsoleCapture(page) {
-    await page.evaluate(() => {
-        // Store original console methods
-        window.__originalConsole = {
-            // eslint-disable-next-line no-console
-            log: console.log,
-            // eslint-disable-next-line no-console
-            error: console.error,
-            // eslint-disable-next-line no-console
-            warn: console.warn,
-            // eslint-disable-next-line no-console
-            info: console.info,
-        };
-        // Create array to store console outputs
-        window.__consoleOutputs = [];
-        // Override console methods to capture output
-        const captureConsole = (method) => {
-            const handler = function (...args) {
-                // Call original method
-                window.__originalConsole?.[method](...args);
-                // Capture output
-                const output = args
-                    .map(arg => {
-                    if (arg === undefined)
-                        return 'undefined';
-                    if (arg === null)
-                        return 'null';
-                    if (typeof arg === 'object') {
-                        try {
-                            return JSON.stringify(arg);
-                        }
-                        catch {
-                            return String(arg);
-                        }
-                    }
-                    return String(arg);
-                })
-                    .join(' ');
-                window.__consoleOutputs?.push(output);
-            };
-            Object.defineProperty(console, method, { value: handler, configurable: true, writable: true });
-        };
-        captureConsole('log');
-        captureConsole('error');
-        captureConsole('warn');
-        captureConsole('info');
-    });
-}
-async function injectLibraries(cdpSession) {
-    try {
-        const nodeModulesPath = join(process.cwd(), 'node_modules');
-        // Inject utility libraries into the page context
-        const json5Code = readFileSync(join(nodeModulesPath, 'json5', 'dist', 'index.min.js'), 'utf8');
-        const jsonpathCode = readFileSync(join(nodeModulesPath, 'jsonpath-plus', 'dist', 'index-browser-umd.min.cjs'), 'utf8');
-        const lodashCode = readFileSync(join(nodeModulesPath, 'lodash', 'lodash.min.js'), 'utf8');
-        // Inject libraries using CDP
-        await cdpSession.send('Runtime.evaluate', {
-            expression: `
-        (function(){
-          try {
-            window.mcp = window.mcp || {};
-            window.mcp.helpers = window.mcp.helpers || {};
-
-            var prev_ = window._;
-            var prevJSON5 = window.JSON5;
-            var prevJSONPath = window.JSONPath;
-
-            // Load libs
-            ${json5Code}
-            ${jsonpathCode}
-            ${lodashCode}
-
-            // Capture injected references
-            var injectedJSON5 = window.JSON5;
-            var injectedJSONPathFn = (window.JSONPath && window.JSONPath.JSONPath) ? window.JSONPath.JSONPath : window.JSONPath;
-            var injectedLodash = window._;
-
-            // Restore previous globals to avoid conflicts
-            if (typeof prevJSON5 !== 'undefined') window.JSON5 = prevJSON5;
-            if (typeof prevJSONPath !== 'undefined') window.JSONPath = prevJSONPath;
-            if (injectedLodash && injectedLodash.noConflict) {
-              injectedLodash = injectedLodash.noConflict();
-            } else if (typeof prev_ !== 'undefined') {
-              window._ = prev_;
-            }
-
-            // Expose helpers under a simple namespace
-            window.mcp.JSON5 = injectedJSON5;
-            window.mcp.JSONPath = injectedJSONPathFn;
-            window.mcp._ = injectedLodash;
-
-            // GraphQL helpers
-            if (!window.mcp.GraphQLClient) {
-              class GraphQLClient {
-                constructor(endpoint, options = {}) {
-                  this.endpoint = endpoint;
-                  this.options = options || {};
-                }
-                async request(document, variables, requestHeaders) {
-                  const method = ((this.options.method || 'POST')).toUpperCase();
-                  const headers = Object.assign(
-                    { 'content-type': 'application/json' },
-                    this.options.headers || {},
-                    requestHeaders || {}
-                  );
-                  const bodyObj = {
-                    query: typeof document === 'string' ? document : String(document),
-                    variables: variables || undefined,
-                  };
-                  let url = this.endpoint;
-                  const fetchOptions = { method, headers, credentials: (this.options.credentials || 'same-origin') };
-                  if (method === 'GET') {
-                    const params = new URLSearchParams();
-                    params.set('query', bodyObj.query);
-                    if (variables) params.set('variables', JSON.stringify(variables));
-                    url += (url.includes('?') ? '&' : '?') + params.toString();
-                  } else {
-                    fetchOptions.body = JSON.stringify(bodyObj);
-                  }
-                  const res = await fetch(url, fetchOptions);
-                  let json;
-                  try {
-                    json = await res.json();
-                  } catch (e) {
-                    throw new Error('Invalid JSON response: ' + (e && e.message ? e.message : String(e)));
-                  }
-                  if (!res.ok) {
-                    const errMsg = (json && json.error) ? json.error : (json && json.errors ? (json.errors.map(e => e.message).join('; ')) : res.statusText);
-                    throw new Error('HTTP ' + res.status + ' ' + errMsg);
-                  }
-                  if (json.errors && (!this.options || this.options.errorPolicy !== 'all')) {
-                    const msg = json.errors.map(e => e.message).join('; ');
-                    throw new Error('GraphQL errors: ' + msg);
-                  }
-                  return (this.options && this.options.errorPolicy === 'all') ? json : json.data;
-                }
-                setHeaders(headers) {
-                  this.options = this.options || {};
-                  this.options.headers = Object.assign({}, this.options.headers || {}, headers || {});
-                }
-                setEndpoint(endpoint) { this.endpoint = endpoint; }
-              }
-              function gql(strings, ...values) {
-                let out = '';
-                for (let i = 0; i < strings.length; i++) {
-                  out += strings[i];
-                  if (i < values.length) out += values[i];
-                }
-                return out;
-              }
-              async function graphqlRequest(urlOrConfig, document, variables, requestHeaders) {
-                if (typeof urlOrConfig === 'string') {
-                  const client = new GraphQLClient(urlOrConfig);
-                  return client.request(document, variables, requestHeaders);
-                }
-                const { url, ...rest } = urlOrConfig || {};
-                const client = new GraphQLClient(url, rest);
-                return client.request(document, variables, requestHeaders);
-              }
-
-              window.mcp.GraphQLClient = GraphQLClient;
-              window.mcp.gql = gql;
-              window.mcp.graphqlRequest = graphqlRequest;
-
-              // Expose globals only if not already present
-              if (!window.GraphQLClient) window.GraphQLClient = GraphQLClient;
-              if (!window.gql) window.gql = gql;
-              if (!window.graphqlRequest) window.graphqlRequest = graphqlRequest;
-            }
-          } catch (e) {}
-        })();
-      `,
-            replMode: true,
-        });
-        return true;
-    }
-    catch (error) {
-        debugLog('Failed to inject libraries:', error);
-        return false;
-    }
-}
-const repl = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_repl',
-        title: 'Browser REPL',
-        description: 'DevTools-like browser REPL. Per-tab state persists across calls (const/let/functions); supports top-level await. Survives SPA nav; resets on full reload or when switching tabs. Helpers available via window.mcp: JSON5, JSONPath, _, GraphQLClient, gql, graphqlRequest. No need for wrapping in IIFE.',
-        inputSchema: replSchema,
-        type: 'action',
-    },
-    handle: async (tab, params, response) => {
-        const page = tab.page;
-        const state = getPageState(page);
-        // Get or create CDP session for this page
-        async function getOrCreateSession() {
-            if (!state.cdpSession) {
-                state.cdpSession = await page.context().newCDPSession(page);
-                await state.cdpSession.send('Runtime.enable');
-            }
-            return state.cdpSession;
-        }
-        const session = await getOrCreateSession();
-        // Set up console output capture if not already done
-        if (!state.consoleListenerSetup) {
-            await setupConsoleCapture(page);
-            state.consoleListenerSetup = true;
-        }
-        // Transform Playwright selectors to DOM-compatible code
-        let transformedScript = transformScript(params.script);
-        // Check if script has return statements outside functions
-        const hasReturnOutsideFunction = /^[^{]*\breturn\b/.test(transformedScript.trim());
-        const hasTopLevelAwait = /^[^{]*\bawait\b/.test(transformedScript.trim());
-        // Wrap script appropriately if it has return statements
-        if (hasReturnOutsideFunction && hasTopLevelAwait) {
-            // Wrap in async function for both return and await
-            transformedScript = `(async function() { ${transformedScript} })()`;
-        }
-        else if (hasReturnOutsideFunction) {
-            // Wrap in regular function for return statements
-            transformedScript = `(function() { ${transformedScript} })()`;
-        }
-        // Add code to response - show the original script, not transformed
-        response.addCode(`// Execute in browser REPL\nawait page.evaluate(${javascript.quote(params.script)});`);
-        response.setIncludeSnapshot();
-        await tab.waitForCompletion(async () => {
-            try {
-                // Clear console outputs for this evaluation
-                await page.evaluate(() => {
-                    window.__consoleOutputs = [];
-                });
-                // Inject libraries if not already done
-                if (!state.librariesInjected)
-                    state.librariesInjected = await injectLibraries(session);
-                // Execute the script with REPL mode for console-like behavior
-                let evaluationResponse;
-                try {
-                    evaluationResponse = await session.send('Runtime.evaluate', {
-                        expression: transformedScript,
-                        replMode: true, // Chrome DevTools console behavior (non-standard, tolerated by CDP)
-                        includeCommandLineAPI: true, // Includes console utilities like $, $$, etc.
-                        awaitPromise: true, // Automatically await promises
-                        returnByValue: true, // Return the actual value, not just object reference
-                        timeout: EVALUATE_TIMEOUT_MS,
-                    });
-                }
-                catch (error) {
-                    // If REPL mode fails due to wrapped functions, try without REPL mode
-                    if (hasReturnOutsideFunction || hasTopLevelAwait) {
-                        evaluationResponse = await session.send('Runtime.evaluate', {
-                            expression: transformedScript,
-                            replMode: false, // Disable REPL mode for wrapped functions
-                            includeCommandLineAPI: true,
-                            awaitPromise: true,
-                            returnByValue: true,
-                            timeout: EVALUATE_TIMEOUT_MS,
-                        });
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-                if (evaluationResponse.exceptionDetails) {
-                    const details = evaluationResponse.exceptionDetails;
-                    // Try to get the actual error message from multiple sources
-                    let errorMessage = details.text || 'Evaluation failed';
-                    // If we have exception details, try to extract more info
-                    if (details.exception) {
-                        if (details.exception.description)
-                            errorMessage = details.exception.description;
-                        else if (details.exception.value !== undefined)
-                            errorMessage = String(details.exception.value);
-                    }
-                    // Add location information if available
-                    if (details.lineNumber !== undefined) {
-                        errorMessage += ` (at line ${details.lineNumber}`;
-                        if (details.columnNumber !== undefined)
-                            errorMessage += `:${details.columnNumber}`;
-                        errorMessage += ')';
-                    }
-                    // Check if it's a timeout error
-                    if (errorMessage.includes('Timeout') ||
-                        errorMessage.includes('timeout'))
-                        throw new Error(`Script execution timed out after ${EVALUATE_TIMEOUT_MS / 1000} seconds`);
-                    throw new Error(errorMessage);
-                }
-                // Get console outputs from page context
-                const consoleOutputs = await page.evaluate(() => {
-                    return window.__consoleOutputs || [];
-                });
-                // Format the output
-                const formatOutput = () => {
-                    const MAX_OUTPUT_LENGTH = 10_000;
-                    const MAX_CONSOLE_OUTPUTS = 100;
-                    let output = '';
-                    // Add console output if any
-                    if (consoleOutputs && consoleOutputs.length > 0) {
-                        // Limit number of console outputs and truncate each one
-                        const truncatedOutputs = consoleOutputs
-                            .slice(0, MAX_CONSOLE_OUTPUTS)
-                            .map(o => String(truncate(o, { maxStringLength: 1000 })));
-                        output = truncatedOutputs.join('\n');
-                        if (consoleOutputs.length > MAX_CONSOLE_OUTPUTS)
-                            output += `\n... (${consoleOutputs.length - MAX_CONSOLE_OUTPUTS} more console outputs omitted)`;
-                    }
-                    // Add evaluation result only if:
-                    // 1. It's not undefined, OR
-                    // 2. There's no console output (so we need to show something)
-                    const result = evaluationResponse.result.value;
-                    if (result !== undefined) {
-                        let resultString;
-                        try {
-                            resultString =
-                                typeof result === 'string'
-                                    ? result
-                                    : JSON.stringify(result, null, 2);
-                        }
-                        catch {
-                            // Handle circular references or other stringify errors
-                            resultString = String(result);
-                        }
-                        // Truncate result if too long (first structure-limit, then clamp string)
-                        const truncatedValue = truncate(result, { maxStringLength: 200, maxItems: 20 });
-                        let limited = '';
-                        try {
-                            limited = typeof truncatedValue === 'string' ? truncatedValue : JSON.stringify(truncatedValue, null, 2);
-                        }
-                        catch {
-                            limited = resultString;
-                        }
-                        const truncatedResult = limited.length > 5000 ? (limited.substring(0, 5000) + '\n... (truncated)') : limited;
-                        if (output)
-                            output += '\n' + truncatedResult;
-                        else
-                            output = truncatedResult;
-                    }
-                    else if (!consoleOutputs || consoleOutputs.length === 0) {
-                        // Only show "undefined" if there's no console output
-                        output = 'undefined';
-                    }
-                    // Final truncation of the entire output
-                    if (output.length > MAX_OUTPUT_LENGTH) {
-                        output =
-                            output.substring(0, MAX_OUTPUT_LENGTH) +
-                                '\n... (output truncated)';
-                    }
-                    return output;
-                };
-                response.addResult(formatOutput());
-            }
-            catch (error) {
-                const errorToMessage = (e) => {
-                    if (e instanceof Error)
-                        return e.message;
-                    if (typeof e === 'string')
-                        return e;
-                    try {
-                        return JSON.stringify(e);
-                    }
-                    catch {
-                        return 'Unknown error occurred';
-                    }
-                };
-                response.addError(errorToMessage(error));
-            }
-        });
-    },
-});
-export default [repl];

package/lib/tools/screenshot.js

@@ -1,79 +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 { z } from 'zod';
-import { defineTabTool } from './tool.js';
-import * as javascript from '../utils/codegen.js';
-import { generateLocator } from './utils.js';
-const screenshotSchema = z.object({
-    type: z.enum(['png', 'jpeg']).default('png').describe('Image format for the screenshot. Default is png.'),
-    filename: z.string().optional().describe('File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified.'),
-    element: z.string().optional().describe('Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too.'),
-    ref: z.string().optional().describe('Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too.'),
-    fullPage: z.boolean().optional().describe('When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots.'),
-}).refine(data => {
-    return !!data.element === !!data.ref;
-}, {
-    message: 'Both element and ref must be provided or neither.',
-    path: ['ref', 'element']
-}).refine(data => {
-    return !(data.fullPage && (data.element || data.ref));
-}, {
-    message: 'fullPage cannot be used with element screenshots.',
-    path: ['fullPage']
-});
-const screenshot = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_take_screenshot',
-        title: 'Take a screenshot',
-        description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
-        inputSchema: screenshotSchema,
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        const fileType = params.type || 'png';
-        const fileName = await tab.context.outputFile(params.filename ?? `page-${new Date().toISOString()}.${fileType}`);
-        const options = {
-            type: fileType,
-            quality: fileType === 'png' ? undefined : 90,
-            scale: 'css',
-            path: fileName,
-            ...(params.fullPage !== undefined && { fullPage: params.fullPage })
-        };
-        const isElementScreenshot = params.element && params.ref;
-        const screenshotTarget = isElementScreenshot ? params.element : (params.fullPage ? 'full page' : 'viewport');
-        response.addCode(`// Screenshot ${screenshotTarget} and save it as ${fileName}`);
-        // Only get snapshot when element screenshot is needed
-        const locator = params.ref ? await tab.refLocator({ element: params.element || '', ref: params.ref }) : null;
-        if (locator)
-            response.addCode(`await page.${await generateLocator(locator)}.screenshot(${javascript.formatObject(options)});`);
-        else
-            response.addCode(`await page.screenshot(${javascript.formatObject(options)});`);
-        const buffer = locator ? await locator.screenshot(options) : await tab.page.screenshot(options);
-        response.addResult(`Took the ${screenshotTarget} screenshot and saved it as ${fileName}`);
-        // https://github.com/microsoft/playwright-mcp/issues/817
-        // Never return large images to LLM, saving them to the file system is enough.
-        if (!params.fullPage) {
-            response.addImage({
-                contentType: fileType === 'png' ? 'image/png' : 'image/jpeg',
-                data: buffer
-            });
-        }
-    }
-});
-export default [
-    screenshot,
-];

package/lib/tools/scroll.js

@@ -1,126 +0,0 @@
-import { z } from 'zod';
-import ms from 'ms';
-import { defineTabTool } from './tool.js';
-/**
- * Generate random number between min and max
- */
-function randomBetween(min, max) {
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-/**
- * Generate human-like scroll pattern
- */
-function generateScrollPattern(totalDelta) {
-    const pattern = [];
-    const abs = Math.abs(totalDelta);
-    const direction = totalDelta > 0 ? 1 : -1;
-    // Faster profile: fewer steps overall, still eased
-    const steps = abs < 250 ? randomBetween(3, 6)
-        : abs < 1200 ? randomBetween(4, 10)
-            : randomBetween(8, 16);
-    const base = abs / steps;
-    const easeInOut = (t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t); // 0..1
-    for (let i = 0; i < steps; i++) {
-        const t = steps > 1 ? i / (steps - 1) : 0;
-        const momentum = 0.6 + easeInOut(t) * 0.7; // ~0.6 .. 1.3
-        const variation = 0.1 + Math.random() * 0.2; // +/- ~15%
-        const scrollAmount = base * momentum * (1 + (Math.random() - 0.5) * variation);
-        // Larger per-event wheel to reduce total time: clamp 10..180px
-        const clamped = Math.max(10, Math.min(180, Math.round(scrollAmount)));
-        // Short delays: 15–60ms + small size factor
-        const delay = randomBetween(ms('15ms'), ms('60ms')) + Math.floor(clamped * 0.08);
-        pattern.push({
-            delta: clamped * direction,
-            delay,
-        });
-        // Rare micro-pause (short) to keep a bit of human feel
-        if (Math.random() < 0.05 && i < steps - 1)
-            pattern.push({ delta: 0, delay: randomBetween(ms('30ms'), ms('80ms')) });
-    }
-    // Smaller, rarer overshoot for long moves only
-    if (abs > 600 && Math.random() < 0.1) {
-        pattern.push({
-            delta: -direction * randomBetween(6, 18),
-            delay: randomBetween(ms('60ms'), ms('120ms')),
-        });
-    }
-    return pattern;
-}
-const scrollSchema = z.object({
-    amount: z.number().describe('Vertical scroll amount in pixels (positive scrolls down, negative up)')
-});
-const scrollWheel = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_scroll',
-        title: 'Scroll page',
-        description: 'Scroll the page using mouse wheel with human-like behavior',
-        inputSchema: scrollSchema,
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        const requestedDeltaY = params.amount || 0;
-        // Capture initial scroll position
-        const initialScrollPosition = await tab.page.evaluate(() => ({
-            x: window.scrollX,
-            y: window.scrollY
-        }));
-        response.addCode(`// Scroll page by ${requestedDeltaY}px (vertical)`);
-        await tab.waitForCompletion(async () => {
-            // Position mouse at a slightly randomized viewport center
-            const viewport = tab.page.viewportSize();
-            if (viewport) {
-                const x = viewport.width / 2 + randomBetween(-100, 100);
-                const y = viewport.height / 2 + randomBetween(-100, 100);
-                await tab.page.mouse.move(x, y);
-                response.addCode(`await page.mouse.move(${x}, ${y});`);
-            }
-            // Add initial "hover" delay (short)
-            await tab.page.waitForTimeout(randomBetween(ms('40ms'), ms('120ms')));
-            // Generate and execute human-like scroll pattern
-            const scrollPatternY = requestedDeltaY ? generateScrollPattern(requestedDeltaY) : [];
-            const maxSteps = scrollPatternY.length;
-            for (let i = 0; i < maxSteps; i++) {
-                let deltaY = scrollPatternY[i]?.delta || 0;
-                const delay = scrollPatternY[i]?.delay || 0;
-                // Clamp vertical delta to avoid scrolling past page edges
-                const allowedY = await tab.page.evaluate(dy => {
-                    const doc = document.scrollingElement || document.documentElement;
-                    const maxY = Math.max(0, (doc.scrollHeight || document.documentElement.scrollHeight) - window.innerHeight);
-                    const curY = window.scrollY || doc.scrollTop || 0;
-                    let a = dy;
-                    if (curY + dy < 0)
-                        a = -curY;
-                    if (curY + dy > maxY)
-                        a = maxY - curY;
-                    return a;
-                }, deltaY);
-                deltaY = allowedY;
-                // Skip if nothing to do (already at edge)
-                if (deltaY === 0)
-                    continue;
-                await tab.page.mouse.wheel(0, deltaY);
-                response.addCode(`await page.mouse.wheel(0, ${deltaY});`);
-                // Wait between scroll events
-                if (i < maxSteps - 1 && delay > 0) {
-                    await tab.page.waitForTimeout(delay);
-                    response.addCode(`await page.waitForTimeout(${delay});`);
-                }
-            }
-            // Short final pause
-            const finalDelay = randomBetween(ms('80ms'), ms('200ms'));
-            await tab.page.waitForTimeout(finalDelay);
-            response.addCode(`await page.waitForTimeout(${finalDelay});`);
-        });
-        // Capture final scroll position
-        const finalScrollPosition = await tab.page.evaluate(() => ({
-            x: window.scrollX,
-            y: window.scrollY
-        }));
-        // Always show scroll position for scroll tool
-        response.addResult(`Scroll position:\nBefore: x=${initialScrollPosition.x}, y=${initialScrollPosition.y}\nAfter: x=${finalScrollPosition.x}, y=${finalScrollPosition.y}`);
-    },
-});
-export default [
-    scrollWheel,
-];