patchright-core 1.48.2

package/lib/server/chromium/chromium.js

@@ -0,0 +1,350 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Chromium = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _crBrowser = require("./crBrowser");
+var _processLauncher = require("../../utils/processLauncher");
+var _crConnection = require("./crConnection");
+var _browserType = require("../browserType");
+var _transport = require("../transport");
+var _crDevTools = require("./crDevTools");
+var _browser = require("../browser");
+var _network = require("../../utils/network");
+var _userAgent = require("../../utils/userAgent");
+var _ascii = require("../../utils/ascii");
+var _utils = require("../../utils");
+var _fileUtils = require("../../utils/fileUtils");
+var _debugLogger = require("../../utils/debugLogger");
+var _progress = require("../progress");
+var _timeoutSettings = require("../../common/timeoutSettings");
+var _helper = require("../helper");
+var _registry = require("../registry");
+var _manualPromise = require("../../utils/manualPromise");
+var _browserContext = require("../browserContext");
+var _chromiumSwitches = require("./chromiumSwitches");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const ARTIFACTS_FOLDER = _path.default.join(_os.default.tmpdir(), 'playwright-artifacts-');
+class Chromium extends _browserType.BrowserType {
+  constructor(parent) {
+    super(parent, 'chromium');
+    this._devtools = void 0;
+    if ((0, _utils.debugMode)()) this._devtools = this._createDevTools();
+  }
+  async connectOverCDP(metadata, endpointURL, options, timeout) {
+    const controller = new _progress.ProgressController(metadata, this);
+    controller.setLogName('browser');
+    return controller.run(async progress => {
+      return await this._connectOverCDPInternal(progress, endpointURL, options);
+    }, _timeoutSettings.TimeoutSettings.timeout({
+      timeout
+    }));
+  }
+  async _connectOverCDPInternal(progress, endpointURL, options, onClose) {
+    let headersMap;
+    if (options.headers) headersMap = (0, _utils.headersArrayToObject)(options.headers, false);
+    if (!headersMap) headersMap = {
+      'User-Agent': (0, _userAgent.getUserAgent)()
+    };else if (headersMap && !Object.keys(headersMap).some(key => key.toLowerCase() === 'user-agent')) headersMap['User-Agent'] = (0, _userAgent.getUserAgent)();
+    const artifactsDir = await _fs.default.promises.mkdtemp(ARTIFACTS_FOLDER);
+    const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
+    progress.throwIfAborted();
+    const chromeTransport = await _transport.WebSocketTransport.connect(progress, wsEndpoint, headersMap);
+    const cleanedUp = new _manualPromise.ManualPromise();
+    const doCleanup = async () => {
+      await (0, _fileUtils.removeFolders)([artifactsDir]);
+      await (onClose === null || onClose === void 0 ? void 0 : onClose());
+      cleanedUp.resolve();
+    };
+    const doClose = async () => {
+      await chromeTransport.closeAndWait();
+      await cleanedUp;
+    };
+    const browserProcess = {
+      close: doClose,
+      kill: doClose
+    };
+    const persistent = {
+      noDefaultViewport: true
+    };
+    const browserOptions = {
+      slowMo: options.slowMo,
+      name: 'chromium',
+      isChromium: true,
+      persistent,
+      browserProcess,
+      protocolLogger: _helper.helper.debugProtocolLogger(),
+      browserLogsCollector: new _debugLogger.RecentLogsCollector(),
+      artifactsDir,
+      downloadsPath: options.downloadsPath || artifactsDir,
+      tracesDir: options.tracesDir || artifactsDir,
+      originalLaunchOptions: {}
+    };
+    (0, _browserContext.validateBrowserContextOptions)(persistent, browserOptions);
+    progress.throwIfAborted();
+    const browser = await _crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions);
+    browser._isCollocatedWithServer = false;
+    browser.on(_browser.Browser.Events.Disconnected, doCleanup);
+    return browser;
+  }
+  _createDevTools() {
+    // TODO: this is totally wrong when using channels.
+    const directory = _registry.registry.findExecutable('chromium').directory;
+    return directory ? new _crDevTools.CRDevTools(_path.default.join(directory, 'devtools-preferences.json')) : undefined;
+  }
+  async connectToTransport(transport, options) {
+    let devtools = this._devtools;
+    if (options.__testHookForDevTools) {
+      devtools = this._createDevTools();
+      await options.__testHookForDevTools(devtools);
+    }
+    return _crBrowser.CRBrowser.connect(this.attribution.playwright, transport, options, devtools);
+  }
+  doRewriteStartupLog(error) {
+    if (!error.logs) return error;
+    if (error.logs.includes('Missing X server')) error.logs = '\n' + (0, _ascii.wrapInASCIIBox)(_browserType.kNoXServerRunningError, 1);
+    // These error messages are taken from Chromium source code as of July, 2020:
+    // https://github.com/chromium/chromium/blob/70565f67e79f79e17663ad1337dc6e63ee207ce9/content/browser/zygote_host/zygote_host_impl_linux.cc
+    if (!error.logs.includes('crbug.com/357670') && !error.logs.includes('No usable sandbox!') && !error.logs.includes('crbug.com/638180')) return error;
+    error.logs = [`Chromium sandboxing failed!`, `================================`, `To avoid the sandboxing issue, do either of the following:`, `  - (preferred): Configure your environment to support sandboxing`, `  - (alternative): Launch Chromium without sandbox using 'chromiumSandbox: false' option`, `================================`, ``].join('\n');
+    return error;
+  }
+  amendEnvironment(env, userDataDir, executable, browserArguments) {
+    return env;
+  }
+  attemptToGracefullyCloseBrowser(transport) {
+    const message = {
+      method: 'Browser.close',
+      id: _crConnection.kBrowserCloseMessageId,
+      params: {}
+    };
+    transport.send(message);
+  }
+  async _launchWithSeleniumHub(progress, hubUrl, options) {
+    await this._createArtifactDirs(options);
+    if (!hubUrl.endsWith('/')) hubUrl = hubUrl + '/';
+    const args = this._innerDefaultArgs(options);
+    args.push('--remote-debugging-port=0');
+    const isEdge = options.channel && options.channel.startsWith('msedge');
+    let desiredCapabilities = {
+      'browserName': isEdge ? 'MicrosoftEdge' : 'chrome',
+      [isEdge ? 'ms:edgeOptions' : 'goog:chromeOptions']: {
+        args
+      }
+    };
+    if (process.env.SELENIUM_REMOTE_CAPABILITIES) {
+      const remoteCapabilities = parseSeleniumRemoteParams({
+        name: 'capabilities',
+        value: process.env.SELENIUM_REMOTE_CAPABILITIES
+      }, progress);
+      if (remoteCapabilities) desiredCapabilities = {
+        ...desiredCapabilities,
+        ...remoteCapabilities
+      };
+    }
+    let headers = {};
+    if (process.env.SELENIUM_REMOTE_HEADERS) {
+      const remoteHeaders = parseSeleniumRemoteParams({
+        name: 'headers',
+        value: process.env.SELENIUM_REMOTE_HEADERS
+      }, progress);
+      if (remoteHeaders) headers = remoteHeaders;
+    }
+    progress.log(`<selenium> connecting to ${hubUrl}`);
+    const response = await (0, _network.fetchData)({
+      url: hubUrl + 'session',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8',
+        ...headers
+      },
+      data: JSON.stringify({
+        capabilities: {
+          alwaysMatch: desiredCapabilities
+        }
+      }),
+      timeout: progress.timeUntilDeadline()
+    }, seleniumErrorHandler);
+    const value = JSON.parse(response).value;
+    const sessionId = value.sessionId;
+    progress.log(`<selenium> connected to sessionId=${sessionId}`);
+    const disconnectFromSelenium = async () => {
+      progress.log(`<selenium> disconnecting from sessionId=${sessionId}`);
+      await (0, _network.fetchData)({
+        url: hubUrl + 'session/' + sessionId,
+        method: 'DELETE',
+        headers
+      }).catch(error => progress.log(`<error disconnecting from selenium>: ${error}`));
+      progress.log(`<selenium> disconnected from sessionId=${sessionId}`);
+      _processLauncher.gracefullyCloseSet.delete(disconnectFromSelenium);
+    };
+    _processLauncher.gracefullyCloseSet.add(disconnectFromSelenium);
+    try {
+      const capabilities = value.capabilities;
+      let endpointURL;
+      if (capabilities['se:cdp']) {
+        // Selenium 4 - use built-in CDP websocket proxy.
+        progress.log(`<selenium> using selenium v4`);
+        const endpointURLString = addProtocol(capabilities['se:cdp']);
+        endpointURL = new URL(endpointURLString);
+        if (endpointURL.hostname === 'localhost' || endpointURL.hostname === '127.0.0.1') endpointURL.hostname = new URL(hubUrl).hostname;
+        progress.log(`<selenium> retrieved endpoint ${endpointURL.toString()} for sessionId=${sessionId}`);
+      } else {
+        // Selenium 3 - resolve target node IP to use instead of localhost ws url.
+        progress.log(`<selenium> using selenium v3`);
+        const maybeChromeOptions = capabilities['goog:chromeOptions'];
+        const chromeOptions = maybeChromeOptions && typeof maybeChromeOptions === 'object' ? maybeChromeOptions : undefined;
+        const debuggerAddress = chromeOptions && typeof chromeOptions.debuggerAddress === 'string' ? chromeOptions.debuggerAddress : undefined;
+        const chromeOptionsURL = typeof maybeChromeOptions === 'string' ? maybeChromeOptions : undefined;
+        // TODO(dgozman): figure out if we can make ChromeDriver to return 127.0.0.1 instead of localhost.
+        const endpointURLString = addProtocol(debuggerAddress || chromeOptionsURL).replace('localhost', '127.0.0.1');
+        progress.log(`<selenium> retrieved endpoint ${endpointURLString} for sessionId=${sessionId}`);
+        endpointURL = new URL(endpointURLString);
+        if (endpointURL.hostname === 'localhost' || endpointURL.hostname === '127.0.0.1') {
+          const sessionInfoUrl = new URL(hubUrl).origin + '/grid/api/testsession?session=' + sessionId;
+          try {
+            const sessionResponse = await (0, _network.fetchData)({
+              url: sessionInfoUrl,
+              method: 'GET',
+              timeout: progress.timeUntilDeadline(),
+              headers
+            }, seleniumErrorHandler);
+            const proxyId = JSON.parse(sessionResponse).proxyId;
+            endpointURL.hostname = new URL(proxyId).hostname;
+            progress.log(`<selenium> resolved endpoint ip ${endpointURL.toString()} for sessionId=${sessionId}`);
+          } catch (e) {
+            progress.log(`<selenium> unable to resolve endpoint ip for sessionId=${sessionId}, running in standalone?`);
+          }
+        }
+      }
+      return await this._connectOverCDPInternal(progress, endpointURL.toString(), {
+        ...options,
+        headers: (0, _utils.headersObjectToArray)(headers)
+      }, disconnectFromSelenium);
+    } catch (e) {
+      await disconnectFromSelenium();
+      throw e;
+    }
+  }
+  defaultArgs(options, isPersistent, userDataDir) {
+    const chromeArguments = this._innerDefaultArgs(options);
+    chromeArguments.push(`--user-data-dir=${userDataDir}`);
+    if (options.useWebSocket) chromeArguments.push('--remote-debugging-port=0');else chromeArguments.push('--remote-debugging-pipe');
+    if (isPersistent) chromeArguments.push('about:blank');else chromeArguments.push('--no-startup-window');
+    return chromeArguments;
+  }
+  _innerDefaultArgs(options) {
+    const {
+      args = []
+    } = options;
+    const userDataDirArg = args.find(arg => arg.startsWith('--user-data-dir'));
+    if (userDataDirArg) throw this._createUserDataDirArgMisuseError('--user-data-dir');
+    if (args.find(arg => arg.startsWith('--remote-debugging-pipe'))) throw new Error('Playwright manages remote debugging connection itself.');
+    if (args.find(arg => !arg.startsWith('-'))) throw new Error('Arguments can not specify page to be opened');
+    const chromeArguments = [..._chromiumSwitches.chromiumSwitches];
+    if (_os.default.platform() === 'darwin') {
+      // See https://github.com/microsoft/playwright/issues/7362
+      chromeArguments.push('--enable-use-zoom-for-dsf=false');
+      // See https://bugs.chromium.org/p/chromium/issues/detail?id=1407025.
+      if (options.headless) chromeArguments.push('--use-angle');
+    }
+    if (options.devtools) chromeArguments.push('--auto-open-devtools-for-tabs');
+    if (options.headless) {
+      chromeArguments.push('--headless=new');
+      chromeArguments.push('--hide-scrollbars', '--mute-audio', '--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4');
+    }
+    if (options.chromiumSandbox !== true) chromeArguments.push('--no-sandbox');
+    const proxy = options.proxyOverride || options.proxy;
+    if (proxy) {
+      const proxyURL = new URL(proxy.server);
+      const isSocks = proxyURL.protocol === 'socks5:';
+      // https://www.chromium.org/developers/design-documents/network-settings
+      if (isSocks && !this.attribution.playwright.options.socksProxyPort) {
+        // https://www.chromium.org/developers/design-documents/network-stack/socks-proxy
+        chromeArguments.push(`--host-resolver-rules="MAP * ~NOTFOUND , EXCLUDE ${proxyURL.hostname}"`);
+      }
+      chromeArguments.push(`--proxy-server=${proxy.server}`);
+      const proxyBypassRules = [];
+      // https://source.chromium.org/chromium/chromium/src/+/master:net/docs/proxy.md;l=548;drc=71698e610121078e0d1a811054dcf9fd89b49578
+      if (this.attribution.playwright.options.socksProxyPort) proxyBypassRules.push('<-loopback>');
+      if (proxy.bypass) proxyBypassRules.push(...proxy.bypass.split(',').map(t => t.trim()).map(t => t.startsWith('.') ? '*' + t : t));
+      if (!process.env.PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK && !proxyBypassRules.includes('<-loopback>')) proxyBypassRules.push('<-loopback>');
+      if (proxyBypassRules.length > 0) chromeArguments.push(`--proxy-bypass-list=${proxyBypassRules.join(';')}`);
+    }
+    chromeArguments.push(...args);
+    return chromeArguments;
+  }
+  readyState(options) {
+    var _options$args;
+    if (options.useWebSocket || (_options$args = options.args) !== null && _options$args !== void 0 && _options$args.some(a => a.startsWith('--remote-debugging-port'))) return new ChromiumReadyState();
+    return undefined;
+  }
+}
+exports.Chromium = Chromium;
+class ChromiumReadyState extends _browserType.BrowserReadyState {
+  onBrowserOutput(message) {
+    const match = message.match(/DevTools listening on (.*)/);
+    if (match) this._wsEndpoint.resolve(match[1]);
+  }
+}
+async function urlToWSEndpoint(progress, endpointURL, headers) {
+  if (endpointURL.startsWith('ws')) return endpointURL;
+  progress.log(`<ws preparing> retrieving websocket url from ${endpointURL}`);
+  const httpURL = endpointURL.endsWith('/') ? `${endpointURL}json/version/` : `${endpointURL}/json/version/`;
+  const json = await (0, _network.fetchData)({
+    url: httpURL,
+    headers
+  }, async (_, resp) => new Error(`Unexpected status ${resp.statusCode} when connecting to ${httpURL}.\n` + `This does not look like a DevTools server, try connecting via ws://.`));
+  return JSON.parse(json).webSocketDebuggerUrl;
+}
+async function seleniumErrorHandler(params, response) {
+  const body = await streamToString(response);
+  let message = body;
+  try {
+    const json = JSON.parse(body);
+    message = json.value.localizedMessage || json.value.message;
+  } catch (e) {}
+  return new Error(`Error connecting to Selenium at ${params.url}: ${message}`);
+}
+function addProtocol(url) {
+  if (!['ws://', 'wss://', 'http://', 'https://'].some(protocol => url.startsWith(protocol))) return 'http://' + url;
+  return url;
+}
+function streamToString(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on('data', chunk => chunks.push(Buffer.from(chunk)));
+    stream.on('error', reject);
+    stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+  });
+}
+function parseSeleniumRemoteParams(env, progress) {
+  try {
+    const parsed = JSON.parse(env.value);
+    progress.log(`<selenium> using additional ${env.name} "${env.value}"`);
+    return parsed;
+  } catch (e) {
+    progress.log(`<selenium> ignoring additional ${env.name} "${env.value}": ${e}`);
+  }
+}

package/lib/server/chromium/chromiumSwitches.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chromiumSwitches = void 0;
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// No dependencies as it is used from the Electron loader.
+
+const chromiumSwitches = exports.chromiumSwitches = ['--disable-field-trial-config',
+// https://source.chromium.org/chromium/chromium/src/+/main:testing/variations/README.md
+'--disable-background-networking', '--disable-background-timer-throttling', '--disable-backgrounding-occluded-windows',
+// Avoids surprises like main request not being intercepted during page.goBack().
+'--disable-breakpad',
+// Avoids unneeded network activity after startup.
+'--no-default-browser-check', '--disable-dev-shm-usage', '--disable-hang-monitor', '--disable-prompt-on-repost', '--disable-renderer-backgrounding', '--force-color-profile=srgb', '--no-first-run', '--password-store=basic', '--use-mock-keychain',
+// See https://chromium-review.googlesource.com/c/chromium/src/+/2436773
+'--no-service-autorun', '--export-tagged-pdf',
+// https://chromium-review.googlesource.com/c/chromium/src/+/4853540
+'--disable-search-engine-choice-screen', '--disable-blink-features=AutomationControlled'];

package/lib/server/chromium/crAccessibility.js

@@ -0,0 +1,237 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAccessibilityTree = getAccessibilityTree;
+/**
+ * Copyright 2018 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+async function getAccessibilityTree(client, needle) {
+  const {
+    nodes
+  } = await client.send('Accessibility.getFullAXTree');
+  const tree = CRAXNode.createTree(client, nodes);
+  return {
+    tree,
+    needle: needle ? await tree._findElement(needle) : null
+  };
+}
+class CRAXNode {
+  constructor(client, payload) {
+    this._payload = void 0;
+    this._children = [];
+    this._richlyEditable = false;
+    this._editable = false;
+    this._focusable = false;
+    this._expanded = false;
+    this._hidden = false;
+    this._name = void 0;
+    this._role = void 0;
+    this._cachedHasFocusableChild = void 0;
+    this._client = void 0;
+    this._client = client;
+    this._payload = payload;
+    this._name = this._payload.name ? this._payload.name.value : '';
+    this._role = this._payload.role ? this._payload.role.value : 'Unknown';
+    for (const property of this._payload.properties || []) {
+      if (property.name === 'editable') {
+        this._richlyEditable = property.value.value === 'richtext';
+        this._editable = true;
+      }
+      if (property.name === 'focusable') this._focusable = property.value.value;
+      if (property.name === 'expanded') this._expanded = property.value.value;
+      if (property.name === 'hidden') this._hidden = property.value.value;
+    }
+  }
+  _isPlainTextField() {
+    if (this._richlyEditable) return false;
+    if (this._editable) return true;
+    return this._role === 'textbox' || this._role === 'ComboBox' || this._role === 'searchbox';
+  }
+  _isTextOnlyObject() {
+    const role = this._role;
+    return role === 'LineBreak' || role === 'text' || role === 'InlineTextBox' || role === 'StaticText';
+  }
+  _hasFocusableChild() {
+    if (this._cachedHasFocusableChild === undefined) {
+      this._cachedHasFocusableChild = false;
+      for (const child of this._children) {
+        if (child._focusable || child._hasFocusableChild()) {
+          this._cachedHasFocusableChild = true;
+          break;
+        }
+      }
+    }
+    return this._cachedHasFocusableChild;
+  }
+  children() {
+    return this._children;
+  }
+  async _findElement(element) {
+    const objectId = element._objectId;
+    const {
+      node: {
+        backendNodeId
+      }
+    } = await this._client.send('DOM.describeNode', {
+      objectId
+    });
+    const needle = this.find(node => node._payload.backendDOMNodeId === backendNodeId);
+    return needle || null;
+  }
+  find(predicate) {
+    if (predicate(this)) return this;
+    for (const child of this._children) {
+      const result = child.find(predicate);
+      if (result) return result;
+    }
+    return null;
+  }
+  isLeafNode() {
+    if (!this._children.length) return true;
+
+    // These types of objects may have children that we use as internal
+    // implementation details, but we want to expose them as leaves to platform
+    // accessibility APIs because screen readers might be confused if they find
+    // any children.
+    if (this._isPlainTextField() || this._isTextOnlyObject()) return true;
+
+    // Roles whose children are only presentational according to the ARIA and
+    // HTML5 Specs should be hidden from screen readers.
+    // (Note that whilst ARIA buttons can have only presentational children, HTML5
+    // buttons are allowed to have content.)
+    switch (this._role) {
+      case 'doc-cover':
+      case 'graphics-symbol':
+      case 'img':
+      case 'Meter':
+      case 'scrollbar':
+      case 'slider':
+      case 'separator':
+      case 'progressbar':
+        return true;
+      default:
+        break;
+    }
+
+    // Here and below: Android heuristics
+    if (this._hasFocusableChild()) return false;
+    if (this._focusable && this._role !== 'WebArea' && this._role !== 'RootWebArea' && this._name) return true;
+    if (this._role === 'heading' && this._name) return true;
+    return false;
+  }
+  isControl() {
+    switch (this._role) {
+      case 'button':
+      case 'checkbox':
+      case 'ColorWell':
+      case 'combobox':
+      case 'DisclosureTriangle':
+      case 'listbox':
+      case 'menu':
+      case 'menubar':
+      case 'menuitem':
+      case 'menuitemcheckbox':
+      case 'menuitemradio':
+      case 'radio':
+      case 'scrollbar':
+      case 'searchbox':
+      case 'slider':
+      case 'spinbutton':
+      case 'switch':
+      case 'tab':
+      case 'textbox':
+      case 'tree':
+        return true;
+      default:
+        return false;
+    }
+  }
+  isInteresting(insideControl) {
+    const role = this._role;
+    if (role === 'Ignored' || this._hidden) return false;
+    if (this._focusable || this._richlyEditable) return true;
+
+    // If it's not focusable but has a control role, then it's interesting.
+    if (this.isControl()) return true;
+
+    // A non focusable child of a control is not interesting
+    if (insideControl) return false;
+    return this.isLeafNode() && !!this._name;
+  }
+  normalizedRole() {
+    switch (this._role) {
+      case 'RootWebArea':
+        return 'WebArea';
+      case 'StaticText':
+        return 'text';
+      default:
+        return this._role;
+    }
+  }
+  serialize() {
+    const properties = new Map();
+    for (const property of this._payload.properties || []) properties.set(property.name.toLowerCase(), property.value.value);
+    if (this._payload.description) properties.set('description', this._payload.description.value);
+    const node = {
+      role: this.normalizedRole(),
+      name: this._payload.name ? this._payload.name.value || '' : ''
+    };
+    const userStringProperties = ['description', 'keyshortcuts', 'roledescription', 'valuetext'];
+    for (const userStringProperty of userStringProperties) {
+      if (!properties.has(userStringProperty)) continue;
+      node[userStringProperty] = properties.get(userStringProperty);
+    }
+    const booleanProperties = ['disabled', 'expanded', 'focused', 'modal', 'multiline', 'multiselectable', 'readonly', 'required', 'selected'];
+    for (const booleanProperty of booleanProperties) {
+      // WebArea's treat focus differently than other nodes. They report whether their frame  has focus,
+      // not whether focus is specifically on the root node.
+      if (booleanProperty === 'focused' && (this._role === 'WebArea' || this._role === 'RootWebArea')) continue;
+      const value = properties.get(booleanProperty);
+      if (!value) continue;
+      node[booleanProperty] = value;
+    }
+    const numericalProperties = ['level', 'valuemax', 'valuemin'];
+    for (const numericalProperty of numericalProperties) {
+      if (!properties.has(numericalProperty)) continue;
+      node[numericalProperty] = properties.get(numericalProperty);
+    }
+    const tokenProperties = ['autocomplete', 'haspopup', 'invalid', 'orientation'];
+    for (const tokenProperty of tokenProperties) {
+      const value = properties.get(tokenProperty);
+      if (!value || value === 'false') continue;
+      node[tokenProperty] = value;
+    }
+    const axNode = node;
+    if (this._payload.value) {
+      if (typeof this._payload.value.value === 'string') axNode.valueString = this._payload.value.value;
+      if (typeof this._payload.value.value === 'number') axNode.valueNumber = this._payload.value.value;
+    }
+    if (properties.has('checked')) axNode.checked = properties.get('checked') === 'true' ? 'checked' : properties.get('checked') === 'false' ? 'unchecked' : 'mixed';
+    if (properties.has('pressed')) axNode.pressed = properties.get('pressed') === 'true' ? 'pressed' : properties.get('pressed') === 'false' ? 'released' : 'mixed';
+    return axNode;
+  }
+  static createTree(client, payloads) {
+    const nodeById = new Map();
+    for (const payload of payloads) nodeById.set(payload.nodeId, new CRAXNode(client, payload));
+    for (const node of nodeById.values()) {
+      for (const childId of node._payload.childIds || []) node._children.push(nodeById.get(childId));
+    }
+    return nodeById.values().next().value;
+  }
+}