@browserstack/mcp-server 1.2.1 → 1.2.2-beta.1

package/dist/tools/appautomate.js

@@ -19,7 +19,7 @@ async function takeAppScreenshot(args) {
     let driver;
     try {
         validateArgs(args);
-        const { desiredPlatform, desiredPhone, appPath, config } = args;
+        const { desiredPlatform, desiredPhone, appPath, browserstackAppUrl, config, } = args;
         let { desiredPlatformVersion } = args;
         const platforms = (await getDevicesAndBrowsers(BrowserStackProducts.APP_AUTOMATE)).mobile;
         const platformData = platforms.find((p) => p.os === desiredPlatform.toLowerCase());
@@ -35,8 +35,18 @@ async function takeAppScreenshot(args) {
         }
         const authString = getBrowserStackAuth(config);
         const [username, password] = authString.split(":");
-        const app_url = await uploadApp(appPath, username, password);
-        logger.info(`App uploaded. URL: ${app_url}`);
+        let app_url;
+        if (browserstackAppUrl) {
+            app_url = browserstackAppUrl;
+            logger.info(`Using provided BrowserStack app URL: ${app_url}`);
+        }
+        else {
+            if (!appPath) {
+                throw new Error("appPath is required when browserstackAppUrl is not provided");
+            }
+            app_url = await uploadApp(appPath, username, password);
+            logger.info(`App uploaded. URL: ${app_url}`);
+        }
         const capabilities = {
             platformName: desiredPlatform,
             "appium:platformVersion": selectedDevice.os_version,
@@ -89,11 +99,34 @@ async function takeAppScreenshot(args) {
 }
 //Runs AppAutomate tests on BrowserStack by uploading app and test suite, then triggering a test run.
 async function runAppTestsOnBrowserStack(args, config) {
+    // Validate that either paths or URLs are provided for both app and test suite
+    if (!args.browserstackAppUrl && !args.appPath) {
+        throw new Error("appPath is required when browserstackAppUrl is not provided");
+    }
+    if (!args.browserstackTestSuiteUrl && !args.testSuitePath) {
+        throw new Error("testSuitePath is required when browserstackTestSuiteUrl is not provided");
+    }
     switch (args.detectedAutomationFramework) {
         case AppTestPlatform.ESPRESSO: {
             try {
-                const app_url = await uploadEspressoApp(args.appPath, config);
-                const test_suite_url = await uploadEspressoTestSuite(args.testSuitePath, config);
+                let app_url;
+                if (args.browserstackAppUrl) {
+                    app_url = args.browserstackAppUrl;
+                    logger.info(`Using provided BrowserStack app URL: ${app_url}`);
+                }
+                else {
+                    app_url = await uploadEspressoApp(args.appPath, config);
+                    logger.info(`App uploaded. URL: ${app_url}`);
+                }
+                let test_suite_url;
+                if (args.browserstackTestSuiteUrl) {
+                    test_suite_url = args.browserstackTestSuiteUrl;
+                    logger.info(`Using provided BrowserStack test suite URL: ${test_suite_url}`);
+                }
+                else {
+                    test_suite_url = await uploadEspressoTestSuite(args.testSuitePath, config);
+                    logger.info(`Test suite uploaded. URL: ${test_suite_url}`);
+                }
                 const build_id = await triggerEspressoBuild(app_url, test_suite_url, args.devices, args.project);
                 return {
                     content: [
@@ -111,8 +144,24 @@ async function runAppTestsOnBrowserStack(args, config) {
         }
         case AppTestPlatform.XCUITEST: {
             try {
-                const app_url = await uploadXcuiApp(args.appPath, config);
-                const test_suite_url = await uploadXcuiTestSuite(args.testSuitePath, config);
+                let app_url;
+                if (args.browserstackAppUrl) {
+                    app_url = args.browserstackAppUrl;
+                    logger.info(`Using provided BrowserStack app URL: ${app_url}`);
+                }
+                else {
+                    app_url = await uploadXcuiApp(args.appPath, config);
+                    logger.info(`App uploaded. URL: ${app_url}`);
+                }
+                let test_suite_url;
+                if (args.browserstackTestSuiteUrl) {
+                    test_suite_url = args.browserstackTestSuiteUrl;
+                    logger.info(`Using provided BrowserStack test suite URL: ${test_suite_url}`);
+                }
+                else {
+                    test_suite_url = await uploadXcuiTestSuite(args.testSuitePath, config);
+                    logger.info(`Test suite uploaded. URL: ${test_suite_url}`);
+                }
                 const build_id = await triggerXcuiBuild(app_url, test_suite_url, args.devices, args.project, config);
                 return {
                     content: [

package/dist/tools/applive-utils/start-session.d.ts

@@ -1,9 +1,10 @@
 import { BrowserStackConfig } from "../../lib/types.js";
 interface StartSessionArgs {
-    appPath: string;
+    appPath?: string;
     desiredPlatform: "android" | "ios";
     desiredPhone: string;
     desiredPlatformVersion: string;
+    browserstackAppUrl?: string;
 }
 interface StartSessionOptions {
     config: BrowserStackConfig;

package/dist/tools/applive-utils/start-session.js

@@ -11,7 +11,7 @@ import envConfig from "../../config.js";
  * Start an App Live session: filter, select, upload, and open.
  */
 export async function startSession(args, options) {
-    const { appPath, desiredPlatform, desiredPhone, desiredPlatformVersion } = args;
+    const { appPath, desiredPlatform, desiredPhone, desiredPlatformVersion, browserstackAppUrl, } = args;
     const { config } = options;
     // 1) Fetch devices for APP_LIVE
     const data = await getDevicesAndBrowsers(BrowserStackProducts.APP_LIVE);
@@ -38,11 +38,22 @@ export async function startSession(args, options) {
         desiredPlatformVersion !== "oldest") {
         note = `\n Note: The requested version "${desiredPlatformVersion}" is not available. Using "${version}" instead.`;
     }
-    // 6) Upload app
-    const authString = getBrowserStackAuth(config);
-    const [username, password] = authString.split(":");
-    const { app_url } = await uploadApp(appPath, username, password);
-    logger.info(`App uploaded: ${app_url}`);
+    // 6) Upload app or use provided URL
+    let app_url;
+    if (browserstackAppUrl) {
+        app_url = browserstackAppUrl;
+        logger.info(`Using provided BrowserStack app URL: ${app_url}`);
+    }
+    else {
+        if (!appPath) {
+            throw new Error("appPath is required when browserstackAppUrl is not provided");
+        }
+        const authString = getBrowserStackAuth(config);
+        const [username, password] = authString.split(":");
+        const result = await uploadApp(appPath, username, password);
+        app_url = result.app_url;
+        logger.info(`App uploaded: ${app_url}`);
+    }
     if (!app_url) {
         throw new Error("Failed to upload app. Please try again.");
     }

package/dist/tools/applive.d.ts

@@ -7,7 +7,8 @@ import { BrowserStackConfig } from "../lib/types.js";
 export declare function startAppLiveSession(args: {
     desiredPlatform: string;
     desiredPlatformVersion: string;
-    appPath: string;
+    appPath?: string;
     desiredPhone: string;
+    browserstackAppUrl?: string;
 }, config: BrowserStackConfig): Promise<CallToolResult>;
 export default function addAppLiveTools(server: McpServer, config: BrowserStackConfig): Record<string, any>;

package/dist/tools/applive.js

@@ -10,34 +10,38 @@ export async function startAppLiveSession(args, config) {
     if (!args.desiredPlatform) {
         throw new Error("You must provide a desiredPlatform.");
     }
-    if (!args.appPath) {
-        throw new Error("You must provide a appPath.");
+    if (!args.appPath && !args.browserstackAppUrl) {
+        throw new Error("You must provide either appPath or browserstackAppUrl.");
     }
     if (!args.desiredPhone) {
         throw new Error("You must provide a desiredPhone.");
     }
-    if (args.desiredPlatform === "android" && !args.appPath.endsWith(".apk")) {
-        throw new Error("You must provide a valid Android app path.");
-    }
-    if (args.desiredPlatform === "ios" && !args.appPath.endsWith(".ipa")) {
-        throw new Error("You must provide a valid iOS app path.");
-    }
-    // check if the app path exists && is readable
-    try {
-        if (!fs.existsSync(args.appPath)) {
-            throw new Error("The app path does not exist.");
+    // Only validate app path if it's provided (not using browserstackAppUrl)
+    if (args.appPath) {
+        if (args.desiredPlatform === "android" && !args.appPath.endsWith(".apk")) {
+            throw new Error("You must provide a valid Android app path.");
+        }
+        if (args.desiredPlatform === "ios" && !args.appPath.endsWith(".ipa")) {
+            throw new Error("You must provide a valid iOS app path.");
+        }
+        // check if the app path exists && is readable
+        try {
+            if (!fs.existsSync(args.appPath)) {
+                throw new Error("The app path does not exist.");
+            }
+            fs.accessSync(args.appPath, fs.constants.R_OK);
+        }
+        catch (error) {
+            logger.error("The app path does not exist or is not readable: %s", error);
+            throw new Error("The app path does not exist or is not readable.");
         }
-        fs.accessSync(args.appPath, fs.constants.R_OK);
-    }
-    catch (error) {
-        logger.error("The app path does not exist or is not readable: %s", error);
-        throw new Error("The app path does not exist or is not readable.");
     }
     const launchUrl = await startSession({
         appPath: args.appPath,
         desiredPlatform: args.desiredPlatform,
         desiredPhone: args.desiredPhone,
         desiredPlatformVersion: args.desiredPlatformVersion,
+        browserstackAppUrl: args.browserstackAppUrl,
     }, { config });
     return {
         content: [

package/dist/tools/bstack-sdk.d.ts

@@ -1,17 +1,4 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { SDKSupportedBrowserAutomationFramework, SDKSupportedLanguage, SDKSupportedTestingFramework } from "./sdk-utils/types.js";
 import { BrowserStackConfig } from "../lib/types.js";
-/**
- * BrowserStack SDK hooks into your test framework to seamlessly run tests on BrowserStack.
- * This tool gives instructions to setup a browserstack.yml file in the project root and installs the necessary dependencies.
- */
-export declare function bootstrapProjectWithSDK({ detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, desiredPlatforms, enablePercy, config, }: {
-    detectedBrowserAutomationFramework: SDKSupportedBrowserAutomationFramework;
-    detectedTestingFramework: SDKSupportedTestingFramework;
-    detectedLanguage: SDKSupportedLanguage;
-    desiredPlatforms: string[];
-    enablePercy: boolean;
-    config: BrowserStackConfig;
-}): Promise<CallToolResult>;
-export default function addSDKTools(server: McpServer, config: BrowserStackConfig): Record<string, any>;
+export declare function registerRunBrowserStackTestsTool(server: McpServer, config: BrowserStackConfig): Record<string, any>;
+export default registerRunBrowserStackTestsTool;

package/dist/tools/bstack-sdk.js

@@ -1,128 +1,11 @@
-import { z } from "zod";
-import { trackMCP } from "../lib/instrumentation.js";
-import { getSDKPrefixCommand } from "./sdk-utils/commands.js";
-import { SDKSupportedLanguageEnum, SDKSupportedBrowserAutomationFrameworkEnum, SDKSupportedTestingFrameworkEnum, } from "./sdk-utils/types.js";
-import { generateBrowserStackYMLInstructions, getInstructionsForProjectConfiguration, formatInstructionsWithNumbers, } from "./sdk-utils/instructions.js";
-import { formatPercyInstructions, getPercyInstructions, } from "./sdk-utils/percy/instructions.js";
-import { getBrowserStackAuth } from "../lib/get-auth.js";
-/**
- * BrowserStack SDK hooks into your test framework to seamlessly run tests on BrowserStack.
- * This tool gives instructions to setup a browserstack.yml file in the project root and installs the necessary dependencies.
- */
-export async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, desiredPlatforms, enablePercy, config, }) {
-    // Get credentials from config
-    const authString = getBrowserStackAuth(config);
-    const [username, accessKey] = authString.split(":");
-    // Handle frameworks with unique setup instructions that don't use browserstack.yml
-    if (detectedBrowserAutomationFramework === "cypress" ||
-        detectedTestingFramework === "webdriverio") {
-        let combinedInstructions = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, username, accessKey);
-        if (enablePercy) {
-            const percyInstructions = getPercyInstructions(detectedLanguage, detectedBrowserAutomationFramework, detectedTestingFramework);
-            if (percyInstructions) {
-                combinedInstructions +=
-                    "\n\n" + formatPercyInstructions(percyInstructions);
-            }
-            else {
-                throw new Error(`Percy is currently not supported through MCP for ${detectedLanguage} with ${detectedTestingFramework}. If you want to run the test cases without Percy, disable Percy and run it again.`);
-            }
-        }
-        // Apply consistent formatting for all configurations
-        return formatFinalInstructions(combinedInstructions);
-    }
-    // Handle default flow using browserstack.yml
-    const sdkSetupCommand = getSDKPrefixCommand(detectedLanguage, detectedTestingFramework, username, accessKey);
-    const ymlInstructions = generateBrowserStackYMLInstructions(desiredPlatforms, enablePercy);
-    const instructionsForProjectConfiguration = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, username, accessKey);
-    let combinedInstructions = "";
-    // Step 1: Add SDK setup command
-    if (sdkSetupCommand) {
-        combinedInstructions += sdkSetupCommand;
-    }
-    // Step 2: Add browserstack.yml setup
-    if (ymlInstructions) {
-        combinedInstructions += "\n\n---STEP---\n" + ymlInstructions;
-    }
-    // Step 3: Add language/framework-specific setup
-    if (instructionsForProjectConfiguration) {
-        combinedInstructions += "\n\n" + instructionsForProjectConfiguration;
-    }
-    // Step 4: Add Percy setup if applicable
-    if (enablePercy) {
-        const percyInstructions = getPercyInstructions(detectedLanguage, detectedBrowserAutomationFramework, detectedTestingFramework);
-        if (percyInstructions) {
-            combinedInstructions +=
-                "\n\n" + formatPercyInstructions(percyInstructions);
-        }
-        else {
-            throw new Error(`Percy is currently not supported through MCP for ${detectedLanguage} with ${detectedTestingFramework}. If you want to run the test cases without Percy, disable Percy and run it again.`);
-        }
-    }
-    // Apply consistent formatting for all configurations
-    return formatFinalInstructions(combinedInstructions);
-}
-// Helper function to apply consistent formatting to all instruction types
-function formatFinalInstructions(combinedInstructions) {
-    const fullInstructions = `⚠️ IMPORTANT: DO NOT SKIP ANY STEP
-  All the setup steps described in this file MUST be executed regardless of any existing configuration or setup.
-  This ensures proper BrowserStack SDK setup.
-
-  ${formatInstructionsWithNumbers(combinedInstructions)}`;
-    return {
-        content: [
-            {
-                type: "text",
-                text: fullInstructions,
-                isError: false,
-            },
-        ],
-    };
-}
-export default function addSDKTools(server, config) {
+import { RunTestsOnBrowserStackParamsShape } from "./sdk-utils/common/schema.js";
+import { runTestsOnBrowserStackHandler } from "./sdk-utils/handler.js";
+import { RUN_ON_BROWSERSTACK_DESCRIPTION } from "./sdk-utils/common/constants.js";
+export function registerRunBrowserStackTestsTool(server, config) {
     const tools = {};
-    tools.setupBrowserStackAutomateTests = server.tool("setupBrowserStackAutomateTests", "Set up and run automated web-based tests on BrowserStack using the BrowserStack SDK. Use for functional or integration tests on BrowserStack, with optional Percy visual testing for supported frameworks. Example prompts: run this test on browserstack; run this test on browserstack with Percy; set up this project for browserstack with Percy. Integrate BrowserStack SDK into your project", {
-        detectedBrowserAutomationFramework: z
-            .nativeEnum(SDKSupportedBrowserAutomationFrameworkEnum)
-            .describe("The automation framework configured in the project. Example: 'playwright', 'selenium'"),
-        detectedTestingFramework: z
-            .nativeEnum(SDKSupportedTestingFrameworkEnum)
-            .describe("The testing framework used in the project. Be precise with framework selection Example: 'webdriverio', 'jest', 'pytest', 'junit4', 'junit5', 'mocha'"),
-        detectedLanguage: z
-            .nativeEnum(SDKSupportedLanguageEnum)
-            .describe("The programming language used in the project. Example: 'nodejs', 'python', 'java', 'csharp'"),
-        desiredPlatforms: z
-            .array(z.enum(["windows", "macos", "android", "ios"]))
-            .describe("The platforms the user wants to test on. Always ask this to the user, do not try to infer this."),
-        enablePercy: z
-            .boolean()
-            .optional()
-            .default(false)
-            .describe("Set to true if the user wants to enable Percy for visual testing. Defaults to false."),
-    }, async (args) => {
-        try {
-            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion(), undefined, config);
-            return await bootstrapProjectWithSDK({
-                detectedBrowserAutomationFramework: args.detectedBrowserAutomationFramework,
-                detectedTestingFramework: args.detectedTestingFramework,
-                detectedLanguage: args.detectedLanguage,
-                desiredPlatforms: args.desiredPlatforms,
-                enablePercy: args.enablePercy,
-                config,
-            });
-        }
-        catch (error) {
-            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion(), error, config);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Failed to bootstrap project with BrowserStack SDK. Error: ${error}. Please open an issue on GitHub if the problem persists`,
-                        isError: true,
-                    },
-                ],
-                isError: true,
-            };
-        }
+    tools.setupBrowserStackAutomateTests = server.tool("setupBrowserStackAutomateTests", RUN_ON_BROWSERSTACK_DESCRIPTION, RunTestsOnBrowserStackParamsShape, async (args) => {
+        return runTestsOnBrowserStackHandler(args, config);
     });
     return tools;
 }
+export default registerRunBrowserStackTestsTool;

package/dist/tools/list-test-files.d.ts

@@ -0,0 +1,2 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function addListTestFiles(args: any): Promise<CallToolResult>;

package/dist/tools/list-test-files.js

@@ -0,0 +1,33 @@
+import { listTestFiles } from "./percy-snapshot-utils/detect-test-files.js";
+import { testFilePathsMap } from "../lib/inmemory-store.js";
+import crypto from "crypto";
+export async function addListTestFiles(args) {
+    const { dirs, language, framework } = args;
+    let testFiles = [];
+    for (const dir of dirs) {
+        const files = await listTestFiles({
+            language,
+            framework,
+            baseDir: dir,
+        });
+        testFiles = testFiles.concat(files);
+    }
+    if (testFiles.length === 0) {
+        throw new Error("No test files found");
+    }
+    // Generate a UUID and store the test files in memory
+    const uuid = crypto.randomUUID();
+    testFilePathsMap.set(uuid, testFiles);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `The Test files are stored in memory with id ${uuid} and the total number of tests files found is ${testFiles.length}. You can use this UUID to retrieve the tests file paths later.`,
+            },
+            {
+                type: "text",
+                text: `You can now use the tool addPercySnapshotCommands to update the test file with Percy commands for visual testing with the UUID ${uuid}`,
+            },
+        ],
+    };
+}

package/dist/tools/percy-sdk.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BrowserStackConfig } from "../lib/types.js";
+export declare function registerPercyTools(server: McpServer, config: BrowserStackConfig): Record<string, any>;
+export default registerPercyTools;

package/dist/tools/percy-sdk.js

@@ -0,0 +1,88 @@
+import { SetUpPercyParamsShape } from "./sdk-utils/common/schema.js";
+import { updateTestsWithPercyCommands } from "./add-percy-snapshots.js";
+import { addListTestFiles } from "./list-test-files.js";
+import { trackMCP } from "../index.js";
+import { setUpPercyHandler, setUpSimulatePercyChangeHandler, } from "./sdk-utils/handler.js";
+import { SETUP_PERCY_DESCRIPTION, SIMULATE_PERCY_CHANGE_DESCRIPTION, LIST_TEST_FILES_DESCRIPTION, PERCY_SNAPSHOT_COMMANDS_DESCRIPTION, } from "./sdk-utils/common/constants.js";
+import { ListTestFilesParamsShape, UpdateTestFileWithInstructionsParams, } from "./percy-snapshot-utils/constants.js";
+export function registerPercyTools(server, config) {
+    const tools = {};
+    // Register setupPercyVisualTesting
+    tools.setupPercyVisualTesting = server.tool("setupPercyVisualTesting", SETUP_PERCY_DESCRIPTION, SetUpPercyParamsShape, async (args) => {
+        try {
+            trackMCP("setupPercyVisualTesting", server.server.getClientVersion(), config);
+            return setUpPercyHandler(args, config);
+        }
+        catch (error) {
+            trackMCP("setupPercyVisualTesting", server.server.getClientVersion(), error, config);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Register simulatePercyChange
+    tools.simulatePercyChange = server.tool("simulatePercyChange", SIMULATE_PERCY_CHANGE_DESCRIPTION, SetUpPercyParamsShape, async (args) => {
+        try {
+            trackMCP("simulatePercyChange", server.server.getClientVersion(), config);
+            return setUpSimulatePercyChangeHandler(args, config);
+        }
+        catch (error) {
+            trackMCP("simulatePercyChange", server.server.getClientVersion(), error, config);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Register addPercySnapshotCommands
+    tools.addPercySnapshotCommands = server.tool("addPercySnapshotCommands", PERCY_SNAPSHOT_COMMANDS_DESCRIPTION, UpdateTestFileWithInstructionsParams, async (args) => {
+        try {
+            trackMCP("addPercySnapshotCommands", server.server.getClientVersion(), config);
+            return await updateTestsWithPercyCommands(args);
+        }
+        catch (error) {
+            trackMCP("addPercySnapshotCommands", server.server.getClientVersion(), error, config);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Register listTestFiles
+    tools.listTestFiles = server.tool("listTestFiles", LIST_TEST_FILES_DESCRIPTION, ListTestFilesParamsShape, async (args) => {
+        try {
+            trackMCP("listTestFiles", server.server.getClientVersion(), config);
+            return addListTestFiles(args);
+        }
+        catch (error) {
+            trackMCP("listTestFiles", server.server.getClientVersion(), error, config);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return tools;
+}
+export default registerPercyTools;

package/dist/tools/percy-snapshot-utils/constants.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { SDKSupportedLanguage } from "../sdk-utils/common/types.js";
+import { DetectionConfig } from "./types.js";
+export declare const UpdateTestFileWithInstructionsParams: {
+    uuid: z.ZodString;
+    index: z.ZodNumber;
+};
+export declare const ListTestFilesParamsShape: {
+    dirs: z.ZodArray<z.ZodString, "many">;
+    language: z.ZodEnum<[string, ...string[]]>;
+    framework: z.ZodEnum<[string, ...string[]]>;
+};
+export declare const TEST_FILE_DETECTION: Record<SDKSupportedLanguage, DetectionConfig>;
+export declare const EXCLUDED_DIRS: Set<string>;
+export declare const backendIndicators: RegExp[];
+export declare const strongUIIndicators: RegExp[];