webdriverio 9.7.1 → 9.7.3

package/build/index.js

@@ -42,8 +42,8 @@ import logger from "@wdio/logger";
 import { getBrowserObject } from "@wdio/utils";
 var log = logger("webdriverio");
 async function implicitWait(currentElement, commandName) {
-  const browser = getBrowserObject(currentElement);
-  const skipForMobileScroll = browser.isMobile && await browser.isNativeContext && (commandName === "scrollIntoView" || commandName === "tap");
+  const browser2 = getBrowserObject(currentElement);
+  const skipForMobileScroll = browser2.isMobile && await browser2.isNativeContext && (commandName === "scrollIntoView" || commandName === "tap");
   if (!currentElement.elementId && !commandName.match(/(waitUntil|waitFor|isExisting|is?\w+Displayed|is?\w+Clickable)/) && !skipForMobileScroll) {
     log.debug(
       "command ".concat(commandName, ' was called on an element ("').concat(currentElement.selector, '") ') + "that wasn't found, waiting for it..."
@@ -174,13 +174,13 @@ var WebDriverError = class extends Error {
   }
 };
 function getElement(selector, res, props = { isReactElement: false, isShadowElement: false }) {
-  const browser = getBrowserObject2(this);
+  const browser2 = getBrowserObject2(this);
   const browserCommandKeys = Object.keys(browser_exports);
   const propertiesObject = {
     /**
      * filter out browser commands from object
      */
-    ...Object.entries(clone(browser.__propertiesObject__)).reduce((commands, [name, descriptor]) => {
+    ...Object.entries(clone(browser2.__propertiesObject__)).reduce((commands, [name, descriptor]) => {
       if (!browserCommandKeys.includes(name)) {
         commands[name] = descriptor;
       }
@@ -212,19 +212,19 @@ function getElement(selector, res, props = { isReactElement: false, isShadowElem
   const elementInstance = element(this.sessionId, elementErrorHandler(wrapCommand));
   const origAddCommand = elementInstance.addCommand.bind(elementInstance);
   elementInstance.addCommand = (name, fn) => {
-    browser.__propertiesObject__[name] = { value: fn };
+    browser2.__propertiesObject__[name] = { value: fn };
     origAddCommand(name, fn);
   };
   return elementInstance;
 }
 var getElements = function getElements2(selector, elemResponse, props = { isReactElement: false, isShadowElement: false }) {
-  const browser = getBrowserObject2(this);
+  const browser2 = getBrowserObject2(this);
   const browserCommandKeys = Object.keys(browser_exports);
   const propertiesObject = {
     /**
      * filter out browser commands from object
      */
-    ...Object.entries(clone(browser.__propertiesObject__)).reduce((commands, [name, descriptor]) => {
+    ...Object.entries(clone(browser2.__propertiesObject__)).reduce((commands, [name, descriptor]) => {
       if (!browserCommandKeys.includes(name)) {
         commands[name] = descriptor;
       }
@@ -263,7 +263,7 @@ var getElements = function getElements2(selector, elemResponse, props = { isReac
     const elementInstance = element(this.sessionId, elementErrorHandler(wrapCommand));
     const origAddCommand = elementInstance.addCommand.bind(elementInstance);
     elementInstance.addCommand = (name, fn) => {
-      browser.__propertiesObject__[name] = { value: fn };
+      browser2.__propertiesObject__[name] = { value: fn };
       origAddCommand(name, fn);
     };
     return elementInstance;
@@ -1177,11 +1177,11 @@ function uninstallFakeTimers() {
 var fakerScript = 'function FakeTimers () {\n/*\n * Copyright (c) 2010-2014, Christian Johansen, christian@cjohansen.no. All rights reserved.\n * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n/**\n * @typedef {object} IdleDeadline\n * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout\n * @property {function():number} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period\n */\n\n/**\n * Queues a function to be called during a browser\'s idle periods\n *\n * @callback RequestIdleCallback\n * @param {function(IdleDeadline)} callback\n * @param {{timeout: number}} options - an options object\n * @returns {number} the id\n */\n\n/**\n * @callback NextTick\n * @param {VoidVarArgsFunc} callback - the callback to run\n * @param {...*} args - optional arguments to call the callback with\n * @returns {void}\n */\n\n/**\n * @callback SetImmediate\n * @param {VoidVarArgsFunc} callback - the callback to run\n * @param {...*} args - optional arguments to call the callback with\n * @returns {NodeImmediate}\n */\n\n/**\n * @callback VoidVarArgsFunc\n * @param {...*} callback - the callback to run\n * @returns {void}\n */\n\n/**\n * @typedef RequestAnimationFrame\n * @property {function(number):void} requestAnimationFrame\n * @returns {number} - the id\n */\n\n/**\n * @typedef Performance\n * @property {function(): number} now\n */\n\n/* eslint-disable jsdoc/require-property-description */\n/**\n * @typedef {object} Clock\n * @property {number} now - the current time\n * @property {Date} Date - the Date constructor\n * @property {number} loopLimit - the maximum number of timers before assuming an infinite loop\n * @property {RequestIdleCallback} requestIdleCallback\n * @property {function(number):void} cancelIdleCallback\n * @property {setTimeout} setTimeout\n * @property {clearTimeout} clearTimeout\n * @property {NextTick} nextTick\n * @property {queueMicrotask} queueMicrotask\n * @property {setInterval} setInterval\n * @property {clearInterval} clearInterval\n * @property {SetImmediate} setImmediate\n * @property {function(NodeImmediate):void} clearImmediate\n * @property {function():number} countTimers\n * @property {RequestAnimationFrame} requestAnimationFrame\n * @property {function(number):void} cancelAnimationFrame\n * @property {function():void} runMicrotasks\n * @property {function(string | number): number} tick\n * @property {function(string | number): Promise<number>} tickAsync\n * @property {function(): number} next\n * @property {function(): Promise<number>} nextAsync\n * @property {function(): number} runAll\n * @property {function(): number} runToFrame\n * @property {function(): Promise<number>} runAllAsync\n * @property {function(): number} runToLast\n * @property {function(): Promise<number>} runToLastAsync\n * @property {function(): void} reset\n * @property {function(number | Date): void} setSystemTime\n * @property {function(number): void} jump\n * @property {Performance} performance\n * @property {function(number[]): number[]} hrtime - process.hrtime (legacy)\n * @property {function(): void} uninstall Uninstall the clock.\n * @property {Function[]} methods - the methods that are faked\n * @property {boolean} [shouldClearNativeTimers] inherited from config\n * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods\n */\n/* eslint-enable jsdoc/require-property-description */\n\n/**\n * Configuration object for the `install` method.\n *\n * @typedef {object} Config\n * @property {number|Date} [now] a number (in milliseconds) or a Date object (default epoch)\n * @property {string[]} [toFake] names of the methods that should be faked.\n * @property {number} [loopLimit] the maximum number of timers that will be run when calling runAll()\n * @property {boolean} [shouldAdvanceTime] tells FakeTimers to increment mocked time automatically (default false)\n * @property {number} [advanceTimeDelta] increment mocked time every <<advanceTimeDelta>> ms (default: 20ms)\n * @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false)\n */\n\n/* eslint-disable jsdoc/require-property-description */\n/**\n * The internal structure to describe a scheduled fake timer\n *\n * @typedef {object} Timer\n * @property {Function} func\n * @property {*[]} args\n * @property {number} delay\n * @property {number} callAt\n * @property {number} createdAt\n * @property {boolean} immediate\n * @property {number} id\n * @property {Error} [error]\n */\n\n/**\n * A Node timer\n *\n * @typedef {object} NodeImmediate\n * @property {function(): boolean} hasRef\n * @property {function(): NodeImmediate} ref\n * @property {function(): NodeImmediate} unref\n */\n/* eslint-enable jsdoc/require-property-description */\n\n/**\n * Mocks available features in the specified global namespace.\n *\n * @param {*} _global Namespace to mock (e.g. `window`)\n * @returns {FakeTimers}\n */\nfunction withGlobal(_global) {\n    const maxTimeout = Math.pow(2, 31) - 1; //see https://heycam.github.io/webidl/#abstract-opdef-converttoint\n    const idCounterStart = 1e12; // arbitrarily large number to avoid collisions with native timer IDs\n    const NOOP = function () {\n        return undefined;\n    };\n    const NOOP_ARRAY = function () {\n        return [];\n    };\n    const timeoutResult = _global.setTimeout(NOOP, 0);\n    const addTimerReturnsObject = typeof timeoutResult === "object";\n    const hrtimePresent =\n        _global.process && typeof _global.process.hrtime === "function";\n    const hrtimeBigintPresent =\n        hrtimePresent && typeof _global.process.hrtime.bigint === "function";\n    const nextTickPresent =\n        _global.process && typeof _global.process.nextTick === "function";\n    const utilPromisify = _global.process && require("util").promisify;\n    const performancePresent =\n        _global.performance && typeof _global.performance.now === "function";\n    const hasPerformancePrototype =\n        _global.Performance &&\n        (typeof _global.Performance).match(/^(function|object)$/);\n    const hasPerformanceConstructorPrototype =\n        _global.performance &&\n        _global.performance.constructor &&\n        _global.performance.constructor.prototype;\n    const queueMicrotaskPresent = _global.hasOwnProperty("queueMicrotask");\n    const requestAnimationFramePresent =\n        _global.requestAnimationFrame &&\n        typeof _global.requestAnimationFrame === "function";\n    const cancelAnimationFramePresent =\n        _global.cancelAnimationFrame &&\n        typeof _global.cancelAnimationFrame === "function";\n    const requestIdleCallbackPresent =\n        _global.requestIdleCallback &&\n        typeof _global.requestIdleCallback === "function";\n    const cancelIdleCallbackPresent =\n        _global.cancelIdleCallback &&\n        typeof _global.cancelIdleCallback === "function";\n    const setImmediatePresent =\n        _global.setImmediate && typeof _global.setImmediate === "function";\n    const intlPresent = _global.Intl && typeof _global.Intl === "object";\n\n    _global.clearTimeout(timeoutResult);\n\n    const NativeDate = _global.Date;\n    const NativeIntl = _global.Intl;\n    let uniqueTimerId = idCounterStart;\n\n    /**\n     * @param {number} num\n     * @returns {boolean}\n     */\n    function isNumberFinite(num) {\n        if (Number.isFinite) {\n            return Number.isFinite(num);\n        }\n\n        return isFinite(num);\n    }\n\n    let isNearInfiniteLimit = false;\n\n    /**\n     * @param {Clock} clock\n     * @param {number} i\n     */\n    function checkIsNearInfiniteLimit(clock, i) {\n        if (clock.loopLimit && i === clock.loopLimit - 1) {\n            isNearInfiniteLimit = true;\n        }\n    }\n\n    /**\n     *\n     */\n    function resetIsNearInfiniteLimit() {\n        isNearInfiniteLimit = false;\n    }\n\n    /**\n     * Parse strings like "01:10:00" (meaning 1 hour, 10 minutes, 0 seconds) into\n     * number of milliseconds. This is used to support human-readable strings passed\n     * to clock.tick()\n     *\n     * @param {string} str\n     * @returns {number}\n     */\n    function parseTime(str) {\n        if (!str) {\n            return 0;\n        }\n\n        const strings = str.split(":");\n        const l = strings.length;\n        let i = l;\n        let ms = 0;\n        let parsed;\n\n        if (l > 3 || !/^(\\d\\d:){0,2}\\d\\d?$/.test(str)) {\n            throw new Error(\n                "tick only understands numbers, \'m:s\' and \'h:m:s\'. Each part must be two digits",\n            );\n        }\n\n        while (i--) {\n            parsed = parseInt(strings[i], 10);\n\n            if (parsed >= 60) {\n                throw new Error(`Invalid time ${str}`);\n            }\n\n            ms += parsed * Math.pow(60, l - i - 1);\n        }\n\n        return ms * 1000;\n    }\n\n    /**\n     * Get the decimal part of the millisecond value as nanoseconds\n     *\n     * @param {number} msFloat the number of milliseconds\n     * @returns {number} an integer number of nanoseconds in the range [0,1e6)\n     *\n     * Example: nanoRemainer(123.456789) -> 456789\n     */\n    function nanoRemainder(msFloat) {\n        const modulo = 1e6;\n        const remainder = (msFloat * 1e6) % modulo;\n        const positiveRemainder =\n            remainder < 0 ? remainder + modulo : remainder;\n\n        return Math.floor(positiveRemainder);\n    }\n\n    /**\n     * Used to grok the `now` parameter to createClock.\n     *\n     * @param {Date|number} epoch the system time\n     * @returns {number}\n     */\n    function getEpoch(epoch) {\n        if (!epoch) {\n            return 0;\n        }\n        if (typeof epoch.getTime === "function") {\n            return epoch.getTime();\n        }\n        if (typeof epoch === "number") {\n            return epoch;\n        }\n        throw new TypeError("now should be milliseconds since UNIX epoch");\n    }\n\n    /**\n     * @param {number} from\n     * @param {number} to\n     * @param {Timer} timer\n     * @returns {boolean}\n     */\n    function inRange(from, to, timer) {\n        return timer && timer.callAt >= from && timer.callAt <= to;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {Timer} job\n     */\n    function getInfiniteLoopError(clock, job) {\n        const infiniteLoopError = new Error(\n            `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`,\n        );\n\n        if (!job.error) {\n            return infiniteLoopError;\n        }\n\n        // pattern never matched in Node\n        const computedTargetPattern = /target\\.*[<|(|[].*?[>|\\]|)]\\s*/;\n        let clockMethodPattern = new RegExp(\n            String(Object.keys(clock).join("|")),\n        );\n\n        if (addTimerReturnsObject) {\n            // node.js environment\n            clockMethodPattern = new RegExp(\n                `\\\\s+at (Object\\\\.)?(?:${Object.keys(clock).join("|")})\\\\s+`,\n            );\n        }\n\n        let matchedLineIndex = -1;\n        job.error.stack.split("\\n").some(function (line, i) {\n            // If we\'ve matched a computed target line (e.g. setTimeout) then we\n            // don\'t need to look any further. Return true to stop iterating.\n            const matchedComputedTarget = line.match(computedTargetPattern);\n            /* istanbul ignore if */\n            if (matchedComputedTarget) {\n                matchedLineIndex = i;\n                return true;\n            }\n\n            // If we\'ve matched a clock method line, then there may still be\n            // others further down the trace. Return false to keep iterating.\n            const matchedClockMethod = line.match(clockMethodPattern);\n            if (matchedClockMethod) {\n                matchedLineIndex = i;\n                return false;\n            }\n\n            // If we haven\'t matched anything on this line, but we matched\n            // previously and set the matched line index, then we can stop.\n            // If we haven\'t matched previously, then we should keep iterating.\n            return matchedLineIndex >= 0;\n        });\n\n        const stack = `${infiniteLoopError}\\n${job.type || "Microtask"} - ${\n            job.func.name || "anonymous"\n        }\\n${job.error.stack\n            .split("\\n")\n            .slice(matchedLineIndex + 1)\n            .join("\\n")}`;\n\n        try {\n            Object.defineProperty(infiniteLoopError, "stack", {\n                value: stack,\n            });\n        } catch (e) {\n            // noop\n        }\n\n        return infiniteLoopError;\n    }\n\n    /**\n     * @param {Date} target\n     * @param {Date} source\n     * @returns {Date} the target after modifications\n     */\n    function mirrorDateProperties(target, source) {\n        let prop;\n        for (prop in source) {\n            if (source.hasOwnProperty(prop)) {\n                target[prop] = source[prop];\n            }\n        }\n\n        // set special now implementation\n        if (source.now) {\n            target.now = function now() {\n                return target.clock.now;\n            };\n        } else {\n            delete target.now;\n        }\n\n        // set special toSource implementation\n        if (source.toSource) {\n            target.toSource = function toSource() {\n                return source.toSource();\n            };\n        } else {\n            delete target.toSource;\n        }\n\n        // set special toString implementation\n        target.toString = function toString() {\n            return source.toString();\n        };\n\n        target.prototype = source.prototype;\n        target.parse = source.parse;\n        target.UTC = source.UTC;\n        target.prototype.toUTCString = source.prototype.toUTCString;\n        target.isFake = true;\n\n        return target;\n    }\n\n    //eslint-disable-next-line jsdoc/require-jsdoc\n    function createDate() {\n        /**\n         * @param {number} year\n         * @param {number} month\n         * @param {number} date\n         * @param {number} hour\n         * @param {number} minute\n         * @param {number} second\n         * @param {number} ms\n         * @returns {Date}\n         */\n        function ClockDate(year, month, date, hour, minute, second, ms) {\n            // the Date constructor called as a function, ref Ecma-262 Edition 5.1, section 15.9.2.\n            // This remains so in the 10th edition of 2019 as well.\n            if (!(this instanceof ClockDate)) {\n                return new NativeDate(ClockDate.clock.now).toString();\n            }\n\n            // if Date is called as a constructor with \'new\' keyword\n            // Defensive and verbose to avoid potential harm in passing\n            // explicit undefined when user does not pass argument\n            switch (arguments.length) {\n                case 0:\n                    return new NativeDate(ClockDate.clock.now);\n                case 1:\n                    return new NativeDate(year);\n                case 2:\n                    return new NativeDate(year, month);\n                case 3:\n                    return new NativeDate(year, month, date);\n                case 4:\n                    return new NativeDate(year, month, date, hour);\n                case 5:\n                    return new NativeDate(year, month, date, hour, minute);\n                case 6:\n                    return new NativeDate(\n                        year,\n                        month,\n                        date,\n                        hour,\n                        minute,\n                        second,\n                    );\n                default:\n                    return new NativeDate(\n                        year,\n                        month,\n                        date,\n                        hour,\n                        minute,\n                        second,\n                        ms,\n                    );\n            }\n        }\n\n        return mirrorDateProperties(ClockDate, NativeDate);\n    }\n\n    /**\n     * Mirror Intl by default on our fake implementation\n     *\n     * Most of the properties are the original native ones,\n     * but we need to take control of those that have a\n     * dependency on the current clock.\n     *\n     * @returns {object} the partly fake Intl implementation\n     */\n    function createIntl() {\n        const ClockIntl = {};\n        /*\n         * All properties of Intl are non-enumerable, so we need\n         * to do a bit of work to get them out.\n         */\n        Object.getOwnPropertyNames(NativeIntl).forEach(\n            (property) => (ClockIntl[property] = NativeIntl[property]),\n        );\n\n        ClockIntl.DateTimeFormat = function (...args) {\n            const realFormatter = new NativeIntl.DateTimeFormat(...args);\n            const formatter = {};\n\n            ["formatRange", "formatRangeToParts", "resolvedOptions"].forEach(\n                (method) => {\n                    formatter[method] =\n                        realFormatter[method].bind(realFormatter);\n                },\n            );\n\n            ["format", "formatToParts"].forEach((method) => {\n                formatter[method] = function (date) {\n                    return realFormatter[method](date || ClockIntl.clock.now);\n                };\n            });\n\n            return formatter;\n        };\n\n        ClockIntl.DateTimeFormat.prototype = Object.create(\n            NativeIntl.DateTimeFormat.prototype,\n        );\n\n        ClockIntl.DateTimeFormat.supportedLocalesOf =\n            NativeIntl.DateTimeFormat.supportedLocalesOf;\n\n        return ClockIntl;\n    }\n\n    //eslint-disable-next-line jsdoc/require-jsdoc\n    function enqueueJob(clock, job) {\n        // enqueues a microtick-deferred task - ecma262/#sec-enqueuejob\n        if (!clock.jobs) {\n            clock.jobs = [];\n        }\n        clock.jobs.push(job);\n    }\n\n    //eslint-disable-next-line jsdoc/require-jsdoc\n    function runJobs(clock) {\n        // runs all microtick-deferred tasks - ecma262/#sec-runjobs\n        if (!clock.jobs) {\n            return;\n        }\n        for (let i = 0; i < clock.jobs.length; i++) {\n            const job = clock.jobs[i];\n            job.func.apply(null, job.args);\n\n            checkIsNearInfiniteLimit(clock, i);\n            if (clock.loopLimit && i > clock.loopLimit) {\n                throw getInfiniteLoopError(clock, job);\n            }\n        }\n        resetIsNearInfiniteLimit();\n        clock.jobs = [];\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {Timer} timer\n     * @returns {number} id of the created timer\n     */\n    function addTimer(clock, timer) {\n        if (timer.func === undefined) {\n            throw new Error("Callback must be provided to timer calls");\n        }\n\n        if (addTimerReturnsObject) {\n            // Node.js environment\n            if (typeof timer.func !== "function") {\n                throw new TypeError(\n                    `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${\n                        timer.func\n                    } of type ${typeof timer.func}`,\n                );\n            }\n        }\n\n        if (isNearInfiniteLimit) {\n            timer.error = new Error();\n        }\n\n        timer.type = timer.immediate ? "Immediate" : "Timeout";\n\n        if (timer.hasOwnProperty("delay")) {\n            if (typeof timer.delay !== "number") {\n                timer.delay = parseInt(timer.delay, 10);\n            }\n\n            if (!isNumberFinite(timer.delay)) {\n                timer.delay = 0;\n            }\n            timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;\n            timer.delay = Math.max(0, timer.delay);\n        }\n\n        if (timer.hasOwnProperty("interval")) {\n            timer.type = "Interval";\n            timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;\n        }\n\n        if (timer.hasOwnProperty("animation")) {\n            timer.type = "AnimationFrame";\n            timer.animation = true;\n        }\n\n        if (timer.hasOwnProperty("idleCallback")) {\n            timer.type = "IdleCallback";\n            timer.idleCallback = true;\n        }\n\n        if (!clock.timers) {\n            clock.timers = {};\n        }\n\n        timer.id = uniqueTimerId++;\n        timer.createdAt = clock.now;\n        timer.callAt =\n            clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));\n\n        clock.timers[timer.id] = timer;\n\n        if (addTimerReturnsObject) {\n            const res = {\n                refed: true,\n                ref: function () {\n                    this.refed = true;\n                    return res;\n                },\n                unref: function () {\n                    this.refed = false;\n                    return res;\n                },\n                hasRef: function () {\n                    return this.refed;\n                },\n                refresh: function () {\n                    timer.callAt =\n                        clock.now +\n                        (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));\n\n                    // it _might_ have been removed, but if not the assignment is perfectly fine\n                    clock.timers[timer.id] = timer;\n\n                    return res;\n                },\n                [Symbol.toPrimitive]: function () {\n                    return timer.id;\n                },\n            };\n            return res;\n        }\n\n        return timer.id;\n    }\n\n    /* eslint consistent-return: "off" */\n    /**\n     * Timer comparitor\n     *\n     * @param {Timer} a\n     * @param {Timer} b\n     * @returns {number}\n     */\n    function compareTimers(a, b) {\n        // Sort first by absolute timing\n        if (a.callAt < b.callAt) {\n            return -1;\n        }\n        if (a.callAt > b.callAt) {\n            return 1;\n        }\n\n        // Sort next by immediate, immediate timers take precedence\n        if (a.immediate && !b.immediate) {\n            return -1;\n        }\n        if (!a.immediate && b.immediate) {\n            return 1;\n        }\n\n        // Sort next by creation time, earlier-created timers take precedence\n        if (a.createdAt < b.createdAt) {\n            return -1;\n        }\n        if (a.createdAt > b.createdAt) {\n            return 1;\n        }\n\n        // Sort next by id, lower-id timers take precedence\n        if (a.id < b.id) {\n            return -1;\n        }\n        if (a.id > b.id) {\n            return 1;\n        }\n\n        // As timer ids are unique, no fallback `0` is necessary\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {number} from\n     * @param {number} to\n     * @returns {Timer}\n     */\n    function firstTimerInRange(clock, from, to) {\n        const timers = clock.timers;\n        let timer = null;\n        let id, isInRange;\n\n        for (id in timers) {\n            if (timers.hasOwnProperty(id)) {\n                isInRange = inRange(from, to, timers[id]);\n\n                if (\n                    isInRange &&\n                    (!timer || compareTimers(timer, timers[id]) === 1)\n                ) {\n                    timer = timers[id];\n                }\n            }\n        }\n\n        return timer;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @returns {Timer}\n     */\n    function firstTimer(clock) {\n        const timers = clock.timers;\n        let timer = null;\n        let id;\n\n        for (id in timers) {\n            if (timers.hasOwnProperty(id)) {\n                if (!timer || compareTimers(timer, timers[id]) === 1) {\n                    timer = timers[id];\n                }\n            }\n        }\n\n        return timer;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @returns {Timer}\n     */\n    function lastTimer(clock) {\n        const timers = clock.timers;\n        let timer = null;\n        let id;\n\n        for (id in timers) {\n            if (timers.hasOwnProperty(id)) {\n                if (!timer || compareTimers(timer, timers[id]) === -1) {\n                    timer = timers[id];\n                }\n            }\n        }\n\n        return timer;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {Timer} timer\n     */\n    function callTimer(clock, timer) {\n        if (typeof timer.interval === "number") {\n            clock.timers[timer.id].callAt += timer.interval;\n        } else {\n            delete clock.timers[timer.id];\n        }\n\n        if (typeof timer.func === "function") {\n            timer.func.apply(null, timer.args);\n        } else {\n            /* eslint no-eval: "off" */\n            const eval2 = eval;\n            (function () {\n                eval2(timer.func);\n            })();\n        }\n    }\n\n    /**\n     * Gets clear handler name for a given timer type\n     *\n     * @param {string} ttype\n     */\n    function getClearHandler(ttype) {\n        if (ttype === "IdleCallback" || ttype === "AnimationFrame") {\n            return `cancel${ttype}`;\n        }\n        return `clear${ttype}`;\n    }\n\n    /**\n     * Gets schedule handler name for a given timer type\n     *\n     * @param {string} ttype\n     */\n    function getScheduleHandler(ttype) {\n        if (ttype === "IdleCallback" || ttype === "AnimationFrame") {\n            return `request${ttype}`;\n        }\n        return `set${ttype}`;\n    }\n\n    /**\n     * Creates an anonymous function to warn only once\n     */\n    function createWarnOnce() {\n        let calls = 0;\n        return function (msg) {\n            // eslint-disable-next-line\n            !calls++ && console.warn(msg);\n        };\n    }\n    const warnOnce = createWarnOnce();\n\n    /**\n     * @param {Clock} clock\n     * @param {number} timerId\n     * @param {string} ttype\n     */\n    function clearTimer(clock, timerId, ttype) {\n        if (!timerId) {\n            // null appears to be allowed in most browsers, and appears to be\n            // relied upon by some libraries, like Bootstrap carousel\n            return;\n        }\n\n        if (!clock.timers) {\n            clock.timers = {};\n        }\n\n        // in Node, the ID is stored as the primitive value for `Timeout` objects\n        // for `Immediate` objects, no ID exists, so it gets coerced to NaN\n        const id = Number(timerId);\n\n        if (Number.isNaN(id) || id < idCounterStart) {\n            const handlerName = getClearHandler(ttype);\n\n            if (clock.shouldClearNativeTimers === true) {\n                const nativeHandler = clock[`_${handlerName}`];\n                return typeof nativeHandler === "function"\n                    ? nativeHandler(timerId)\n                    : undefined;\n            }\n            warnOnce(\n                `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.` +\n                    "\\nTo automatically clean-up native timers, use `shouldClearNativeTimers`.",\n            );\n        }\n\n        if (clock.timers.hasOwnProperty(id)) {\n            // check that the ID matches a timer of the correct type\n            const timer = clock.timers[id];\n            if (\n                timer.type === ttype ||\n                (timer.type === "Timeout" && ttype === "Interval") ||\n                (timer.type === "Interval" && ttype === "Timeout")\n            ) {\n                delete clock.timers[id];\n            } else {\n                const clear = getClearHandler(ttype);\n                const schedule = getScheduleHandler(timer.type);\n                throw new Error(\n                    `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`,\n                );\n            }\n        }\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {Config} config\n     * @returns {Timer[]}\n     */\n    function uninstall(clock, config) {\n        let method, i, l;\n        const installedHrTime = "_hrtime";\n        const installedNextTick = "_nextTick";\n\n        for (i = 0, l = clock.methods.length; i < l; i++) {\n            method = clock.methods[i];\n            if (method === "hrtime" && _global.process) {\n                _global.process.hrtime = clock[installedHrTime];\n            } else if (method === "nextTick" && _global.process) {\n                _global.process.nextTick = clock[installedNextTick];\n            } else if (method === "performance") {\n                const originalPerfDescriptor = Object.getOwnPropertyDescriptor(\n                    clock,\n                    `_${method}`,\n                );\n                if (\n                    originalPerfDescriptor &&\n                    originalPerfDescriptor.get &&\n                    !originalPerfDescriptor.set\n                ) {\n                    Object.defineProperty(\n                        _global,\n                        method,\n                        originalPerfDescriptor,\n                    );\n                } else if (originalPerfDescriptor.configurable) {\n                    _global[method] = clock[`_${method}`];\n                }\n            } else {\n                if (_global[method] && _global[method].hadOwnProperty) {\n                    _global[method] = clock[`_${method}`];\n                } else {\n                    try {\n                        delete _global[method];\n                    } catch (ignore) {\n                        /* eslint no-empty: "off" */\n                    }\n                }\n            }\n        }\n\n        if (config.shouldAdvanceTime === true) {\n            _global.clearInterval(clock.attachedInterval);\n        }\n\n        // Prevent multiple executions which will completely remove these props\n        clock.methods = [];\n\n        // return pending timers, to enable checking what timers remained on uninstall\n        if (!clock.timers) {\n            return [];\n        }\n        return Object.keys(clock.timers).map(function mapper(key) {\n            return clock.timers[key];\n        });\n    }\n\n    /**\n     * @param {object} target the target containing the method to replace\n     * @param {string} method the keyname of the method on the target\n     * @param {Clock} clock\n     */\n    function hijackMethod(target, method, clock) {\n        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(\n            target,\n            method,\n        );\n        clock[`_${method}`] = target[method];\n\n        if (method === "Date") {\n            const date = mirrorDateProperties(clock[method], target[method]);\n            target[method] = date;\n        } else if (method === "Intl") {\n            target[method] = clock[method];\n        } else if (method === "performance") {\n            const originalPerfDescriptor = Object.getOwnPropertyDescriptor(\n                target,\n                method,\n            );\n            // JSDOM has a read only performance field so we have to save/copy it differently\n            if (\n                originalPerfDescriptor &&\n                originalPerfDescriptor.get &&\n                !originalPerfDescriptor.set\n            ) {\n                Object.defineProperty(\n                    clock,\n                    `_${method}`,\n                    originalPerfDescriptor,\n                );\n\n                const perfDescriptor = Object.getOwnPropertyDescriptor(\n                    clock,\n                    method,\n                );\n                Object.defineProperty(target, method, perfDescriptor);\n            } else {\n                target[method] = clock[method];\n            }\n        } else {\n            target[method] = function () {\n                return clock[method].apply(clock, arguments);\n            };\n\n            Object.defineProperties(\n                target[method],\n                Object.getOwnPropertyDescriptors(clock[method]),\n            );\n        }\n\n        target[method].clock = clock;\n    }\n\n    /**\n     * @param {Clock} clock\n     * @param {number} advanceTimeDelta\n     */\n    function doIntervalTick(clock, advanceTimeDelta) {\n        clock.tick(advanceTimeDelta);\n    }\n\n    /**\n     * @typedef {object} Timers\n     * @property {setTimeout} setTimeout\n     * @property {clearTimeout} clearTimeout\n     * @property {setInterval} setInterval\n     * @property {clearInterval} clearInterval\n     * @property {Date} Date\n     * @property {Intl} Intl\n     * @property {SetImmediate=} setImmediate\n     * @property {function(NodeImmediate): void=} clearImmediate\n     * @property {function(number[]):number[]=} hrtime\n     * @property {NextTick=} nextTick\n     * @property {Performance=} performance\n     * @property {RequestAnimationFrame=} requestAnimationFrame\n     * @property {boolean=} queueMicrotask\n     * @property {function(number): void=} cancelAnimationFrame\n     * @property {RequestIdleCallback=} requestIdleCallback\n     * @property {function(number): void=} cancelIdleCallback\n     */\n\n    /** @type {Timers} */\n    const timers = {\n        setTimeout: _global.setTimeout,\n        clearTimeout: _global.clearTimeout,\n        setInterval: _global.setInterval,\n        clearInterval: _global.clearInterval,\n        Date: _global.Date,\n    };\n\n    if (setImmediatePresent) {\n        timers.setImmediate = _global.setImmediate;\n        timers.clearImmediate = _global.clearImmediate;\n    }\n\n    if (hrtimePresent) {\n        timers.hrtime = _global.process.hrtime;\n    }\n\n    if (nextTickPresent) {\n        timers.nextTick = _global.process.nextTick;\n    }\n\n    if (performancePresent) {\n        timers.performance = _global.performance;\n    }\n\n    if (requestAnimationFramePresent) {\n        timers.requestAnimationFrame = _global.requestAnimationFrame;\n    }\n\n    if (queueMicrotaskPresent) {\n        timers.queueMicrotask = true;\n    }\n\n    if (cancelAnimationFramePresent) {\n        timers.cancelAnimationFrame = _global.cancelAnimationFrame;\n    }\n\n    if (requestIdleCallbackPresent) {\n        timers.requestIdleCallback = _global.requestIdleCallback;\n    }\n\n    if (cancelIdleCallbackPresent) {\n        timers.cancelIdleCallback = _global.cancelIdleCallback;\n    }\n\n    if (intlPresent) {\n        timers.Intl = _global.Intl;\n    }\n\n    const originalSetTimeout = _global.setImmediate || _global.setTimeout;\n\n    /**\n     * @param {Date|number} [start] the system time - non-integer values are floored\n     * @param {number} [loopLimit] maximum number of timers that will be run when calling runAll()\n     * @returns {Clock}\n     */\n    function createClock(start, loopLimit) {\n        // eslint-disable-next-line no-param-reassign\n        start = Math.floor(getEpoch(start));\n        // eslint-disable-next-line no-param-reassign\n        loopLimit = loopLimit || 1000;\n        let nanos = 0;\n        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]\n\n        if (NativeDate === undefined) {\n            throw new Error(\n                "The global scope doesn\'t have a `Date` object" +\n                    " (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)",\n            );\n        }\n\n        const clock = {\n            now: start,\n            Date: createDate(),\n            loopLimit: loopLimit,\n        };\n\n        clock.Date.clock = clock;\n\n        //eslint-disable-next-line jsdoc/require-jsdoc\n        function getTimeToNextFrame() {\n            return 16 - ((clock.now - start) % 16);\n        }\n\n        //eslint-disable-next-line jsdoc/require-jsdoc\n        function hrtime(prev) {\n            const millisSinceStart = clock.now - adjustedSystemTime[0] - start;\n            const secsSinceStart = Math.floor(millisSinceStart / 1000);\n            const remainderInNanos =\n                (millisSinceStart - secsSinceStart * 1e3) * 1e6 +\n                nanos -\n                adjustedSystemTime[1];\n\n            if (Array.isArray(prev)) {\n                if (prev[1] > 1e9) {\n                    throw new TypeError(\n                        "Number of nanoseconds can\'t exceed a billion",\n                    );\n                }\n\n                const oldSecs = prev[0];\n                let nanoDiff = remainderInNanos - prev[1];\n                let secDiff = secsSinceStart - oldSecs;\n\n                if (nanoDiff < 0) {\n                    nanoDiff += 1e9;\n                    secDiff -= 1;\n                }\n\n                return [secDiff, nanoDiff];\n            }\n            return [secsSinceStart, remainderInNanos];\n        }\n\n        /**\n         * A high resolution timestamp in milliseconds.\n         *\n         * @typedef {number} DOMHighResTimeStamp\n         */\n\n        /**\n         * performance.now()\n         *\n         * @returns {DOMHighResTimeStamp}\n         */\n        function fakePerformanceNow() {\n            const hrt = hrtime();\n            const millis = hrt[0] * 1000 + hrt[1] / 1e6;\n            return millis;\n        }\n\n        if (hrtimeBigintPresent) {\n            hrtime.bigint = function () {\n                const parts = hrtime();\n                return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]); // eslint-disable-line\n            };\n        }\n\n        if (intlPresent) {\n            clock.Intl = createIntl();\n            clock.Intl.clock = clock;\n        }\n\n        clock.requestIdleCallback = function requestIdleCallback(\n            func,\n            timeout,\n        ) {\n            let timeToNextIdlePeriod = 0;\n\n            if (clock.countTimers() > 0) {\n                timeToNextIdlePeriod = 50; // const for now\n            }\n\n            const result = addTimer(clock, {\n                func: func,\n                args: Array.prototype.slice.call(arguments, 2),\n                delay:\n                    typeof timeout === "undefined"\n                        ? timeToNextIdlePeriod\n                        : Math.min(timeout, timeToNextIdlePeriod),\n                idleCallback: true,\n            });\n\n            return Number(result);\n        };\n\n        clock.cancelIdleCallback = function cancelIdleCallback(timerId) {\n            return clearTimer(clock, timerId, "IdleCallback");\n        };\n\n        clock.setTimeout = function setTimeout(func, timeout) {\n            return addTimer(clock, {\n                func: func,\n                args: Array.prototype.slice.call(arguments, 2),\n                delay: timeout,\n            });\n        };\n        if (typeof _global.Promise !== "undefined" && utilPromisify) {\n            clock.setTimeout[utilPromisify.custom] =\n                function promisifiedSetTimeout(timeout, arg) {\n                    return new _global.Promise(function setTimeoutExecutor(\n                        resolve,\n                    ) {\n                        addTimer(clock, {\n                            func: resolve,\n                            args: [arg],\n                            delay: timeout,\n                        });\n                    });\n                };\n        }\n\n        clock.clearTimeout = function clearTimeout(timerId) {\n            return clearTimer(clock, timerId, "Timeout");\n        };\n\n        clock.nextTick = function nextTick(func) {\n            return enqueueJob(clock, {\n                func: func,\n                args: Array.prototype.slice.call(arguments, 1),\n                error: isNearInfiniteLimit ? new Error() : null,\n            });\n        };\n\n        clock.queueMicrotask = function queueMicrotask(func) {\n            return clock.nextTick(func); // explicitly drop additional arguments\n        };\n\n        clock.setInterval = function setInterval(func, timeout) {\n            // eslint-disable-next-line no-param-reassign\n            timeout = parseInt(timeout, 10);\n            return addTimer(clock, {\n                func: func,\n                args: Array.prototype.slice.call(arguments, 2),\n                delay: timeout,\n                interval: timeout,\n            });\n        };\n\n        clock.clearInterval = function clearInterval(timerId) {\n            return clearTimer(clock, timerId, "Interval");\n        };\n\n        if (setImmediatePresent) {\n            clock.setImmediate = function setImmediate(func) {\n                return addTimer(clock, {\n                    func: func,\n                    args: Array.prototype.slice.call(arguments, 1),\n                    immediate: true,\n                });\n            };\n\n            if (typeof _global.Promise !== "undefined" && utilPromisify) {\n                clock.setImmediate[utilPromisify.custom] =\n                    function promisifiedSetImmediate(arg) {\n                        return new _global.Promise(\n                            function setImmediateExecutor(resolve) {\n                                addTimer(clock, {\n                                    func: resolve,\n                                    args: [arg],\n                                    immediate: true,\n                                });\n                            },\n                        );\n                    };\n            }\n\n            clock.clearImmediate = function clearImmediate(timerId) {\n                return clearTimer(clock, timerId, "Immediate");\n            };\n        }\n\n        clock.countTimers = function countTimers() {\n            return (\n                Object.keys(clock.timers || {}).length +\n                (clock.jobs || []).length\n            );\n        };\n\n        clock.requestAnimationFrame = function requestAnimationFrame(func) {\n            const result = addTimer(clock, {\n                func: func,\n                delay: getTimeToNextFrame(),\n                get args() {\n                    return [fakePerformanceNow()];\n                },\n                animation: true,\n            });\n\n            return Number(result);\n        };\n\n        clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) {\n            return clearTimer(clock, timerId, "AnimationFrame");\n        };\n\n        clock.runMicrotasks = function runMicrotasks() {\n            runJobs(clock);\n        };\n\n        /**\n         * @param {number|string} tickValue milliseconds or a string parseable by parseTime\n         * @param {boolean} isAsync\n         * @param {Function} resolve\n         * @param {Function} reject\n         * @returns {number|undefined} will return the new `now` value or nothing for async\n         */\n        function doTick(tickValue, isAsync, resolve, reject) {\n            const msFloat =\n                typeof tickValue === "number"\n                    ? tickValue\n                    : parseTime(tickValue);\n            const ms = Math.floor(msFloat);\n            const remainder = nanoRemainder(msFloat);\n            let nanosTotal = nanos + remainder;\n            let tickTo = clock.now + ms;\n\n            if (msFloat < 0) {\n                throw new TypeError("Negative ticks are not supported");\n            }\n\n            // adjust for positive overflow\n            if (nanosTotal >= 1e6) {\n                tickTo += 1;\n                nanosTotal -= 1e6;\n            }\n\n            nanos = nanosTotal;\n            let tickFrom = clock.now;\n            let previous = clock.now;\n            // ESLint fails to detect this correctly\n            /* eslint-disable prefer-const */\n            let timer,\n                firstException,\n                oldNow,\n                nextPromiseTick,\n                compensationCheck,\n                postTimerCall;\n            /* eslint-enable prefer-const */\n\n            clock.duringTick = true;\n\n            // perform microtasks\n            oldNow = clock.now;\n            runJobs(clock);\n            if (oldNow !== clock.now) {\n                // compensate for any setSystemTime() call during microtask callback\n                tickFrom += clock.now - oldNow;\n                tickTo += clock.now - oldNow;\n            }\n\n            //eslint-disable-next-line jsdoc/require-jsdoc\n            function doTickInner() {\n                // perform each timer in the requested range\n                timer = firstTimerInRange(clock, tickFrom, tickTo);\n                // eslint-disable-next-line no-unmodified-loop-condition\n                while (timer && tickFrom <= tickTo) {\n                    if (clock.timers[timer.id]) {\n                        tickFrom = timer.callAt;\n                        clock.now = timer.callAt;\n                        oldNow = clock.now;\n                        try {\n                            runJobs(clock);\n                            callTimer(clock, timer);\n                        } catch (e) {\n                            firstException = firstException || e;\n                        }\n\n                        if (isAsync) {\n                            // finish up after native setImmediate callback to allow\n                            // all native es6 promises to process their callbacks after\n                            // each timer fires.\n                            originalSetTimeout(nextPromiseTick);\n                            return;\n                        }\n\n                        compensationCheck();\n                    }\n\n                    postTimerCall();\n                }\n\n                // perform process.nextTick()s again\n                oldNow = clock.now;\n                runJobs(clock);\n                if (oldNow !== clock.now) {\n                    // compensate for any setSystemTime() call during process.nextTick() callback\n                    tickFrom += clock.now - oldNow;\n                    tickTo += clock.now - oldNow;\n                }\n                clock.duringTick = false;\n\n                // corner case: during runJobs new timers were scheduled which could be in the range [clock.now, tickTo]\n                timer = firstTimerInRange(clock, tickFrom, tickTo);\n                if (timer) {\n                    try {\n                        clock.tick(tickTo - clock.now); // do it all again - for the remainder of the requested range\n                    } catch (e) {\n                        firstException = firstException || e;\n                    }\n                } else {\n                    // no timers remaining in the requested range: move the clock all the way to the end\n                    clock.now = tickTo;\n\n                    // update nanos\n                    nanos = nanosTotal;\n                }\n                if (firstException) {\n                    throw firstException;\n                }\n\n                if (isAsync) {\n                    resolve(clock.now);\n                } else {\n                    return clock.now;\n                }\n            }\n\n            nextPromiseTick =\n                isAsync &&\n                function () {\n                    try {\n                        compensationCheck();\n                        postTimerCall();\n                        doTickInner();\n                    } catch (e) {\n                        reject(e);\n                    }\n                };\n\n            compensationCheck = function () {\n                // compensate for any setSystemTime() call during timer callback\n                if (oldNow !== clock.now) {\n                    tickFrom += clock.now - oldNow;\n                    tickTo += clock.now - oldNow;\n                    previous += clock.now - oldNow;\n                }\n            };\n\n            postTimerCall = function () {\n                timer = firstTimerInRange(clock, previous, tickTo);\n                previous = tickFrom;\n            };\n\n            return doTickInner();\n        }\n\n        /**\n         * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"\n         * @returns {number} will return the new `now` value\n         */\n        clock.tick = function tick(tickValue) {\n            return doTick(tickValue, false);\n        };\n\n        if (typeof _global.Promise !== "undefined") {\n            /**\n             * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"\n             * @returns {Promise}\n             */\n            clock.tickAsync = function tickAsync(tickValue) {\n                return new _global.Promise(function (resolve, reject) {\n                    originalSetTimeout(function () {\n                        try {\n                            doTick(tickValue, true, resolve, reject);\n                        } catch (e) {\n                            reject(e);\n                        }\n                    });\n                });\n            };\n        }\n\n        clock.next = function next() {\n            runJobs(clock);\n            const timer = firstTimer(clock);\n            if (!timer) {\n                return clock.now;\n            }\n\n            clock.duringTick = true;\n            try {\n                clock.now = timer.callAt;\n                callTimer(clock, timer);\n                runJobs(clock);\n                return clock.now;\n            } finally {\n                clock.duringTick = false;\n            }\n        };\n\n        if (typeof _global.Promise !== "undefined") {\n            clock.nextAsync = function nextAsync() {\n                return new _global.Promise(function (resolve, reject) {\n                    originalSetTimeout(function () {\n                        try {\n                            const timer = firstTimer(clock);\n                            if (!timer) {\n                                resolve(clock.now);\n                                return;\n                            }\n\n                            let err;\n                            clock.duringTick = true;\n                            clock.now = timer.callAt;\n                            try {\n                                callTimer(clock, timer);\n                            } catch (e) {\n                                err = e;\n                            }\n                            clock.duringTick = false;\n\n                            originalSetTimeout(function () {\n                                if (err) {\n                                    reject(err);\n                                } else {\n                                    resolve(clock.now);\n                                }\n                            });\n                        } catch (e) {\n                            reject(e);\n                        }\n                    });\n                });\n            };\n        }\n\n        clock.runAll = function runAll() {\n            let numTimers, i;\n            runJobs(clock);\n            for (i = 0; i < clock.loopLimit; i++) {\n                if (!clock.timers) {\n                    resetIsNearInfiniteLimit();\n                    return clock.now;\n                }\n\n                numTimers = Object.keys(clock.timers).length;\n                if (numTimers === 0) {\n                    resetIsNearInfiniteLimit();\n                    return clock.now;\n                }\n\n                clock.next();\n                checkIsNearInfiniteLimit(clock, i);\n            }\n\n            const excessJob = firstTimer(clock);\n            throw getInfiniteLoopError(clock, excessJob);\n        };\n\n        clock.runToFrame = function runToFrame() {\n            return clock.tick(getTimeToNextFrame());\n        };\n\n        if (typeof _global.Promise !== "undefined") {\n            clock.runAllAsync = function runAllAsync() {\n                return new _global.Promise(function (resolve, reject) {\n                    let i = 0;\n                    /**\n                     *\n                     */\n                    function doRun() {\n                        originalSetTimeout(function () {\n                            try {\n                                runJobs(clock);\n\n                                let numTimers;\n                                if (i < clock.loopLimit) {\n                                    if (!clock.timers) {\n                                        resetIsNearInfiniteLimit();\n                                        resolve(clock.now);\n                                        return;\n                                    }\n\n                                    numTimers = Object.keys(\n                                        clock.timers,\n                                    ).length;\n                                    if (numTimers === 0) {\n                                        resetIsNearInfiniteLimit();\n                                        resolve(clock.now);\n                                        return;\n                                    }\n\n                                    clock.next();\n\n                                    i++;\n\n                                    doRun();\n                                    checkIsNearInfiniteLimit(clock, i);\n                                    return;\n                                }\n\n                                const excessJob = firstTimer(clock);\n                                reject(getInfiniteLoopError(clock, excessJob));\n                            } catch (e) {\n                                reject(e);\n                            }\n                        });\n                    }\n                    doRun();\n                });\n            };\n        }\n\n        clock.runToLast = function runToLast() {\n            const timer = lastTimer(clock);\n            if (!timer) {\n                runJobs(clock);\n                return clock.now;\n            }\n\n            return clock.tick(timer.callAt - clock.now);\n        };\n\n        if (typeof _global.Promise !== "undefined") {\n            clock.runToLastAsync = function runToLastAsync() {\n                return new _global.Promise(function (resolve, reject) {\n                    originalSetTimeout(function () {\n                        try {\n                            const timer = lastTimer(clock);\n                            if (!timer) {\n                                runJobs(clock);\n                                resolve(clock.now);\n                            }\n\n                            resolve(clock.tickAsync(timer.callAt - clock.now));\n                        } catch (e) {\n                            reject(e);\n                        }\n                    });\n                });\n            };\n        }\n\n        clock.reset = function reset() {\n            nanos = 0;\n            clock.timers = {};\n            clock.jobs = [];\n            clock.now = start;\n        };\n\n        clock.setSystemTime = function setSystemTime(systemTime) {\n            // determine time difference\n            const newNow = getEpoch(systemTime);\n            const difference = newNow - clock.now;\n            let id, timer;\n\n            adjustedSystemTime[0] = adjustedSystemTime[0] + difference;\n            adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;\n            // update \'system clock\'\n            clock.now = newNow;\n            nanos = 0;\n\n            // update timers and intervals to keep them stable\n            for (id in clock.timers) {\n                if (clock.timers.hasOwnProperty(id)) {\n                    timer = clock.timers[id];\n                    timer.createdAt += difference;\n                    timer.callAt += difference;\n                }\n            }\n        };\n\n        /**\n         * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"\n         * @returns {number} will return the new `now` value\n         */\n        clock.jump = function jump(tickValue) {\n            const msFloat =\n                typeof tickValue === "number"\n                    ? tickValue\n                    : parseTime(tickValue);\n            const ms = Math.floor(msFloat);\n\n            for (const timer of Object.values(clock.timers)) {\n                if (clock.now + ms > timer.callAt) {\n                    timer.callAt = clock.now + ms;\n                }\n            }\n            clock.tick(ms);\n        };\n\n        if (performancePresent) {\n            clock.performance = Object.create(null);\n            clock.performance.now = fakePerformanceNow;\n        }\n\n        if (hrtimePresent) {\n            clock.hrtime = hrtime;\n        }\n\n        return clock;\n    }\n\n    /* eslint-disable complexity */\n\n    /**\n     * @param {Config=} [config] Optional config\n     * @returns {Clock}\n     */\n    function install(config) {\n        if (\n            arguments.length > 1 ||\n            config instanceof Date ||\n            Array.isArray(config) ||\n            typeof config === "number"\n        ) {\n            throw new TypeError(\n                `FakeTimers.install called with ${String(\n                    config,\n                )} install requires an object parameter`,\n            );\n        }\n\n        if (_global.Date.isFake === true) {\n            // Timers are already faked; this is a problem.\n            // Make the user reset timers before continuing.\n            throw new TypeError(\n                "Can\'t install fake timers twice on the same global object.",\n            );\n        }\n\n        // eslint-disable-next-line no-param-reassign\n        config = typeof config !== "undefined" ? config : {};\n        config.shouldAdvanceTime = config.shouldAdvanceTime || false;\n        config.advanceTimeDelta = config.advanceTimeDelta || 20;\n        config.shouldClearNativeTimers =\n            config.shouldClearNativeTimers || false;\n\n        if (config.target) {\n            throw new TypeError(\n                "config.target is no longer supported. Use `withGlobal(target)` instead.",\n            );\n        }\n\n        let i, l;\n        const clock = createClock(config.now, config.loopLimit);\n        clock.shouldClearNativeTimers = config.shouldClearNativeTimers;\n\n        clock.uninstall = function () {\n            return uninstall(clock, config);\n        };\n\n        clock.methods = config.toFake || [];\n\n        if (clock.methods.length === 0) {\n            // do not fake nextTick by default - GitHub#126\n            clock.methods = Object.keys(timers).filter(function (key) {\n                return key !== "nextTick" && key !== "queueMicrotask";\n            });\n        }\n\n        if (config.shouldAdvanceTime === true) {\n            const intervalTick = doIntervalTick.bind(\n                null,\n                clock,\n                config.advanceTimeDelta,\n            );\n            const intervalId = _global.setInterval(\n                intervalTick,\n                config.advanceTimeDelta,\n            );\n            clock.attachedInterval = intervalId;\n        }\n\n        if (clock.methods.includes("performance")) {\n            const proto = (() => {\n                if (hasPerformanceConstructorPrototype) {\n                    return _global.performance.constructor.prototype;\n                }\n                if (hasPerformancePrototype) {\n                    return _global.Performance.prototype;\n                }\n            })();\n            if (proto) {\n                Object.getOwnPropertyNames(proto).forEach(function (name) {\n                    if (name !== "now") {\n                        clock.performance[name] =\n                            name.indexOf("getEntries") === 0\n                                ? NOOP_ARRAY\n                                : NOOP;\n                    }\n                });\n            } else if ((config.toFake || []).includes("performance")) {\n                // user explicitly tried to fake performance when not present\n                throw new ReferenceError(\n                    "non-existent performance object cannot be faked",\n                );\n            }\n        }\n        for (i = 0, l = clock.methods.length; i < l; i++) {\n            const nameOfMethodToReplace = clock.methods[i];\n            if (nameOfMethodToReplace === "hrtime") {\n                if (\n                    _global.process &&\n                    typeof _global.process.hrtime === "function"\n                ) {\n                    hijackMethod(_global.process, nameOfMethodToReplace, clock);\n                }\n            } else if (nameOfMethodToReplace === "nextTick") {\n                if (\n                    _global.process &&\n                    typeof _global.process.nextTick === "function"\n                ) {\n                    hijackMethod(_global.process, nameOfMethodToReplace, clock);\n                }\n            } else {\n                hijackMethod(_global, nameOfMethodToReplace, clock);\n            }\n        }\n\n        return clock;\n    }\n\n    /* eslint-enable complexity */\n\n    return {\n        timers: timers,\n        createClock: createClock,\n        install: install,\n        withGlobal: withGlobal,\n    };\n}\n\n/**\n * @typedef {object} FakeTimers\n * @property {Timers} timers\n * @property {createClock} createClock\n * @property {Function} install\n * @property {withGlobal} withGlobal\n */\n\n// /** @type {FakeTimers} */\nwindow.__wdio_sinon = withGlobal(globalThis);\n\n// // exports.timers = defaultImplementation.timers;\n// // exports.createClock = defaultImplementation.createClock;\n// // exports.install = defaultImplementation.install;\n// // exports.withGlobal = withGlobal;\n}\n';
 var _browser, _resetFn, _isInstalled;
 var ClockManager = class {
-  constructor(browser) {
+  constructor(browser2) {
     __privateAdd(this, _browser);
     __privateAdd(this, _resetFn, () => Promise.resolve());
     __privateAdd(this, _isInstalled, false);
-    __privateSet(this, _browser, browser);
+    __privateSet(this, _browser, browser2);
   }
   /**
    * Install fake timers on the browser. If you call the `emulate` command, WebdriverIO will automatically install
@@ -2626,14 +2626,14 @@ var deviceDescriptorsSource = {
 };
 
 // src/commands/browser/emulate.ts
-function storeRestoreFunction(browser, scope, fn) {
+function storeRestoreFunction(browser2, scope, fn) {
   var _a, _b;
-  if (!restoreFunctions.has(browser)) {
-    restoreFunctions.set(browser, /* @__PURE__ */ new Map());
+  if (!restoreFunctions.has(browser2)) {
+    restoreFunctions.set(browser2, /* @__PURE__ */ new Map());
   }
-  const restoreFunctionsList = (_a = restoreFunctions.get(browser)) == null ? void 0 : _a.get(scope);
+  const restoreFunctionsList = (_a = restoreFunctions.get(browser2)) == null ? void 0 : _a.get(scope);
   const updatedList = restoreFunctionsList ? [...restoreFunctionsList, fn] : [fn];
-  (_b = restoreFunctions.get(browser)) == null ? void 0 : _b.set(scope, updatedList);
+  (_b = restoreFunctions.get(browser2)) == null ? void 0 : _b.set(scope, updatedList);
 }
 async function emulate(scope, options) {
   if (!this.isBidi) {
@@ -3003,11 +3003,11 @@ var SessionManager = class {
    * @param browser WebdriverIO.Browser
    * @param scope   scope of the session manager, e.g. context, network etc.
    */
-  constructor(browser, scope) {
+  constructor(browser2, scope) {
     __privateAdd(this, _SessionManager_instances);
     __privateAdd(this, _browser2);
     __privateAdd(this, _scope);
-    __privateSet(this, _browser2, browser);
+    __privateSet(this, _browser2, browser2);
     __privateGet(this, _browser2).on("command", __privateMethod(this, _SessionManager_instances, onCommand_fn).bind(this));
     __privateSet(this, _scope, scope);
   }
@@ -3027,17 +3027,17 @@ var SessionManager = class {
       !process.env.WDIO_UNIT_TESTS
     );
   }
-  static getSessionManager(browser, Manager) {
+  static getSessionManager(browser2, Manager) {
     const scope = Manager.name;
     let sessionManagerInstances = sessionManager.get(scope);
     if (!sessionManagerInstances) {
       sessionManagerInstances = /* @__PURE__ */ new Map();
       sessionManager.set(scope, sessionManagerInstances);
     }
-    let sessionManagerInstance = sessionManagerInstances.get(browser);
+    let sessionManagerInstance = sessionManagerInstances.get(browser2);
     if (!sessionManagerInstance) {
-      sessionManagerInstance = new Manager(browser);
-      sessionManagerInstances.set(browser, sessionManagerInstance);
+      sessionManagerInstance = new Manager(browser2);
+      sessionManagerInstances.set(browser2, sessionManagerInstance);
     }
     return sessionManagerInstance;
   }
@@ -3082,20 +3082,20 @@ function getMobileContext({ capabilities, isAndroid, isNativeContext }) {
     isAndroid && ((_a = capabilities == null ? void 0 : capabilities.browserName) == null ? void 0 : _a.toLowerCase()) === "chrome" ? "CHROMIUM" : void 0
   );
 }
-function calculateAndroidPinchAndZoomSpeed({ browser, duration, scale }) {
+function calculateAndroidPinchAndZoomSpeed({ browser: browser2, duration, scale }) {
   var _a;
-  const deviceScreenSize = (((_a = browser.capabilities) == null ? void 0 : _a.deviceScreenSize) || "1080x2400").split("x").reduce((a, b) => a * b);
+  const deviceScreenSize = (((_a = browser2.capabilities) == null ? void 0 : _a.deviceScreenSize) || "1080x2400").split("x").reduce((a, b) => a * b);
   const baseDistance = Math.sqrt(deviceScreenSize);
   const gestureDistance = Math.max(baseDistance * Math.abs(scale), baseDistance * 0.1);
   const durationSeconds = duration / 1e3;
   return Math.floor(gestureDistance / durationSeconds);
 }
-function validatePinchAndZoomOptions({ browser, gesture, options }) {
+function validatePinchAndZoomOptions({ browser: browser2, gesture, options }) {
   if (typeof options !== "undefined" && (typeof options !== "object" || Array.isArray(options))) {
     throw new TypeError("Options must be an object");
   }
   const DEFAULT_SCALE = 0.5;
-  const DEFAULT_DURATION = browser.isIOS ? 1.5 : 1500;
+  const DEFAULT_DURATION = browser2.isIOS ? 1.5 : 1500;
   const MIN_SCALE = 0;
   const MAX_SCALE = 1;
   const MIN_DURATION_MS = 500;
@@ -3104,31 +3104,31 @@ function validatePinchAndZoomOptions({ browser, gesture, options }) {
   const scale = typeof scaleOption === "number" ? scaleOption >= MIN_SCALE && scaleOption <= MAX_SCALE ? scaleOption : (() => {
     throw new Error("The 'scale' option must be a number between ".concat(MIN_SCALE, " and ").concat(MAX_SCALE));
   })() : DEFAULT_SCALE;
-  const duration = typeof durationOption === "number" ? durationOption >= MIN_DURATION_MS && durationOption <= MAX_DURATION_MS ? browser.isIOS ? durationOption / 1e3 : durationOption : (() => {
+  const duration = typeof durationOption === "number" ? durationOption >= MIN_DURATION_MS && durationOption <= MAX_DURATION_MS ? browser2.isIOS ? durationOption / 1e3 : durationOption : (() => {
     throw new Error("The 'duration' option must be between ".concat(MIN_DURATION_MS, " and ").concat(MAX_DURATION_MS, " ms (").concat(MIN_DURATION_MS / 1e3, " and ").concat(MAX_DURATION_MS / 1e3, "  seconds)"));
   })() : DEFAULT_DURATION;
   return {
     duration,
-    scale: browser.isIOS && gesture === "zoom" ? scale * 10 : scale
+    scale: browser2.isIOS && gesture === "zoom" ? scale * 10 : scale
   };
 }
 
 // src/session/context.ts
 var log3 = logger3("webdriverio:context");
 var COMMANDS_REQUIRING_RESET = ["deleteSession", "refresh", "switchToParentFrame"];
-function getContextManager(browser) {
-  return SessionManager.getSessionManager(browser, ContextManager);
+function getContextManager(browser2) {
+  return SessionManager.getSessionManager(browser2, ContextManager);
 }
 var _browser3, _currentContext, _mobileContext, _isNativeContext, _ContextManager_instances, onCommandResultBidiAndClassic_fn, onCommand_fn2, onCommandResultMobile_fn;
 var _ContextManager = class _ContextManager extends SessionManager {
-  constructor(browser) {
-    super(browser, _ContextManager.name);
+  constructor(browser2) {
+    super(browser2, _ContextManager.name);
     __privateAdd(this, _ContextManager_instances);
     __privateAdd(this, _browser3);
     __privateAdd(this, _currentContext);
     __privateAdd(this, _mobileContext);
     __privateAdd(this, _isNativeContext);
-    __privateSet(this, _browser3, browser);
+    __privateSet(this, _browser3, browser2);
     const capabilities = __privateGet(this, _browser3).capabilities;
     __privateSet(this, _isNativeContext, getNativeContext({ capabilities, isMobile: __privateGet(this, _browser3).isMobile }));
     __privateSet(this, _mobileContext, getMobileContext({
@@ -3141,6 +3141,22 @@ var _ContextManager = class _ContextManager extends SessionManager {
       return;
     }
     __privateGet(this, _browser3).on("command", __privateMethod(this, _ContextManager_instances, onCommand_fn2).bind(this));
+    __privateGet(this, _browser3).sessionSubscribe({
+      events: ["browsingContext.navigationStarted"]
+    });
+    __privateGet(this, _browser3).on("browsingContext.navigationStarted", async (nav) => {
+      if (!__privateGet(this, _currentContext) || nav.context === __privateGet(this, _currentContext)) {
+        return;
+      }
+      const { contexts } = await __privateGet(this, _browser3).browsingContextGetTree({});
+      const hasContext = this.findContext(__privateGet(this, _currentContext), contexts, "byContextId");
+      const newContext = contexts.find((context) => context.context === nav.context);
+      if (!hasContext && newContext) {
+        this.setCurrentContext(newContext.context);
+        __privateGet(this, _browser3).switchToWindow(__privateGet(this, _currentContext));
+        return;
+      }
+    });
     if (__privateGet(this, _browser3).isMobile) {
       __privateGet(this, _browser3).on("result", __privateMethod(this, _ContextManager_instances, onCommandResultMobile_fn).bind(this));
     }
@@ -3316,8 +3332,8 @@ function byContextId(context, contextId) {
 
 // src/session/polyfill.ts
 import logger4 from "@wdio/logger";
-function getPolyfillManager(browser) {
-  return SessionManager.getSessionManager(browser, PolyfillManager);
+function getPolyfillManager(browser2) {
+  return SessionManager.getSessionManager(browser2, PolyfillManager);
 }
 var log4 = logger4("webdriverio:PolyfillManager");
 var polyfillFn = function webdriverioPolyfill() {
@@ -3330,13 +3346,13 @@ var polyfillFn = function webdriverioPolyfill() {
 };
 var _initialize, _browser4, _scriptsRegisteredInContexts, _PolyfillManager_instances, registerScripts_fn;
 var _PolyfillManager = class _PolyfillManager extends SessionManager {
-  constructor(browser) {
-    super(browser, _PolyfillManager.name);
+  constructor(browser2) {
+    super(browser2, _PolyfillManager.name);
     __privateAdd(this, _PolyfillManager_instances);
     __privateAdd(this, _initialize);
     __privateAdd(this, _browser4);
     __privateAdd(this, _scriptsRegisteredInContexts, /* @__PURE__ */ new Set());
-    __privateSet(this, _browser4, browser);
+    __privateSet(this, _browser4, browser2);
     if (!this.isEnabled()) {
       __privateSet(this, _initialize, Promise.resolve(true));
       return;
@@ -3391,8 +3407,8 @@ async function execute(script, ...args) {
     throw new Error("number or type of arguments don't agree with execute protocol command");
   }
   if (this.isBidi && !this.isMultiremote) {
-    const browser = getBrowserObject3(this);
-    const contextManager = getContextManager(browser);
+    const browser2 = getBrowserObject3(this);
+    const contextManager = getContextManager(browser2);
     const context = await contextManager.getCurrentContext();
     const userScript = typeof script === "string" ? new Function(script) : script;
     const functionDeclaration = createFunctionDeclarationFromString(userScript);
@@ -3404,7 +3420,7 @@ async function execute(script, ...args) {
         context
       }
     };
-    const result = await browser.scriptCallFunction(params);
+    const result = await browser2.scriptCallFunction(params);
     return parseScriptResult(params, result);
   }
   if (typeof script === "function") {
@@ -3420,8 +3436,8 @@ async function executeAsync(script, ...args) {
     throw new Error("number or type of arguments don't agree with execute protocol command");
   }
   if (this.isBidi && !this.isMultiremote) {
-    const browser = getBrowserObject4(this);
-    const contextManager = getContextManager(browser);
+    const browser2 = getBrowserObject4(this);
+    const contextManager = getContextManager(browser2);
     const context = await contextManager.getCurrentContext();
     const userScript = typeof script === "string" ? new Function(script) : script;
     const functionDeclaration = new Function("\n            const args = Array.from(arguments)\n            return new Promise(async (resolve, reject) => {\n                const cb = (result) => resolve(result)\n                try {\n                    await (".concat(userScript.toString(), ").apply(this, [...args, cb])\n                } catch (err) {\n                    return reject(err)\n                }\n            })\n        ")).toString();
@@ -3433,7 +3449,7 @@ async function executeAsync(script, ...args) {
         context
       }
     };
-    const result = await browser.scriptCallFunction(params);
+    const result = await browser2.scriptCallFunction(params);
     return parseScriptResult(params, result);
   }
   if (typeof script === "function") {
@@ -3585,8 +3601,8 @@ async function getPuppeteer() {
 // src/commands/browser/getWindowSize.ts
 import { getBrowserObject as getBrowserObject5 } from "@wdio/utils";
 async function getWindowSize() {
-  const browser = getBrowserObject5(this);
-  const { width, height } = await browser.getWindowRect();
+  const browser2 = getBrowserObject5(this);
+  const { width, height } = await browser2.getWindowRect();
   return { width, height };
 }
 
@@ -3801,7 +3817,7 @@ var log7 = logger7("WebDriverInterception");
 var hasSubscribedToEvents = false;
 var _pattern, _mockId, _filterOptions, _browser5, _eventHandler, _restored, _requestOverwrites, _respondOverwrites, _calls, _WebDriverInterception_instances, emit_fn, addEventHandler_fn, handleBeforeRequestSent_fn, handleResponseStarted_fn, handleNetworkProvideResponseError_fn, isRequestMatching_fn, matchesFilterOptions_fn, _setOverwrite, ensureNotRestored_fn;
 var _WebDriverInterception = class _WebDriverInterception {
-  constructor(pattern, mockId, filterOptions, browser) {
+  constructor(pattern, mockId, filterOptions, browser2) {
     __privateAdd(this, _WebDriverInterception_instances);
     __privateAdd(this, _pattern);
     __privateAdd(this, _mockId);
@@ -3821,14 +3837,14 @@ var _WebDriverInterception = class _WebDriverInterception {
     __privateSet(this, _pattern, pattern);
     __privateSet(this, _mockId, mockId);
     __privateSet(this, _filterOptions, filterOptions);
-    __privateSet(this, _browser5, browser);
-    browser.on("network.beforeRequestSent", __privateMethod(this, _WebDriverInterception_instances, handleBeforeRequestSent_fn).bind(this));
-    browser.on("network.responseStarted", __privateMethod(this, _WebDriverInterception_instances, handleResponseStarted_fn).bind(this));
+    __privateSet(this, _browser5, browser2);
+    browser2.on("network.beforeRequestSent", __privateMethod(this, _WebDriverInterception_instances, handleBeforeRequestSent_fn).bind(this));
+    browser2.on("network.responseStarted", __privateMethod(this, _WebDriverInterception_instances, handleResponseStarted_fn).bind(this));
   }
-  static async initiate(url2, filterOptions, browser) {
+  static async initiate(url2, filterOptions, browser2) {
     const pattern = parseUrlPattern(url2);
     if (!hasSubscribedToEvents) {
-      await browser.sessionSubscribe({
+      await browser2.sessionSubscribe({
         events: [
           "network.beforeRequestSent",
           "network.responseStarted"
@@ -3837,7 +3853,7 @@ var _WebDriverInterception = class _WebDriverInterception {
       log7.info("subscribed to network events");
       hasSubscribedToEvents = true;
     }
-    const interception = await browser.networkAddIntercept({
+    const interception = await browser2.networkAddIntercept({
       phases: ["beforeRequestSent", "responseStarted"],
       urlPatterns: [{
         type: "pattern",
@@ -3848,7 +3864,7 @@ var _WebDriverInterception = class _WebDriverInterception {
         search: getPatternParam(pattern, "search")
       }]
     });
-    return new _WebDriverInterception(pattern, interception.intercept, filterOptions, browser);
+    return new _WebDriverInterception(pattern, interception.intercept, filterOptions, browser2);
   }
   /**
    * allows access to all requests made with given pattern
@@ -4146,8 +4162,8 @@ async function mock(url2, filterOptions) {
   if (!this.isBidi) {
     throw new Error("Mocking is only supported when running tests using WebDriver Bidi");
   }
-  const browser = getBrowserObject6(this);
-  const contextManager = getContextManager(browser);
+  const browser2 = getBrowserObject6(this);
+  const contextManager = getContextManager(browser2);
   const context = await contextManager.getCurrentContext();
   if (!SESSION_MOCKS[context]) {
     SESSION_MOCKS[context] = /* @__PURE__ */ new Set();
@@ -4345,20 +4361,20 @@ function customElementWrapper() {
 
 // src/session/shadowRoot.ts
 var log11 = logger11("webdriverio:ShadowRootManager");
-function getShadowRootManager(browser) {
-  return SessionManager.getSessionManager(browser, ShadowRootManager);
+function getShadowRootManager(browser2) {
+  return SessionManager.getSessionManager(browser2, ShadowRootManager);
 }
 var _browser6, _initialize2, _shadowRoots, _documentElement, _frameDepth, _ShadowRootManager_instances, handleBidiCommand_fn, commandResultHandler_fn;
 var _ShadowRootManager = class _ShadowRootManager extends SessionManager {
-  constructor(browser) {
-    super(browser, _ShadowRootManager.name);
+  constructor(browser2) {
+    super(browser2, _ShadowRootManager.name);
     __privateAdd(this, _ShadowRootManager_instances);
     __privateAdd(this, _browser6);
     __privateAdd(this, _initialize2);
     __privateAdd(this, _shadowRoots, /* @__PURE__ */ new Map());
     __privateAdd(this, _documentElement);
     __privateAdd(this, _frameDepth, 0);
-    __privateSet(this, _browser6, browser);
+    __privateSet(this, _browser6, browser2);
     if (!this.isEnabled()) {
       __privateSet(this, _initialize2, Promise.resolve(true));
       return;
@@ -4623,21 +4639,21 @@ var ShadowRootTree = class _ShadowRootTree {
 };
 
 // src/session/networkManager.ts
-function getNetworkManager(browser) {
-  return SessionManager.getSessionManager(browser, NetworkManager);
+function getNetworkManager(browser2) {
+  return SessionManager.getSessionManager(browser2, NetworkManager);
 }
 var UNKNOWN_NAVIGATION_ID = "UNKNOWN_NAVIGATION_ID";
 var SUPPORTED_NAVIGATION_PROTOCOLS = ["http", "https", "data", "file"];
 var _browser7, _initialize3, _requests, _lastNetworkId, _NetworkManager_instances, beforeRequestSent_fn, navigationStarted_fn, fetchError_fn, findRootRequest_fn, responseCompleted_fn;
 var _NetworkManager = class _NetworkManager extends SessionManager {
-  constructor(browser) {
-    super(browser, _NetworkManager.name);
+  constructor(browser2) {
+    super(browser2, _NetworkManager.name);
     __privateAdd(this, _NetworkManager_instances);
     __privateAdd(this, _browser7);
     __privateAdd(this, _initialize3);
     __privateAdd(this, _requests, /* @__PURE__ */ new Map());
     __privateAdd(this, _lastNetworkId);
-    __privateSet(this, _browser7, browser);
+    __privateSet(this, _browser7, browser2);
     if (!this.isEnabled()) {
       __privateSet(this, _initialize3, Promise.resolve(true));
       return;
@@ -4821,18 +4837,18 @@ function headerListToObject(headers) {
 }
 
 // src/session/dialog.ts
-function getDialogManager(browser) {
-  return SessionManager.getSessionManager(browser, DialogManager);
+function getDialogManager(browser2) {
+  return SessionManager.getSessionManager(browser2, DialogManager);
 }
 var _browser8, _initialize4, _autoHandleDialog, _DialogManager_instances, handleUserPrompt_fn, switchListenerFlag_fn;
 var _DialogManager = class _DialogManager extends SessionManager {
-  constructor(browser) {
-    super(browser, _DialogManager.name);
+  constructor(browser2) {
+    super(browser2, _DialogManager.name);
     __privateAdd(this, _DialogManager_instances);
     __privateAdd(this, _browser8);
     __privateAdd(this, _initialize4);
     __privateAdd(this, _autoHandleDialog, true);
-    __privateSet(this, _browser8, browser);
+    __privateSet(this, _browser8, browser2);
     if (!this.isEnabled()) {
       __privateSet(this, _initialize4, Promise.resolve(true));
       return;
@@ -4879,7 +4895,7 @@ switchListenerFlag_fn = function(value) {
 var DialogManager = _DialogManager;
 var _browser9, _context, _message, _defaultValue, _type2;
 var Dialog = class {
-  constructor(event, browser) {
+  constructor(event, browser2) {
     __privateAdd(this, _browser9);
     __privateAdd(this, _context);
     __privateAdd(this, _message);
@@ -4889,7 +4905,7 @@ var Dialog = class {
     __privateSet(this, _defaultValue, event.defaultValue);
     __privateSet(this, _type2, event.type);
     __privateSet(this, _context, event.context);
-    __privateSet(this, _browser9, browser);
+    __privateSet(this, _browser9, browser2);
   }
   message() {
     return __privateGet(this, _message);
@@ -5097,8 +5113,8 @@ async function setWindowSize(width, height) {
   if (width < minWindowSize2 || width > maxWindowSize2 || height < minWindowSize2 || height > maxWindowSize2) {
     throw new Error("setWindowSize expects width and height to be a number in the 0 to 2^31 \u2212 1 range");
   }
-  const browser = getBrowserObject7(this);
-  await browser.setWindowRect(null, null, width, height);
+  const browser2 = getBrowserObject7(this);
+  await browser2.setWindowRect(null, null, width, height);
 }
 
 // src/commands/browser/switchWindow.ts
@@ -5293,6 +5309,7 @@ async function switchFrame(context) {
       if (!result || result.type !== "success" || result.result.type !== "boolean" || !result.result.value) {
         continue;
       }
+      await browser.switchFrame(null);
       await this.switchFrame(contextId);
       return contextId;
     }
@@ -5302,23 +5319,23 @@ async function switchFrame(context) {
     "Invalid type for context parameter: ".concat(typeof context, ", expected one of number, string or null. ") + "Check out our docs: https://webdriver.io/docs/api/browser/switchFrame.html"
   );
 }
-function switchToFrameHelper(browser, context) {
-  const sessionContext = getContextManager(browser);
+function switchToFrameHelper(browser2, context) {
+  const sessionContext = getContextManager(browser2);
   sessionContext.setCurrentContext(context);
 }
-async function switchToFrameUsingElement(browser, element) {
-  const frame = await browser.execute(
+async function switchToFrameUsingElement(browser2, element) {
+  const frame = await browser2.execute(
     (iframe) => iframe.contentWindow,
     element
   );
-  switchToFrameHelper(browser, frame.context);
+  switchToFrameHelper(browser2, frame.context);
   const elementId = element[ELEMENT_KEY8];
-  await switchToFrame(browser, { [ELEMENT_KEY8]: elementId });
+  await switchToFrame(browser2, { [ELEMENT_KEY8]: elementId });
   return frame.context;
 }
-function switchToFrame(browser, frame) {
+function switchToFrame(browser2, frame) {
   process.env.DISABLE_WEBDRIVERIO_DEPRECATION_WARNINGS = "true";
-  return browser.switchToFrame(frame).finally(async () => {
+  return browser2.switchToFrame(frame).finally(async () => {
     delete process.env.DISABLE_WEBDRIVERIO_DEPRECATION_WARNINGS;
   });
 }
@@ -5329,8 +5346,8 @@ import { getBrowserObject as getBrowserObject8 } from "@wdio/utils";
 var log15 = logger15("webdriverio:throttle");
 async function throttle(params) {
   log15.warn('Command "throttle" is deprecated and will be removed with the next major version release! Use `throttleNetwork` instead.');
-  const browser = getBrowserObject8(this);
-  await browser.throttleNetwork(params);
+  const browser2 = getBrowserObject8(this);
+  await browser2.throttleNetwork(params);
 }
 
 // src/commands/browser/throttleCPU.ts
@@ -5429,8 +5446,8 @@ async function throttleNetwork(params) {
     throw new Error('Invalid parameter for "throttleNetwork". Expected it to be typeof object or one of the following values: '.concat(NETWORK_PRESET_TYPES.join(", "), ' but found "').concat(params, '"'));
   }
   if (this.isSauce) {
-    const browser = getBrowserObject9(this);
-    await browser.sauceThrottleNetwork(params);
+    const browser2 = getBrowserObject9(this);
+    await browser2.sauceThrottleNetwork(params);
     return null;
   }
   const failedConnectionMessage = "No Puppeteer connection could be established which is required to use this command";
@@ -5592,8 +5609,8 @@ var SWIPE_DEFAULTS = {
   PERCENT: 0.95
 };
 async function swipe(options) {
-  const browser = this;
-  if (!browser.isNativeContext) {
+  const browser2 = this;
+  if (!browser2.isNativeContext) {
     throw new Error("The swipe command is only available for mobile platforms in the NATIVE context.");
   }
   let { scrollableElement, from, to } = options || {};
@@ -5601,18 +5618,18 @@ async function swipe(options) {
     log16.warn("`scrollableElement` is provided, so `from` and `to` will be ignored.");
   }
   if (!from || !to) {
-    scrollableElement = scrollableElement || await getScrollableElement(browser);
+    scrollableElement = scrollableElement || await getScrollableElement(browser2);
     ({ from, to } = await calculateFromTo({
-      browser,
+      browser: browser2,
       direction: (options == null ? void 0 : options.direction) || SWIPE_DEFAULTS.DIRECTION,
       percentage: options == null ? void 0 : options.percent,
       scrollableElement
     }));
   }
-  return w3cSwipe({ browser, duration: (options == null ? void 0 : options.duration) || SWIPE_DEFAULTS.DURATION, from, to });
+  return w3cSwipe({ browser: browser2, duration: (options == null ? void 0 : options.duration) || SWIPE_DEFAULTS.DURATION, from, to });
 }
 async function calculateFromTo({
-  browser,
+  browser: browser2,
   direction,
   percentage,
   scrollableElement
@@ -5627,7 +5644,7 @@ async function calculateFromTo({
       swipePercentage = percentage;
     }
   }
-  const { x, y, width, height } = await browser.getElementRect(await (scrollableElement == null ? void 0 : scrollableElement.elementId));
+  const { x, y, width, height } = await browser2.getElementRect(await (scrollableElement == null ? void 0 : scrollableElement.elementId));
   const scrollRectangles = {
     top: { x: Math.round(x + width / 2), y: Math.round(y + height - height * swipePercentage) },
     right: { x: Math.round(x + width * swipePercentage), y: Math.round(y + height / 2) },
@@ -5658,31 +5675,31 @@ async function calculateFromTo({
   }
   return { from, to };
 }
-async function getScrollableElement(browser) {
+async function getScrollableElement(browser2) {
   const defaultAndroidSelector = "//android.widget.ScrollView";
   const defaultIosSelector = '-ios predicate string:type == "XCUIElementTypeApplication"';
-  const selector = browser.isIOS ? (
+  const selector = browser2.isIOS ? (
     // For iOS, we need to find the application element, if we can't find it, we should throw an error
     defaultIosSelector
   ) : (
     // There is always a scrollview for Android or, if this fails we should throw an error
     defaultAndroidSelector
   );
-  const scrollableElements = await browser.$$(
+  const scrollableElements = await browser2.$$(
     selector
   );
   if (scrollableElements.length > 0) {
     return scrollableElements[0];
   }
   throw new Error(
-    "Default scrollable element '".concat(browser.isIOS ? defaultIosSelector : defaultAndroidSelector, "' was not found. Our advice is to provide a scrollable element like this:\n\nawait browser.swipe({ scrollableElement: $('#scrollable') });\n\n        ")
+    "Default scrollable element '".concat(browser2.isIOS ? defaultIosSelector : defaultAndroidSelector, "' was not found. Our advice is to provide a scrollable element like this:\n\nawait browser.swipe({ scrollableElement: $('#scrollable') });\n\n        ")
   );
 }
-async function w3cSwipe({ browser, duration, from, to }) {
-  await browser.action("pointer", {
-    parameters: { pointerType: browser.isMobile ? "touch" : "mouse" }
+async function w3cSwipe({ browser: browser2, duration, from, to }) {
+  await browser2.action("pointer", {
+    parameters: { pointerType: browser2.isMobile ? "touch" : "mouse" }
   }).move(from.x, from.y).down().pause(10).move({ duration, x: to.x, y: to.y }).up().perform();
-  return browser.pause(500);
+  return browser2.pause(500);
 }
 
 // src/commands/mobile/tap.ts
@@ -5692,18 +5709,18 @@ var log17 = logger17("webdriver");
 async function tap(options) {
   const isElement2 = this.selector !== void 0;
   const element = isElement2 ? this : null;
-  const browser = isElement2 ? getBrowserObject10(this) : this;
-  if (!browser.isMobile) {
+  const browser2 = isElement2 ? getBrowserObject10(this) : this;
+  if (!browser2.isMobile) {
     throw new Error("The tap command is only available for mobile platforms.");
   }
   validateTapOptions(options);
   if (element) {
-    return await elementTap(browser, element, options);
+    return await elementTap(browser2, element, options);
   }
   if (!options || options.x === void 0 || options.y === void 0) {
     throw new Error("The tap command requires x and y coordinates to be set for screen taps.");
   }
-  return await screenTap(browser, options);
+  return await screenTap(browser2, options);
 }
 function validateTapOptions(options) {
   if (options) {
@@ -5729,9 +5746,9 @@ function validateTapOptions(options) {
     }
   }
 }
-async function elementTap(browser, element, options) {
-  if (browser.isNativeContext) {
-    return await nativeTap(element, browser, options);
+async function elementTap(browser2, element, options) {
+  if (browser2.isNativeContext) {
+    return await nativeTap(element, browser2, options);
   }
   if (options) {
     log17.warn("The options object is not supported in Web environments and will be ignored.");
@@ -5741,18 +5758,18 @@ async function elementTap(browser, element, options) {
 async function webTap(element) {
   return element.click();
 }
-async function executeNativeTap(browser, options) {
-  return await browser.execute(
-    "mobile: ".concat(browser.isIOS ? "tap" : "clickGesture"),
-    { ...browser.isIOS ? { x: 0, y: 0 } : {}, ...options }
+async function executeNativeTap(browser2, options) {
+  return await browser2.execute(
+    "mobile: ".concat(browser2.isIOS ? "tap" : "clickGesture"),
+    { ...browser2.isIOS ? { x: 0, y: 0 } : {}, ...options }
   );
 }
-async function nativeTap(element, browser, options = {}) {
+async function nativeTap(element, browser2, options = {}) {
   try {
     if (!element.elementId) {
       throw new Error("no such element");
     }
-    return await executeNativeTap(browser, { elementId: element.elementId });
+    return await executeNativeTap(browser2, { elementId: element.elementId });
   } catch (error) {
     let err = error;
     if (typeof error === "string") {
@@ -5770,7 +5787,7 @@ async function nativeTap(element, browser, options = {}) {
     );
     try {
       await element.scrollIntoView(scrollIntoViewOptions);
-      return await executeNativeTap(browser, { elementId: element.elementId });
+      return await executeNativeTap(browser2, { elementId: element.elementId });
     } catch (scrollError) {
       let err2 = scrollError;
       if (typeof scrollError === "string") {
@@ -5787,12 +5804,12 @@ async function nativeTap(element, browser, options = {}) {
     }
   }
 }
-async function screenTap(browser, options) {
+async function screenTap(browser2, options) {
   const { x, y } = options;
-  if (browser.isNativeContext) {
-    return await executeNativeTap(browser, options);
+  if (browser2.isNativeContext) {
+    return await executeNativeTap(browser2, options);
   }
-  return await browser.action(
+  return await browser2.action(
     "pointer",
     {
       parameters: { pointerType: "touch" }
@@ -5804,19 +5821,19 @@ async function screenTap(browser, options) {
 import logger18 from "@wdio/logger";
 var log18 = logger18("webdriver");
 async function getContext(options) {
-  const browser = this;
-  if (!browser.isMobile) {
+  const browser2 = this;
+  if (!browser2.isMobile) {
     throw new Error("The `getContext` command is only available for mobile platforms.");
   }
-  const currentAppiumContext = await browser.getAppiumContext();
+  const currentAppiumContext = await browser2.getAppiumContext();
   if (!options || !(options == null ? void 0 : options.returnDetailedContext) || currentAppiumContext === "NATIVE_APP") {
     return currentAppiumContext;
   }
   delete options.returnDetailedContext;
-  return getDetailedContext(browser, currentAppiumContext, options);
+  return getDetailedContext(browser2, currentAppiumContext, options);
 }
-async function getDetailedContext(browser, currentAppiumContext, options) {
-  const detailedContexts = await browser.getContexts({
+async function getDetailedContext(browser2, currentAppiumContext, options) {
+  const detailedContexts = await browser2.getContexts({
     ...{ options },
     // Defaults
     returnDetailedContexts: true,
@@ -5843,13 +5860,13 @@ async function getDetailedContext(browser, currentAppiumContext, options) {
 import logger19 from "@wdio/logger";
 var log19 = logger19("webdriver");
 async function getContexts(options) {
-  const browser = this;
-  if (!browser.isMobile) {
+  const browser2 = this;
+  if (!browser2.isMobile) {
     throw new Error("The `getContexts` command is only available for mobile platforms.");
   }
   if (!options || !options.returnDetailedContexts) {
     log19.info("The standard Appium `contexts` method is used. If you want to get more detailed data, you can set `returnDetailedContexts` to `true`.");
-    return browser.getAppiumContexts();
+    return browser2.getAppiumContexts();
   }
   const defaultOptions = {
     androidWebviewConnectionRetryTime: 500,
@@ -5858,7 +5875,7 @@ async function getContexts(options) {
     isAndroidWebviewVisible: true,
     returnAndroidDescriptionData: false
   };
-  return getCurrentContexts({ browser, ...{ ...defaultOptions, ...options } });
+  return getCurrentContexts({ browser: browser2, ...{ ...defaultOptions, ...options } });
 }
 var CHROME_PACKAGE_NAME = "com.android.chrome";
 async function parsedAndroidContexts({
@@ -5928,7 +5945,7 @@ async function parsedAndroidContexts({
   return result;
 }
 async function getCurrentContexts({
-  browser,
+  browser: browser2,
   androidWebviewConnectionRetryTime,
   androidWebviewConnectTimeout,
   filterByCurrentAndroidApp,
@@ -5936,11 +5953,11 @@ async function getCurrentContexts({
   returnAndroidDescriptionData
 }) {
   var _a;
-  const contexts = await browser.execute("mobile: getContexts");
-  if (browser.isIOS) {
+  const contexts = await browser2.execute("mobile: getContexts");
+  if (browser2.isIOS) {
     return contexts;
   }
-  const packageName = await browser.getCurrentPackage();
+  const packageName = await browser2.getCurrentPackage();
   const startTime = Date.now();
   const retryInterval = androidWebviewConnectionRetryTime;
   let isPackageNameMissing = false;
@@ -5979,8 +5996,8 @@ async function getCurrentContexts({
 import logger20 from "@wdio/logger";
 var log20 = logger20("webdriver");
 async function switchContext(options) {
-  const browser = this;
-  if (!browser.isMobile) {
+  const browser2 = this;
+  if (!browser2.isMobile) {
     throw new Error("The `switchContext` command is only available for mobile platforms.");
   }
   if (!options) {
@@ -5988,14 +6005,14 @@ async function switchContext(options) {
   }
   if (typeof options === "string") {
     log20.info("The standard Appium `context`-method is used. If you want to switch to a webview with a specific title or url, please provide an object with the `title` or `url` property. See https://webdriver.io/docs/api/mobile/switchContext for more information.");
-    return browser.switchAppiumContext(options);
+    return browser2.switchAppiumContext(options);
   }
   if (!options.title && !options.url) {
     throw new Error("You need to provide at least a `title` or `url` property to use full potential of the `switchContext` command. See https://webdriver.io/docs/api/mobile/switchContext for more information.");
   }
-  return switchToContext({ browser, options });
+  return switchToContext({ browser: browser2, options });
 }
-async function switchToContext({ browser, options }) {
+async function switchToContext({ browser: browser2, options }) {
   var _a;
   const getContextsOptions = {
     returnDetailedContexts: true,
@@ -6005,19 +6022,19 @@ async function switchToContext({ browser, options }) {
     ...(options == null ? void 0 : options.androidWebviewConnectionRetryTime) && { androidWebviewConnectionRetryTime: options.androidWebviewConnectionRetryTime },
     ...(options == null ? void 0 : options.androidWebviewConnectTimeout) && { androidWebviewConnectTimeout: options.androidWebviewConnectTimeout }
   };
-  const contexts = await browser.getContexts(getContextsOptions);
-  const identifier = browser.isIOS ? (_a = await browser.execute("mobile: activeAppInfo")) == null ? void 0 : _a.bundleId : await browser.getCurrentPackage();
-  const { matchingContext, reasons } = findMatchingContext({ browser, contexts, identifier, ...(options == null ? void 0 : options.title) && { title: options.title }, ...(options == null ? void 0 : options.url) && { url: options.url } });
+  const contexts = await browser2.getContexts(getContextsOptions);
+  const identifier = browser2.isIOS ? (_a = await browser2.execute("mobile: activeAppInfo")) == null ? void 0 : _a.bundleId : await browser2.getCurrentPackage();
+  const { matchingContext, reasons } = findMatchingContext({ browser: browser2, contexts, identifier, ...(options == null ? void 0 : options.title) && { title: options.title }, ...(options == null ? void 0 : options.url) && { url: options.url } });
   if (!matchingContext) {
     throw new Error(reasons.join("\n"));
   }
   log20.info("WebdriverIO found a matching context:", JSON.stringify(matchingContext, null, 2));
-  if (!browser.isIOS) {
+  if (!browser2.isIOS) {
     const webviewName = "WEBVIEW_".concat(identifier);
-    await browser.switchAppiumContext(webviewName);
+    await browser2.switchAppiumContext(webviewName);
   }
-  const switchFunction = browser.isIOS ? browser.switchAppiumContext.bind(browser) : browser.switchToWindow.bind(browser);
-  const matchingContextId = browser.isIOS ? matchingContext.id : matchingContext.webviewPageId;
+  const switchFunction = browser2.isIOS ? browser2.switchAppiumContext.bind(browser2) : browser2.switchToWindow.bind(browser2);
+  const matchingContextId = browser2.isIOS ? matchingContext.id : matchingContext.webviewPageId;
   return switchFunction(matchingContextId);
 }
 function findMatchingContext({
@@ -6186,9 +6203,9 @@ async function actionClick(element, options) {
   if (!buttonValue.includes(button)) {
     throw new Error("Button type not supported.");
   }
-  const browser = getBrowserObject11(element);
+  const browser2 = getBrowserObject11(element);
   if (x || y) {
-    const { width, height } = await browser.getElementRect(element.elementId);
+    const { width, height } = await browser2.getElementRect(element.elementId);
     if (x && x < -Math.floor(width / 2) || x && x > Math.floor(width / 2)) {
       log21.warn("x would cause a out of bounds error as it goes outside of element");
     }
@@ -6197,8 +6214,8 @@ async function actionClick(element, options) {
     }
   }
   const clickNested = async () => {
-    await browser.action("pointer", {
-      parameters: { pointerType: browser.isMobile ? "touch" : "mouse" }
+    await browser2.action("pointer", {
+      parameters: { pointerType: browser2.isMobile ? "touch" : "mouse" }
     }).move({ origin: element, x, y }).down({ button }).pause(duration).up({ button }).perform(skipRelease);
   };
   try {
@@ -6257,8 +6274,8 @@ async function custom$2(strategyName, ...strategyArguments) {
 // src/commands/element/doubleClick.ts
 import { getBrowserObject as getBrowserObject14 } from "@wdio/utils";
 async function doubleClick() {
-  const browser = getBrowserObject14(this);
-  return browser.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: this }).down().up().pause(10).down().up().perform();
+  const browser2 = getBrowserObject14(this);
+  return browser2.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: this }).down().up().pause(10).down().up().perform();
 }
 
 // src/commands/element/dragAndDrop.ts
@@ -6282,8 +6299,8 @@ async function dragAndDrop(target, options = {}) {
     throw new Error('command dragAndDrop requires an WebdriverIO Element or and object with "x" and "y" variables as first parameter');
   }
   const ACTION_BUTTON = 0;
-  const browser = getBrowserObject15(this);
-  const defaultOptions = { duration: browser.isMobile ? 250 : 10 };
+  const browser2 = getBrowserObject15(this);
+  const defaultOptions = { duration: browser2.isMobile ? 250 : 10 };
   const { duration } = { ...defaultOptions, ...options };
   const isMovingToElement = moveToElement.constructor.name === "Element";
   const sourceRef = { [ELEMENT_KEY11]: this[ELEMENT_KEY11] };
@@ -6292,23 +6309,23 @@ async function dragAndDrop(target, options = {}) {
   const targetOrigin = isMovingToElement ? targetRef : "pointer";
   const targetX = isMovingToElement ? 0 : moveToCoordinates.x;
   const targetY = isMovingToElement ? 0 : moveToCoordinates.y;
-  return browser.action("pointer", {
-    parameters: { pointerType: browser.isMobile ? "touch" : "mouse" }
+  return browser2.action("pointer", {
+    parameters: { pointerType: browser2.isMobile ? "touch" : "mouse" }
   }).move({ duration: 0, origin, x: 0, y: 0 }).down({ button: ACTION_BUTTON }).pause(10).move({ duration, origin: targetOrigin, x: targetX, y: targetY }).up({ button: ACTION_BUTTON }).perform();
 }
 
 // src/commands/element/execute.ts
 import { getBrowserObject as getBrowserObject16 } from "@wdio/utils";
 async function execute2(script, ...args) {
-  const browser = getBrowserObject16(this);
-  return browser.execute(script, this, ...args);
+  const browser2 = getBrowserObject16(this);
+  return browser2.execute(script, this, ...args);
 }
 
 // src/commands/element/executeAsync.ts
 import { getBrowserObject as getBrowserObject17 } from "@wdio/utils";
 async function executeAsync2(script, ...args) {
-  const browser = getBrowserObject17(this);
-  return browser.executeAsync(script, this, ...args);
+  const browser2 = getBrowserObject17(this);
+  return browser2.executeAsync(script, this, ...args);
 }
 
 // src/commands/element/getAttribute.ts
@@ -6382,9 +6399,9 @@ function mergeEqualSymmetricalValue(cssValues) {
   return newCssValues.join(" ");
 }
 async function getPseudoElementCSSValue(elem, options) {
-  const browser = getBrowserObject18(elem);
+  const browser2 = getBrowserObject18(elem);
   const { cssProperty, pseudoElement } = options;
-  const cssValue2 = await browser.execute(
+  const cssValue2 = await browser2.execute(
     (elem2, pseudoElement2, cssProperty2) => window.getComputedStyle(elem2, pseudoElement2)[cssProperty2],
     elem,
     pseudoElement,
@@ -6445,7 +6462,7 @@ function getHTMLShadow(element, includeSelectorTag, shadowElementIds = []) {
 var SHADOW_ID_ATTR_NAME = "data-wdio-shadow-id";
 var SHADOW_ID_ATTR = "[".concat(SHADOW_ID_ATTR_NAME, "]");
 async function getHTML2(options = {}) {
-  const browser = getBrowserObject19(this);
+  const browser2 = getBrowserObject19(this);
   if (typeof options !== "object" && typeof options === "boolean") {
     options = { includeSelectorTag: options };
   } else if (typeof options !== "object") {
@@ -6459,7 +6476,7 @@ async function getHTML2(options = {}) {
     excludeElements: []
   }, options);
   const basicGetHTML = (elementId, includeSelectorTag2) => {
-    return browser.execute(getHTML, {
+    return browser2.execute(getHTML, {
       [ELEMENT_KEY12]: elementId,
       // w3c compatible
       ELEMENT: elementId
@@ -6475,12 +6492,12 @@ async function getHTML2(options = {}) {
       );
     }
     const { load } = await import("cheerio");
-    const shadowRootManager = getShadowRootManager(browser);
-    const contextManager = getContextManager(browser);
+    const shadowRootManager = getShadowRootManager(browser2);
+    const contextManager = getContextManager(browser2);
     const context = await contextManager.getCurrentContext();
     const shadowRootElementPairs = shadowRootManager.getShadowElementPairsByContextId(context, this.elementId);
     const elementsWithShadowRootAndIdVerified = (await Promise.all(
-      shadowRootElementPairs.map(([elemId, elem]) => browser.execute((elem2) => elem2.tagName, { [ELEMENT_KEY12]: elemId }).then(
+      shadowRootElementPairs.map(([elemId, elem]) => browser2.execute((elem2) => elem2.tagName, { [ELEMENT_KEY12]: elemId }).then(
         () => [elemId, elem],
         () => void 0
       ))
@@ -6489,7 +6506,7 @@ async function getHTML2(options = {}) {
       { [ELEMENT_KEY12]: elemId },
       shadowId ? { [ELEMENT_KEY12]: shadowId } : void 0
     ]);
-    const { html, shadowElementHTML } = await browser.execute(
+    const { html, shadowElementHTML } = await browser2.execute(
       getHTMLShadow,
       { [ELEMENT_KEY12]: this.elementId },
       includeSelectorTag,
@@ -6700,8 +6717,8 @@ async function isClickable() {
   if (this.isMobile && this.isNativeContext) {
     throw new Error("Method not supported in mobile native environment. It is unlikely that you need to use this command.");
   }
-  const browser = getBrowserObject20(this);
-  return browser.execute(isElementClickable, {
+  const browser2 = getBrowserObject20(this);
+  return browser2.execute(isElementClickable, {
     [ELEMENT_KEY13]: this.elementId,
     // w3c compatible
     ELEMENT: this.elementId
@@ -6893,12 +6910,12 @@ function isElementInViewport(elem) {
 
 // src/commands/element/isDisplayed.ts
 async function isDisplayed(commandParams = DEFAULT_PARAMS) {
-  const browser = getBrowserObject21(this);
+  const browser2 = getBrowserObject21(this);
   if (!await hasElementId(this)) {
     return false;
   }
-  const isNativeApplication = !browser.capabilities.browserName;
-  if (browser.isMobile && isNativeApplication) {
+  const isNativeApplication = !browser2.capabilities.browserName;
+  if (browser2.isMobile && isNativeApplication) {
     if (commandParams == null ? void 0 : commandParams.withinViewport) {
       throw new Error(
         "Cannot determine element visibility within viewport for native mobile apps as it is not feasible to determine full vertical and horizontal application bounds. In most cases a basic visibility check should suffice."
@@ -6908,12 +6925,12 @@ async function isDisplayed(commandParams = DEFAULT_PARAMS) {
   }
   let hadToFallback = false;
   const [isDisplayed2, displayProperty] = await Promise.all([
-    browser.execute(function checkVisibility(elem, params) {
+    browser2.execute(function checkVisibility(elem, params) {
       return elem.checkVisibility(params);
     }, this, commandParams).catch((err) => {
       if (err.message.includes("checkVisibility is not a function")) {
         hadToFallback = true;
-        return browser.execute(isElementDisplayed, this);
+        return browser2.execute(isElementDisplayed, this);
       }
       throw err;
     }),
@@ -6924,9 +6941,9 @@ async function isDisplayed(commandParams = DEFAULT_PARAMS) {
   ]);
   const hasDisplayContentsCSSProperty = displayProperty.value === "contents";
   const shouldRecheckContentVisibility = !hadToFallback && hasDisplayContentsCSSProperty;
-  const finalResponse = shouldRecheckContentVisibility ? await browser.execute(isElementDisplayed, this).catch(() => false) : isDisplayed2;
+  const finalResponse = shouldRecheckContentVisibility ? await browser2.execute(isElementDisplayed, this).catch(() => false) : isDisplayed2;
   if (finalResponse && (commandParams == null ? void 0 : commandParams.withinViewport)) {
-    return browser.execute(isElementInViewport, this);
+    return browser2.execute(isElementInViewport, this);
   }
   return finalResponse;
 }
@@ -6952,9 +6969,9 @@ var getWebElement = (el) => ({
   // jsonwp compatible
 });
 async function isEqual(el) {
-  const browser = getBrowserObject22(this);
-  if (browser.isMobile) {
-    const context = await browser.getContext().catch(() => void 0);
+  const browser2 = getBrowserObject22(this);
+  if (browser2.isMobile) {
+    const context = await browser2.getContext().catch(() => void 0);
     const contextId = typeof context === "string" ? context : context == null ? void 0 : context.id;
     if (contextId && contextId.toLowerCase().includes("native")) {
       return this.elementId === el.elementId;
@@ -6962,7 +6979,7 @@ async function isEqual(el) {
   }
   let result;
   try {
-    result = await browser.execute(
+    result = await browser2.execute(
       /* istanbul ignore next */
       function(el1, el2) {
         return el1 === el2;
@@ -6999,8 +7016,8 @@ function isFocused(elem) {
 
 // src/commands/element/isFocused.ts
 async function isFocused2() {
-  const browser = await getBrowserObject23(this);
-  return browser.execute(isFocused, {
+  const browser2 = await getBrowserObject23(this);
+  return browser2.execute(isFocused, {
     [ELEMENT_KEY15]: this.elementId,
     // w3c compatible
     ELEMENT: this.elementId
@@ -7042,8 +7059,8 @@ function isElementStable(elem, done) {
 
 // src/commands/element/isStable.ts
 async function isStable() {
-  const browser = getBrowserObject24(this);
-  return await browser.executeAsync(isElementStable, {
+  const browser2 = getBrowserObject24(this);
+  return await browser2.executeAsync(isElementStable, {
     [ELEMENT_KEY16]: this.elementId,
     // w3c compatible
     ELEMENT: this.elementId
@@ -7056,9 +7073,9 @@ import logger22 from "@wdio/logger";
 import { getBrowserObject as getBrowserObject25 } from "@wdio/utils";
 var log22 = logger22("webdriver");
 async function moveTo({ xOffset, yOffset } = {}) {
-  const browser = getBrowserObject25(this);
+  const browser2 = getBrowserObject25(this);
   if (xOffset || yOffset) {
-    const { width, height } = await browser.getElementRect(this.elementId);
+    const { width, height } = await browser2.getElementRect(this.elementId);
     if (xOffset && xOffset < -Math.floor(width / 2) || xOffset && xOffset > Math.floor(width / 2)) {
       log22.warn("xOffset would cause a out of bounds error as it goes outside of element");
     }
@@ -7067,7 +7084,7 @@ async function moveTo({ xOffset, yOffset } = {}) {
     }
   }
   const moveToNested = async () => {
-    await browser.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: this, x: xOffset || 0, y: yOffset || 0 }).perform();
+    await browser2.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: this, x: xOffset || 0, y: yOffset || 0 }).perform();
   };
   try {
     await moveToNested();
@@ -7110,10 +7127,10 @@ function previousElement() {
 // src/commands/element/react$$.ts
 import { getBrowserObject as getBrowserObject26 } from "@wdio/utils";
 async function react$$4(selector, { props = {}, state = {} } = {}) {
-  const browser = await getBrowserObject26(this);
+  const browser2 = await getBrowserObject26(this);
   await this.executeScript(resqScript.toString(), []);
-  await browser.execute(waitToLoadReact);
-  const res = await browser.execute(
+  await browser2.execute(waitToLoadReact);
+  const res = await browser2.execute(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     react$$,
     selector,
@@ -7128,10 +7145,10 @@ async function react$$4(selector, { props = {}, state = {} } = {}) {
 // src/commands/element/react$.ts
 import { getBrowserObject as getBrowserObject27 } from "@wdio/utils";
 async function react$4(selector, { props = {}, state = {} } = {}) {
-  const browser = await getBrowserObject27(this);
+  const browser2 = await getBrowserObject27(this);
   await this.executeScript(resqScript.toString(), []);
-  await browser.execute(waitToLoadReact);
-  const res = await browser.execute(
+  await browser2.execute(waitToLoadReact);
+  const res = await browser2.execute(
     react$,
     selector,
     props,
@@ -7152,11 +7169,11 @@ import { ELEMENT_KEY as ELEMENT_KEY17 } from "webdriver";
 import { getBrowserObject as getBrowserObject28 } from "@wdio/utils";
 var log23 = logger23("webdriverio");
 async function scrollIntoView(options = { block: "start", inline: "nearest" }) {
-  const browser = getBrowserObject28(this);
-  if (browser.isMobile) {
-    if (await browser.isNativeContext) {
+  const browser2 = getBrowserObject28(this);
+  if (browser2.isMobile) {
+    if (await browser2.isNativeContext) {
       return nativeMobileScrollIntoView({
-        browser,
+        browser: browser2,
         element: this,
         options: options || {}
       });
@@ -7164,9 +7181,9 @@ async function scrollIntoView(options = { block: "start", inline: "nearest" }) {
     return scrollIntoViewWeb.call(this, options);
   }
   try {
-    const elemRect = await browser.getElementRect(this.elementId);
-    const viewport = await browser.getWindowSize();
-    let [scrollX2, scrollY2] = await browser.execute(() => [
+    const elemRect = await browser2.getElementRect(this.elementId);
+    const viewport = await browser2.getWindowSize();
+    let [scrollX2, scrollY2] = await browser2.execute(() => [
       window.scrollX,
       window.scrollY
     ]);
@@ -7201,7 +7218,7 @@ async function scrollIntoView(options = { block: "start", inline: "nearest" }) {
     }
     deltaX = Math.round(deltaX - scrollX2);
     deltaY = Math.round(deltaY - scrollY2);
-    await browser.action("wheel").scroll({ duration: 0, x: deltaX, y: deltaY, origin: this }).perform();
+    await browser2.action("wheel").scroll({ duration: 0, x: deltaX, y: deltaY, origin: this }).perform();
   } catch (err) {
     log23.warn(
       'Failed to execute "scrollIntoView" using WebDriver Actions API: '.concat(err.message, "!\n") + "Re-attempting using `Element.scrollIntoView` via Web API."
@@ -7210,7 +7227,7 @@ async function scrollIntoView(options = { block: "start", inline: "nearest" }) {
   }
 }
 async function mobileScrollUntilVisible({
-  browser,
+  browser: browser2,
   direction,
   duration,
   element,
@@ -7230,7 +7247,7 @@ async function mobileScrollUntilVisible({
     if (isVisible) {
       break;
     }
-    await browser.swipe({
+    await browser2.swipe({
       direction,
       ...duration ? { duration } : {},
       ...percent ? { percent } : {},
@@ -7242,7 +7259,7 @@ async function mobileScrollUntilVisible({
   return { hasScrolled, isVisible };
 }
 async function nativeMobileScrollIntoView({
-  browser,
+  browser: browser2,
   element,
   options
 }) {
@@ -7255,7 +7272,7 @@ async function nativeMobileScrollIntoView({
     ...options || {}
   };
   const { hasScrolled, isVisible } = await mobileScrollUntilVisible({
-    browser,
+    browser: browser2,
     element,
     maxScrolls: mobileOptions.maxScrolls,
     direction: mobileOptions.direction,
@@ -7264,15 +7281,15 @@ async function nativeMobileScrollIntoView({
     ...(mobileOptions == null ? void 0 : mobileOptions.scrollableElement) ? { scrollableElement: mobileOptions.scrollableElement } : {}
   });
   if (hasScrolled && isVisible) {
-    return browser.pause(1e3);
+    return browser2.pause(1e3);
   } else if (isVisible) {
     return;
   }
   throw new Error("Element not found within scroll limit of ".concat(mobileOptions.maxScrolls, ' scrolls by scrolling "').concat(mobileOptions.direction, '". ') + "Are you sure the element is within the scrollable element or the direction is correct? You can change the scrollable element or direction like this:\n\nawait elem.scrollIntoView({\n    direction: 'left' // possible options are: 'up|down|left|right'\n    scrollableElement: $('#scrollable'),\n});\n\n        ");
 }
 function scrollIntoViewWeb(options = { block: "start", inline: "nearest" }) {
-  const browser = getBrowserObject28(this);
-  return browser.execute(
+  const browser2 = getBrowserObject28(this);
+  return browser2.execute(
     (elem, options2) => elem.scrollIntoView(options2),
     {
       [ELEMENT_KEY17]: this.elementId,
@@ -7679,11 +7696,11 @@ var createRoleBaseXpathSelector = (role) => {
 // src/commands/element/shadow$$.ts
 var log24 = logger24("webdriverio");
 async function shadow$$(selector) {
-  const browser = getBrowserObject29(this);
+  const browser2 = getBrowserObject29(this);
   try {
-    const shadowRoot = await browser.getElementShadowRoot(this.elementId);
+    const shadowRoot = await browser2.getElementShadowRoot(this.elementId);
     const { using, value } = findStrategy(selector, this.isW3C, this.isMobile);
-    const res = await browser.findElementsFromShadowRoot(shadowRoot[SHADOW_ELEMENT_KEY], using, value);
+    const res = await browser2.findElementsFromShadowRoot(shadowRoot[SHADOW_ELEMENT_KEY], using, value);
     const elements = await getElements.call(this, selector, res, { isShadowElement: true });
     return enhanceElementsArray(elements, this, selector);
   } catch (err) {
@@ -7700,11 +7717,11 @@ import { SHADOW_ELEMENT_KEY as SHADOW_ELEMENT_KEY2 } from "webdriver";
 import { getBrowserObject as getBrowserObject30 } from "@wdio/utils";
 var log25 = logger25("webdriverio");
 async function shadow$(selector) {
-  const browser = getBrowserObject30(this);
+  const browser2 = getBrowserObject30(this);
   try {
-    const shadowRoot = await browser.getElementShadowRoot(this.elementId);
+    const shadowRoot = await browser2.getElementShadowRoot(this.elementId);
     const { using, value } = findStrategy(selector, this.isW3C, this.isMobile);
-    const res = await browser.findElementFromShadowRoot(shadowRoot[SHADOW_ELEMENT_KEY2], using, value);
+    const res = await browser2.findElementFromShadowRoot(shadowRoot[SHADOW_ELEMENT_KEY2], using, value);
     return getElement.call(this, selector, res, { isShadowElement: true });
   } catch (err) {
     log25.warn(
@@ -7811,8 +7828,8 @@ var waitUntil2 = waitUntil;
 // src/commands/mobile/longPress.ts
 import { getBrowserObject as getBrowserObject31 } from "@wdio/utils";
 function longPress(options) {
-  const browser = getBrowserObject31(this);
-  if (!browser.isMobile) {
+  const browser2 = getBrowserObject31(this);
+  if (!browser2.isMobile) {
     throw new Error("The longPress command is only available for mobile platforms.");
   }
   if (typeof options !== "undefined" && (typeof options !== "object" || Array.isArray(options))) {
@@ -7830,12 +7847,12 @@ function longPress(options) {
 // src/commands/mobile/pinch.ts
 import { getBrowserObject as getBrowserObject32 } from "@wdio/utils";
 async function pinch(options = {}) {
-  const browser = getBrowserObject32(this);
-  if (!browser.isMobile) {
+  const browser2 = getBrowserObject32(this);
+  if (!browser2.isMobile) {
     throw new Error("The pinch command is only available for mobile platforms.");
   }
-  const { duration, scale } = validatePinchAndZoomOptions({ browser, gesture: "pinch", options });
-  const gestureConfig = browser.isIOS ? {
+  const { duration, scale } = validatePinchAndZoomOptions({ browser: browser2, gesture: "pinch", options });
+  const gestureConfig = browser2.isIOS ? {
     elementId: await this.elementId,
     scale,
     velocity: -Math.abs(duration)
@@ -7843,29 +7860,29 @@ async function pinch(options = {}) {
   } : {
     elementId: await this.elementId,
     percent: scale,
-    speed: calculateAndroidPinchAndZoomSpeed({ browser, duration, scale })
+    speed: calculateAndroidPinchAndZoomSpeed({ browser: browser2, duration, scale })
   };
-  return browser.execute(browser.isIOS ? "mobile: pinch" : "mobile: pinchCloseGesture", gestureConfig);
+  return browser2.execute(browser2.isIOS ? "mobile: pinch" : "mobile: pinchCloseGesture", gestureConfig);
 }
 
 // src/commands/mobile/zoom.ts
 import { getBrowserObject as getBrowserObject33 } from "@wdio/utils";
 async function zoom(options = {}) {
-  const browser = getBrowserObject33(this);
-  if (!browser.isMobile) {
+  const browser2 = getBrowserObject33(this);
+  if (!browser2.isMobile) {
     throw new Error("The zoom command is only available for mobile platforms.");
   }
-  const { duration, scale } = validatePinchAndZoomOptions({ browser, gesture: "zoom", options });
-  const gestureConfig = browser.isIOS ? {
+  const { duration, scale } = validatePinchAndZoomOptions({ browser: browser2, gesture: "zoom", options });
+  const gestureConfig = browser2.isIOS ? {
     elementId: await this.elementId,
     scale,
     velocity: duration
   } : {
     elementId: await this.elementId,
     percent: scale,
-    speed: calculateAndroidPinchAndZoomSpeed({ browser, duration, scale })
+    speed: calculateAndroidPinchAndZoomSpeed({ browser: browser2, duration, scale })
   };
-  return browser.execute(browser.isIOS ? "mobile: pinch" : "mobile: pinchOpenGesture", gestureConfig);
+  return browser2.execute(browser2.isIOS ? "mobile: pinch" : "mobile: pinchOpenGesture", gestureConfig);
 }
 
 // src/scripts/elementContains.ts
@@ -8221,9 +8238,9 @@ function transformClassicToBidiSelector(using, value) {
   throw new Error("Can't transform classic selector ".concat(using, " to Bidi selector"));
 }
 async function findDeepElement(selector) {
-  const browser = getBrowserObject34(this);
-  const shadowRootManager = getShadowRootManager(browser);
-  const contextManager = getContextManager(browser);
+  const browser2 = getBrowserObject34(this);
+  const shadowRootManager = getShadowRootManager(browser2);
+  const contextManager = getContextManager(browser2);
   const context = await contextManager.getCurrentContext();
   const shadowRoots = shadowRootManager.getShadowElementsByContextId(
     context,
@@ -8232,7 +8249,7 @@ async function findDeepElement(selector) {
   const { using, value } = findStrategy(selector, this.isW3C, this.isMobile);
   const locator = transformClassicToBidiSelector(using, value);
   const startNodes = shadowRoots.length > 0 ? shadowRoots.map((shadowRootNodeId) => ({ sharedId: shadowRootNodeId })) : this.elementId ? [{ sharedId: this.elementId }] : void 0;
-  const deepElementResult = await browser.browsingContextLocateNodes({ locator, context, startNodes }).then(async (result) => {
+  const deepElementResult = await browser2.browsingContextLocateNodes({ locator, context, startNodes }).then(async (result) => {
     const nodes = result.nodes.filter((node) => Boolean(node.sharedId)).map((node) => ({
       [ELEMENT_KEY18]: node.sharedId,
       locator
@@ -8241,7 +8258,7 @@ async function findDeepElement(selector) {
       return nodes[0];
     }
     const scopedNodes = await Promise.all(nodes.map(async (node) => {
-      const isIn = await browser.execute(
+      const isIn = await browser2.execute(
         elementContains,
         { [ELEMENT_KEY18]: this.elementId },
         node
@@ -8251,7 +8268,7 @@ async function findDeepElement(selector) {
     return scopedNodes[0];
   }, (err) => {
     log26.warn("Failed to execute browser.browsingContextLocateNodes({ ... }) due to ".concat(err, ", falling back to regular WebDriver Classic command"));
-    return this && "elementId" in this && this.elementId ? this.findElementFromElement(this.elementId, using, value) : browser.findElement(using, value);
+    return this && "elementId" in this && this.elementId ? this.findElementFromElement(this.elementId, using, value) : browser2.findElement(using, value);
   });
   if (!deepElementResult) {
     return new Error("Couldn't find element with selector \"".concat(selector, '"'));
@@ -8259,9 +8276,9 @@ async function findDeepElement(selector) {
   return deepElementResult;
 }
 async function findDeepElements(selector) {
-  const browser = getBrowserObject34(this);
-  const shadowRootManager = getShadowRootManager(browser);
-  const contextManager = getContextManager(browser);
+  const browser2 = getBrowserObject34(this);
+  const shadowRootManager = getShadowRootManager(browser2);
+  const contextManager = getContextManager(browser2);
   const context = await contextManager.getCurrentContext();
   const shadowRoots = shadowRootManager.getShadowElementsByContextId(
     context,
@@ -8270,7 +8287,7 @@ async function findDeepElements(selector) {
   const { using, value } = findStrategy(selector, this.isW3C, this.isMobile);
   const locator = transformClassicToBidiSelector(using, value);
   const startNodes = shadowRoots.length > 0 ? shadowRoots.map((shadowRootNodeId) => ({ sharedId: shadowRootNodeId })) : this.elementId ? [{ sharedId: this.elementId }] : void 0;
-  const deepElementResult = await browser.browsingContextLocateNodes({ locator, context, startNodes }).then(async (result) => {
+  const deepElementResult = await browser2.browsingContextLocateNodes({ locator, context, startNodes }).then(async (result) => {
     const nodes = result.nodes.filter((node) => Boolean(node.sharedId)).map((node) => ({
       [ELEMENT_KEY18]: node.sharedId,
       locator
@@ -8279,7 +8296,7 @@ async function findDeepElements(selector) {
       return nodes;
     }
     const scopedNodes = await Promise.all(nodes.map(async (node) => {
-      const isIn = await browser.execute(
+      const isIn = await browser2.execute(
         elementContains,
         { [ELEMENT_KEY18]: this.elementId },
         node
@@ -8289,7 +8306,7 @@ async function findDeepElements(selector) {
     return scopedNodes;
   }, (err) => {
     log26.warn("Failed to execute browser.browsingContextLocateNodes({ ... }) due to ".concat(err, ", falling back to regular WebDriver Classic command"));
-    return this && "elementId" in this && this.elementId ? this.findElementsFromElement(this.elementId, using, value) : browser.findElements(using, value);
+    return this && "elementId" in this && this.elementId ? this.findElementsFromElement(this.elementId, using, value) : browser2.findElements(using, value);
   });
   return deepElementResult;
 }
@@ -8791,7 +8808,7 @@ var NOOP2 = () => {
 var ProtocolStub = class {
   static async newSession(options) {
     const capabilities = emulateSessionCapabilities(options.capabilities);
-    const browser = {
+    const browser2 = {
       options,
       capabilities,
       requestedCapabilities: capabilities,
@@ -8807,9 +8824,9 @@ var ProtocolStub = class {
       overwriteCommand: NOOP2,
       ...capabilitiesEnvironmentDetector(capabilities)
     };
-    browser.addCommand = (...args) => browser.customCommands.push(args);
-    browser.overwriteCommand = (...args) => browser.overwrittenCommands.push(args);
-    return browser;
+    browser2.addCommand = (...args) => browser2.customCommands.push(args);
+    browser2.overwriteCommand = (...args) => browser2.overwrittenCommands.push(args);
+    return browser2;
   }
   /**
    * added just in case user wants to somehow reload webdriver before it was started.