automation_model 1.0.558-dev → 1.0.560-dev

package/lib/stable_browser.js

@@ -10,7 +10,7 @@ import { getDateTimeValue } from "./date_time.js";
 import drawRectangle from "./drawRect.js";
 //import { closeUnexpectedPopups } from "./popups.js";
 import { getTableCells, getTableData } from "./table_analyze.js";
-import { maskValue, replaceWithLocalTestData } from "./utils.js";
+import { _copyContext, _fixLocatorUsingParams, _fixUsingParams, _getServerUrl, KEYBOARD_EVENTS, maskValue, replaceWithLocalTestData, scrollPageToLoadLazyElements, unEscapeString, } from "./utils.js";
 import csv from "csv-parser";
 import { Readable } from "node:stream";
 import readline from "readline";
@@ -31,6 +31,8 @@ export const Types = {
     GET_PAGE_STATUS: "get_page_status",
     CLICK_ROW_ACTION: "click_row_action",
     VERIFY_ELEMENT_CONTAINS_TEXT: "verify_element_contains_text",
+    VERIFY_PAGE_CONTAINS_TEXT: "verify_page_contains_text",
+    VERIFY_PAGE_CONTAINS_NO_TEXT: "verify_page_contains_no_text",
     ANALYZE_TABLE: "analyze_table",
     SELECT: "select_combobox",
     VERIFY_PAGE_PATH: "verify_page_path",
@@ -48,6 +50,7 @@ export const Types = {
     SET_INPUT: "set_input",
     WAIT_FOR_TEXT_TO_DISAPPEAR: "wait_for_text_to_disappear",
     VERIFY_ATTRIBUTE: "verify_element_attribute",
+    VERIFY_TEXT_WITH_RELATION: "verify_text_with_relation",
 };
 export const apps = {};
 class StableBrowser {
@@ -101,24 +104,6 @@ class StableBrowser {
         registerNetworkEvents(this.world, this, this.context, this.page);
         registerDownloadEvent(this.page, this.world, this.context);
     }
-    async scrollPageToLoadLazyElements() {
-        let lastHeight = await this.page.evaluate(() => document.body.scrollHeight);
-        let retry = 0;
-        while (true) {
-            await this.page.evaluate(() => window.scrollBy(0, window.innerHeight));
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-            let newHeight = await this.page.evaluate(() => document.body.scrollHeight);
-            if (newHeight === lastHeight) {
-                break;
-            }
-            lastHeight = newHeight;
-            retry++;
-            if (retry > 10) {
-                break;
-            }
-        }
-        await this.page.evaluate(() => window.scrollTo(0, 0));
-    }
     registerEventListeners(context) {
         this.registerConsoleLogListener(this.page, context);
         // this.registerRequestListener(this.page, context, this.webLogFile);
@@ -177,8 +162,8 @@ class StableBrowser {
             };
         }
         const tempContext = {};
-        this._copyContext(this, tempContext);
-        this._copyContext(apps[appName], this);
+        _copyContext(this, tempContext);
+        _copyContext(apps[appName], this);
         apps[this.appName] = tempContext;
         this.appName = appName;
         if (newContextCreated) {
@@ -187,22 +172,6 @@ class StableBrowser {
             await this.waitForPageLoad();
         }
     }
-    _copyContext(from, to) {
-        to.browser = from.browser;
-        to.page = from.page;
-        to.context = from.context;
-    }
-    getWebLogFile(logFolder) {
-        if (!fs.existsSync(logFolder)) {
-            fs.mkdirSync(logFolder, { recursive: true });
-        }
-        let nextIndex = 1;
-        while (fs.existsSync(path.join(logFolder, nextIndex.toString() + ".json"))) {
-            nextIndex++;
-        }
-        const fileName = nextIndex + ".json";
-        return path.join(logFolder, fileName);
-    }
     registerConsoleLogListener(page, context) {
         if (!this.context.webLogger) {
             this.context.webLogger = [];
@@ -274,47 +243,8 @@ class StableBrowser {
             timeout: 60000,
         });
     }
-    _fixUsingParams(text, _params) {
-        if (!_params || typeof text !== "string") {
-            return text;
-        }
-        for (let key in _params) {
-            let regValue = key;
-            if (key.startsWith("_")) {
-                // remove the _ prefix
-                regValue = key.substring(1);
-            }
-            text = text.replaceAll(new RegExp("{" + regValue + "}", "g"), _params[key]);
-        }
-        return text;
-    }
-    _fixLocatorUsingParams(locator, _params) {
-        // check if not null
-        if (!locator) {
-            return locator;
-        }
-        // clone the locator
-        locator = JSON.parse(JSON.stringify(locator));
-        this.scanAndManipulate(locator, _params);
-        return locator;
-    }
-    _isObject(value) {
-        return value && typeof value === "object" && value.constructor === Object;
-    }
-    scanAndManipulate(currentObj, _params) {
-        for (const key in currentObj) {
-            if (typeof currentObj[key] === "string") {
-                // Perform string manipulation
-                currentObj[key] = this._fixUsingParams(currentObj[key], _params);
-            }
-            else if (this._isObject(currentObj[key])) {
-                // Recursively scan nested objects
-                this.scanAndManipulate(currentObj[key], _params);
-            }
-        }
-    }
     _getLocator(locator, scope, _params) {
-        locator = this._fixLocatorUsingParams(locator, _params);
+        locator = _fixLocatorUsingParams(locator, _params);
         let locatorReturn;
         if (locator.role) {
             if (locator.role[1].nameReg) {
@@ -322,7 +252,7 @@ class StableBrowser {
                 delete locator.role[1].nameReg;
             }
             // if (locator.role[1].name) {
-            //   locator.role[1].name = this._fixUsingParams(locator.role[1].name, _params);
+            //   locator.role[1].name = _fixUsingParams(locator.role[1].name, _params);
             // }
             locatorReturn = scope.getByRole(locator.role[0], locator.role[1]);
         }
@@ -365,7 +295,7 @@ class StableBrowser {
         if (css && css.locator) {
             css = css.locator;
         }
-        let result = await this._locateElementByText(scope, this._fixUsingParams(text, _params), "*:not(script, style, head)", false, false, _params);
+        let result = await this._locateElementByText(scope, _fixUsingParams(text, _params), "*:not(script, style, head)", false, false, _params);
         if (result.elementCount === 0) {
             return;
         }
@@ -381,116 +311,28 @@ class StableBrowser {
     async _locateElementByText(scope, text1, tag1, regex1 = false, partial1, _params) {
         //const stringifyText = JSON.stringify(text);
         return await scope.locator(":root").evaluate((_node, [text, tag, regex, partial]) => {
-            function isParent(parent, child) {
-                let currentNode = child.parentNode;
-                while (currentNode !== null) {
-                    if (currentNode === parent) {
-                        return true;
-                    }
-                    currentNode = currentNode.parentNode;
-                }
-                return false;
-            }
-            document.isParent = isParent;
-            function getRegex(str) {
-                const match = str.match(/^\/(.*?)\/([gimuy]*)$/);
-                if (!match) {
-                    return null;
-                }
-                let [_, pattern, flags] = match;
-                return new RegExp(pattern, flags);
-            }
-            document.getRegex = getRegex;
-            function collectAllShadowDomElements(element, result = []) {
-                // Check and add the element if it has a shadow root
-                if (element.shadowRoot) {
-                    result.push(element);
-                    // Also search within the shadow root
-                    document.collectAllShadowDomElements(element.shadowRoot, result);
-                }
-                // Iterate over child nodes
-                element.childNodes.forEach((child) => {
-                    // Recursively call the function for each child node
-                    document.collectAllShadowDomElements(child, result);
-                });
-                return result;
-            }
-            document.collectAllShadowDomElements = collectAllShadowDomElements;
-            if (!tag) {
-                tag = "*:not(script, style, head)";
-            }
-            let regexpSearch = document.getRegex(text);
-            if (regexpSearch) {
-                regex = true;
-            }
-            let elements = Array.from(document.querySelectorAll(tag));
-            let shadowHosts = [];
-            document.collectAllShadowDomElements(document, shadowHosts);
-            for (let i = 0; i < shadowHosts.length; i++) {
-                let shadowElement = shadowHosts[i].shadowRoot;
-                if (!shadowElement) {
-                    console.log("shadowElement is null, for host " + shadowHosts[i]);
-                    continue;
-                }
-                let shadowElements = Array.from(shadowElement.querySelectorAll(tag));
-                elements = elements.concat(shadowElements);
-            }
-            let randomToken = null;
-            const foundElements = [];
+            const options = {
+                innerText: true,
+            };
             if (regex) {
-                if (!regexpSearch) {
-                    regexpSearch = new RegExp(text, "im");
-                }
-                for (let i = 0; i < elements.length; i++) {
-                    const element = elements[i];
-                    if ((element.innerText && regexpSearch.test(element.innerText)) ||
-                        (element.value && regexpSearch.test(element.value))) {
-                        foundElements.push(element);
-                    }
-                }
+                options.singleRegex = true;
             }
-            else {
-                text = text.trim();
-                for (let i = 0; i < elements.length; i++) {
-                    const element = elements[i];
-                    if (partial) {
-                        if ((element.innerText && element.innerText.toLowerCase().trim().includes(text.toLowerCase())) ||
-                            (element.value && element.value.toLowerCase().includes(text.toLowerCase()))) {
-                            foundElements.push(element);
-                        }
-                    }
-                    else {
-                        if ((element.innerText && element.innerText.trim() === text) ||
-                            (element.value && element.value === text)) {
-                            foundElements.push(element);
-                        }
-                    }
-                }
+            if (tag) {
+                options.tag = tag;
             }
-            let noChildElements = [];
-            for (let i = 0; i < foundElements.length; i++) {
-                let element = foundElements[i];
-                let hasChild = false;
-                for (let j = 0; j < foundElements.length; j++) {
-                    if (i === j) {
-                        continue;
-                    }
-                    if (isParent(element, foundElements[j])) {
-                        hasChild = true;
-                        break;
-                    }
-                }
-                if (!hasChild) {
-                    noChildElements.push(element);
-                }
+            if (!(partial === true)) {
+                options.exactMatch = true;
             }
+            const elements = window.findMatchingElements(text, options);
+            let randomToken = null;
+            const foundElements = [];
             let elementCount = 0;
-            if (noChildElements.length > 0) {
-                for (let i = 0; i < noChildElements.length; i++) {
+            if (elements.length > 0) {
+                for (let i = 0; i < elements.length; i++) {
                     if (randomToken === null) {
                         randomToken = Math.random().toString(36).substring(7);
                     }
-                    let element = noChildElements[i];
+                    let element = elements[i];
                     element.setAttribute("data-blinq-id", "blinq-id-" + randomToken);
                     elementCount++;
                 }
@@ -512,7 +354,7 @@ class StableBrowser {
         let locatorSearch = selectorHierarchy[index];
         let originalLocatorSearch = "";
         try {
-            originalLocatorSearch = this._fixUsingParams(JSON.stringify(locatorSearch), _params);
+            originalLocatorSearch = _fixUsingParams(JSON.stringify(locatorSearch), _params);
             locatorSearch = JSON.parse(originalLocatorSearch);
         }
         catch (e) {
@@ -530,7 +372,7 @@ class StableBrowser {
             locator = this._getLocator({ css: locatorString }, scope, _params);
         }
         else if (locatorSearch.text) {
-            let text = this._fixUsingParams(locatorSearch.text, _params);
+            let text = _fixUsingParams(locatorSearch.text, _params);
             let result = await this._locateElementByText(scope, text, locatorSearch.tag, false, locatorSearch.partial === true, _params);
             if (result.elementCount === 0) {
                 info.failCause.textNotFound = true;
@@ -874,7 +716,7 @@ class StableBrowser {
                 highPriorityOnly = false;
                 if (this.configuration && this.configuration.load_all_lazy === true && !lazy_scroll) {
                     lazy_scroll = true;
-                    await this.scrollPageToLoadLazyElements();
+                    await scrollPageToLoadLazyElements(this.page);
                 }
             }
             if (Date.now() - startTime > visibleOnlyTimeout) {
@@ -2031,7 +1873,7 @@ class StableBrowser {
         if (options && options.timeout) {
             timeout = options.timeout;
         }
-        const serviceUrl = this._getServerUrl() + "/api/mail/createLinkOrCodeFromEmail";
+        const serviceUrl = _getServerUrl() + "/api/mail/createLinkOrCodeFromEmail";
         const request = {
             method: "POST",
             url: serviceUrl,
@@ -2224,6 +2066,34 @@ class StableBrowser {
             });
         }
     }
+    async findTextInAllFrames(dateAlternatives, numberAlternatives, text, state) {
+        const frames = this.page.frames();
+        let results = [];
+        for (let i = 0; i < frames.length; i++) {
+            if (dateAlternatives.date) {
+                for (let j = 0; j < dateAlternatives.dates.length; j++) {
+                    const result = await this._locateElementByText(frames[i], dateAlternatives.dates[j], "*:not(script, style, head)", false, true, {});
+                    result.frame = frames[i];
+                    results.push(result);
+                }
+            }
+            else if (numberAlternatives.number) {
+                for (let j = 0; j < numberAlternatives.numbers.length; j++) {
+                    const result = await this._locateElementByText(frames[i], numberAlternatives.numbers[j], "*:not(script, style, head)", false, true, {});
+                    result.frame = frames[i];
+                    results.push(result);
+                }
+            }
+            else {
+                const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", false, true, {});
+                result.frame = frames[i];
+                results.push(result);
+            }
+        }
+        state.info.results = results;
+        const resultWithElementsFound = results.filter((result) => result.elementCount > 0);
+        return resultWithElementsFound;
+    }
     async verifyTextExistInPage(text, options = {}, world = null) {
         text = unEscapeString(text);
         const state = {
@@ -2233,7 +2103,7 @@ class StableBrowser {
             locate: false,
             scroll: false,
             highlight: false,
-            type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
+            type: Types.VERIFY_PAGE_CONTAINS_TEXT,
             text: `Verify text exists in page`,
             operation: "verifyTextExistInPage",
             log: "***** verify text " + text + " exists in page *****\n",
@@ -2251,31 +2121,7 @@ class StableBrowser {
             await _preCommand(state, this);
             state.info.text = text;
             while (true) {
-                const frames = this.page.frames();
-                let results = [];
-                for (let i = 0; i < frames.length; i++) {
-                    if (dateAlternatives.date) {
-                        for (let j = 0; j < dateAlternatives.dates.length; j++) {
-                            const result = await this._locateElementByText(frames[i], dateAlternatives.dates[j], "*:not(script, style, head)", true, true, {});
-                            result.frame = frames[i];
-                            results.push(result);
-                        }
-                    }
-                    else if (numberAlternatives.number) {
-                        for (let j = 0; j < numberAlternatives.numbers.length; j++) {
-                            const result = await this._locateElementByText(frames[i], numberAlternatives.numbers[j], "*:not(script, style, head)", true, true, {});
-                            result.frame = frames[i];
-                            results.push(result);
-                        }
-                    }
-                    else {
-                        const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", true, true, {});
-                        result.frame = frames[i];
-                        results.push(result);
-                    }
-                }
-                state.info.results = results;
-                const resultWithElementsFound = results.filter((result) => result.elementCount > 0);
+                const resultWithElementsFound = await this.findTextInAllFrames(dateAlternatives, numberAlternatives, text, state);
                 if (resultWithElementsFound.length === 0) {
                     if (Date.now() - state.startTime > timeout) {
                         throw new Error(`Text ${text} not found in page`);
@@ -2332,31 +2178,7 @@ class StableBrowser {
             await _preCommand(state, this);
             state.info.text = text;
             while (true) {
-                const frames = this.page.frames();
-                let results = [];
-                for (let i = 0; i < frames.length; i++) {
-                    if (dateAlternatives.date) {
-                        for (let j = 0; j < dateAlternatives.dates.length; j++) {
-                            const result = await this._locateElementByText(frames[i], dateAlternatives.dates[j], "*:not(script, style, head)", true, true, {});
-                            result.frame = frames[i];
-                            results.push(result);
-                        }
-                    }
-                    else if (numberAlternatives.number) {
-                        for (let j = 0; j < numberAlternatives.numbers.length; j++) {
-                            const result = await this._locateElementByText(frames[i], numberAlternatives.numbers[j], "*:not(script, style, head)", true, true, {});
-                            result.frame = frames[i];
-                            results.push(result);
-                        }
-                    }
-                    else {
-                        const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", true, true, {});
-                        result.frame = frames[i];
-                        results.push(result);
-                    }
-                }
-                state.info.results = results;
-                const resultWithElementsFound = results.filter((result) => result.elementCount > 0);
+                const resultWithElementsFound = await this.findTextInAllFrames(dateAlternatives, numberAlternatives, text, state);
                 if (resultWithElementsFound.length === 0) {
                     await _screenshot(state, this);
                     return state.info;
@@ -2374,15 +2196,102 @@ class StableBrowser {
             _commandFinally(state, this);
         }
     }
-    _getServerUrl() {
-        let serviceUrl = "https://api.blinq.io";
-        if (process.env.NODE_ENV_BLINQ === "dev") {
-            serviceUrl = "https://dev.api.blinq.io";
+    async verifyTextRelatedToText(textAnchor, climb, textToVerify, options = {}, world = null) {
+        textAnchor = unEscapeString(textAnchor);
+        textToVerify = unEscapeString(textToVerify);
+        const state = {
+            text_search: textToVerify,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            highlight: false,
+            type: Types.VERIFY_TEXT_WITH_RELATION,
+            text: `Verify text with relation to another text`,
+            operation: "verify_text_with_relation",
+            log: "***** search for " + textAnchor + " climb " + climb + " and verify " + textToVerify + " found *****\n",
+        };
+        const timeout = this._getLoadTimeout(options);
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        let newValue = await this._replaceWithLocalData(textAnchor, world);
+        if (newValue !== textAnchor) {
+            this.logger.info(textAnchor + "=" + newValue);
+            textAnchor = newValue;
+        }
+        newValue = await this._replaceWithLocalData(textToVerify, world);
+        if (newValue !== textToVerify) {
+            this.logger.info(textToVerify + "=" + newValue);
+            textToVerify = newValue;
+        }
+        let dateAlternatives = findDateAlternatives(textToVerify);
+        let numberAlternatives = findNumberAlternatives(textToVerify);
+        let foundAncore = false;
+        try {
+            await _preCommand(state, this);
+            state.info.text = textToVerify;
+            while (true) {
+                const resultWithElementsFound = await this.findTextInAllFrames(dateAlternatives, numberAlternatives, textAnchor, state);
+                if (resultWithElementsFound.length === 0) {
+                    if (Date.now() - state.startTime > timeout) {
+                        throw new Error(`Text ${foundAncore ? textToVerify : textAnchor} not found in page`);
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    continue;
+                }
+                for (let i = 0; i < resultWithElementsFound.length; i++) {
+                    foundAncore = true;
+                    const result = resultWithElementsFound[i];
+                    const token = result.randomToken;
+                    const frame = result.frame;
+                    const css = `[data-blinq-id="blinq-id-${token}"]`;
+                    const findResult = await frame.evaluate(([css, climb, textToVerify, token]) => {
+                        const elements = Array.from(document.querySelectorAll(css));
+                        for (let i = 0; i < elements.length; i++) {
+                            const element = elements[i];
+                            let climbParent = element;
+                            for (let j = 0; j < climb; j++) {
+                                climbParent = climbParent.parentElement;
+                                if (!climbParent) {
+                                    break;
+                                }
+                            }
+                            if (!climbParent) {
+                                continue;
+                            }
+                            const foundElements = window.findMatchingElements(textToVerify, {}, climbParent);
+                            if (foundElements.length > 0) {
+                                // set the container element attribute
+                                element.setAttribute("data-blinq-id", `blinq-id-${token}-anchor`);
+                                climbParent.setAttribute("data-blinq-id", `blinq-id-${token}-container`);
+                                foundElements[0].setAttribute("data-blinq-id", `blinq-id-${token}-verify`);
+                                return { found: true };
+                            }
+                        }
+                        return { found: false };
+                    }, [css, climb, textToVerify, result.randomToken]);
+                    if (findResult.found === true) {
+                        const dataAttribute = `[data-blinq-id="blinq-id-${token}-verify"]`;
+                        const cssAnchor = `[data-blinq-id="blinq-id-${token}-anchor"]`;
+                        await this._highlightElements(frame, dataAttribute);
+                        await this._highlightElements(frame, cssAnchor);
+                        const element = await frame.$(dataAttribute);
+                        if (element) {
+                            await this.scrollIfNeeded(element, state.info);
+                            await element.dispatchEvent("bvt_verify_page_contains_text");
+                        }
+                        await _screenshot(state, this);
+                        return state.info;
+                    }
+                }
+            }
+            // await expect(element).toHaveCount(1, { timeout: 10000 });
         }
-        else if (process.env.NODE_ENV_BLINQ === "stage") {
-            serviceUrl = "https://stage.api.blinq.io";
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            _commandFinally(state, this);
         }
-        return serviceUrl;
     }
     async visualVerification(text, options = {}, world = null) {
         const startTime = Date.now();
@@ -2398,7 +2307,7 @@ class StableBrowser {
             throw new Error("TOKEN is not set");
         }
         try {
-            let serviceUrl = this._getServerUrl();
+            let serviceUrl = _getServerUrl();
             ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
             info.screenshotPath = screenshotPath;
             const screenshot = await this.takeScreenshot();
@@ -2563,7 +2472,7 @@ class StableBrowser {
         info.operation = "analyzeTable";
         info.selectors = selectors;
         info.query = query;
-        query = this._fixUsingParams(query, _params);
+        query = _fixUsingParams(query, _params);
         info.query_fixed = query;
         info.operator = operator;
         info.value = value;
@@ -2930,156 +2839,5 @@ function createTimedPromise(promise, label) {
         .then((result) => ({ status: "fulfilled", label, result }))
         .catch((error) => Promise.reject({ status: "rejected", label, error }));
 }
-const KEYBOARD_EVENTS = [
-    "ALT",
-    "AltGraph",
-    "CapsLock",
-    "Control",
-    "Fn",
-    "FnLock",
-    "Hyper",
-    "Meta",
-    "NumLock",
-    "ScrollLock",
-    "Shift",
-    "Super",
-    "Symbol",
-    "SymbolLock",
-    "Enter",
-    "Tab",
-    "ArrowDown",
-    "ArrowLeft",
-    "ArrowRight",
-    "ArrowUp",
-    "End",
-    "Home",
-    "PageDown",
-    "PageUp",
-    "Backspace",
-    "Clear",
-    "Copy",
-    "CrSel",
-    "Cut",
-    "Delete",
-    "EraseEof",
-    "ExSel",
-    "Insert",
-    "Paste",
-    "Redo",
-    "Undo",
-    "Accept",
-    "Again",
-    "Attn",
-    "Cancel",
-    "ContextMenu",
-    "Escape",
-    "Execute",
-    "Find",
-    "Finish",
-    "Help",
-    "Pause",
-    "Play",
-    "Props",
-    "Select",
-    "ZoomIn",
-    "ZoomOut",
-    "BrightnessDown",
-    "BrightnessUp",
-    "Eject",
-    "LogOff",
-    "Power",
-    "PowerOff",
-    "PrintScreen",
-    "Hibernate",
-    "Standby",
-    "WakeUp",
-    "AllCandidates",
-    "Alphanumeric",
-    "CodeInput",
-    "Compose",
-    "Convert",
-    "Dead",
-    "FinalMode",
-    "GroupFirst",
-    "GroupLast",
-    "GroupNext",
-    "GroupPrevious",
-    "ModeChange",
-    "NextCandidate",
-    "NonConvert",
-    "PreviousCandidate",
-    "Process",
-    "SingleCandidate",
-    "HangulMode",
-    "HanjaMode",
-    "JunjaMode",
-    "Eisu",
-    "Hankaku",
-    "Hiragana",
-    "HiraganaKatakana",
-    "KanaMode",
-    "KanjiMode",
-    "Katakana",
-    "Romaji",
-    "Zenkaku",
-    "ZenkakuHanaku",
-    "F1",
-    "F2",
-    "F3",
-    "F4",
-    "F5",
-    "F6",
-    "F7",
-    "F8",
-    "F9",
-    "F10",
-    "F11",
-    "F12",
-    "Soft1",
-    "Soft2",
-    "Soft3",
-    "Soft4",
-    "ChannelDown",
-    "ChannelUp",
-    "Close",
-    "MailForward",
-    "MailReply",
-    "MailSend",
-    "MediaFastForward",
-    "MediaPause",
-    "MediaPlay",
-    "MediaPlayPause",
-    "MediaRecord",
-    "MediaRewind",
-    "MediaStop",
-    "MediaTrackNext",
-    "MediaTrackPrevious",
-    "AudioBalanceLeft",
-    "AudioBalanceRight",
-    "AudioBassBoostDown",
-    "AudioBassBoostToggle",
-    "AudioBassBoostUp",
-    "AudioFaderFront",
-    "AudioFaderRear",
-    "AudioSurroundModeNext",
-    "AudioTrebleDown",
-    "AudioTrebleUp",
-    "AudioVolumeDown",
-    "AudioVolumeMute",
-    "AudioVolumeUp",
-    "MicrophoneToggle",
-    "MicrophoneVolumeDown",
-    "MicrophoneVolumeMute",
-    "MicrophoneVolumeUp",
-    "TV",
-    "TV3DMode",
-    "TVAntennaCable",
-    "TVAudioDescription",
-];
-function unEscapeString(str) {
-    const placeholder = "__NEWLINE__";
-    str = str.replace(new RegExp(placeholder, "g"), "\n");
-    return str;
-}
 export { StableBrowser };
 //# sourceMappingURL=stable_browser.js.map