appium-android-driver 5.13.1 → 5.13.2

package/build/lib/android-helpers.js

@@ -1,774 +1,855 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.SETTINGS_HELPER_PKG_ID = exports.APP_STATE = void 0;
-exports.ensureNetworkSpeed = ensureNetworkSpeed;
-exports.helpers = void 0;
-exports.prepareAvdArgs = prepareAvdArgs;
-require("source-map-support/register");
-var _lodash = _interopRequireDefault(require("lodash"));
-var _path = _interopRequireDefault(require("path"));
-var _asyncbox = require("asyncbox");
-var _logger = _interopRequireDefault(require("./logger"));
-var _support = require("@appium/support");
-var _ioAppium = require("io.appium.settings");
-var _bootstrap = _interopRequireDefault(require("./bootstrap"));
-var _bluebird = _interopRequireDefault(require("bluebird"));
-var _appiumAdb = _interopRequireDefault(require("appium-adb"));
-var _unlockHelpers = _interopRequireWildcard(require("./unlock-helpers"));
-var _os = require("os");
-var _semver = _interopRequireDefault(require("semver"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNetworkSpeed = exports.prepareAvdArgs = exports.APP_STATE = exports.SETTINGS_HELPER_PKG_ID = exports.helpers = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = __importDefault(require("path"));
+const asyncbox_1 = require("asyncbox");
+const logger_1 = __importDefault(require("./logger"));
+const support_1 = require("@appium/support");
+const io_appium_settings_1 = require("io.appium.settings");
+const bootstrap_1 = __importDefault(require("./bootstrap"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const appium_adb_1 = __importDefault(require("appium-adb"));
+const unlock_helpers_1 = require("./unlock-helpers");
+const os_1 = require("os");
+const semver_1 = __importDefault(require("semver"));
 const MOCK_APP_IDS_STORE = '/data/local/tmp/mock_apps.json';
 const PACKAGE_INSTALL_TIMEOUT_MS = 90000;
 const HELPER_APP_INSTALL_RETRIES = 3;
 const HELPER_APP_INSTALL_RETRY_DELAY_MS = 5000;
+// https://cs.chromium.org/chromium/src/chrome/browser/devtools/device/android_device_info_query.cc
 const CHROME_BROWSER_PACKAGE_ACTIVITY = {
-  chrome: {
-    pkg: 'com.android.chrome',
-    activity: 'com.google.android.apps.chrome.Main'
-  },
-  chromium: {
-    pkg: 'org.chromium.chrome.shell',
-    activity: '.ChromeShellActivity'
-  },
-  chromebeta: {
-    pkg: 'com.chrome.beta',
-    activity: 'com.google.android.apps.chrome.Main'
-  },
-  browser: {
-    pkg: 'com.android.browser',
-    activity: 'com.android.browser.BrowserActivity'
-  },
-  'chromium-browser': {
-    pkg: 'org.chromium.chrome',
-    activity: 'com.google.android.apps.chrome.Main'
-  },
-  'chromium-webview': {
-    pkg: 'org.chromium.webview_shell',
-    activity: 'org.chromium.webview_shell.WebViewBrowserActivity'
-  },
-  default: {
-    pkg: 'com.android.chrome',
-    activity: 'com.google.android.apps.chrome.Main'
-  }
+    chrome: {
+        pkg: 'com.android.chrome',
+        activity: 'com.google.android.apps.chrome.Main',
+    },
+    chromium: {
+        pkg: 'org.chromium.chrome.shell',
+        activity: '.ChromeShellActivity',
+    },
+    chromebeta: {
+        pkg: 'com.chrome.beta',
+        activity: 'com.google.android.apps.chrome.Main',
+    },
+    browser: {
+        pkg: 'com.android.browser',
+        activity: 'com.android.browser.BrowserActivity',
+    },
+    'chromium-browser': {
+        pkg: 'org.chromium.chrome',
+        activity: 'com.google.android.apps.chrome.Main',
+    },
+    'chromium-webview': {
+        pkg: 'org.chromium.webview_shell',
+        activity: 'org.chromium.webview_shell.WebViewBrowserActivity',
+    },
+    default: {
+        pkg: 'com.android.chrome',
+        activity: 'com.google.android.apps.chrome.Main',
+    },
 };
 const SETTINGS_HELPER_PKG_ID = 'io.appium.settings';
 exports.SETTINGS_HELPER_PKG_ID = SETTINGS_HELPER_PKG_ID;
 const SETTING_NOTIFICATIONS_LISTENER_SERVICE = `${SETTINGS_HELPER_PKG_ID}/.NLService`;
 const EMULATOR_PATTERN = /\bemulator\b/i;
+// These constants are in sync with
+// https://developer.apple.com/documentation/xctest/xcuiapplicationstate/xcuiapplicationstaterunningbackground?language=objc
 const APP_STATE = Object.freeze({
-  NOT_INSTALLED: 0,
-  NOT_RUNNING: 1,
-  RUNNING_IN_BACKGROUND: 3,
-  RUNNING_IN_FOREGROUND: 4
+    NOT_INSTALLED: 0,
+    NOT_RUNNING: 1,
+    RUNNING_IN_BACKGROUND: 3,
+    RUNNING_IN_FOREGROUND: 4
 });
 exports.APP_STATE = APP_STATE;
 function ensureNetworkSpeed(adb, networkSpeed) {
-  if (_lodash.default.values(adb.NETWORK_SPEED).includes(networkSpeed)) {
-    return networkSpeed;
-  }
-  _logger.default.warn(`Wrong network speed param '${networkSpeed}', using default: ${adb.NETWORK_SPEED.FULL}. ` + `Supported values: ${_lodash.default.values(adb.NETWORK_SPEED)}`);
-  return adb.NETWORK_SPEED.FULL;
+    if (lodash_1.default.values(adb.NETWORK_SPEED).includes(networkSpeed)) {
+        return networkSpeed;
+    }
+    logger_1.default.warn(`Wrong network speed param '${networkSpeed}', using default: ${adb.NETWORK_SPEED.FULL}. ` +
+        `Supported values: ${lodash_1.default.values(adb.NETWORK_SPEED)}`);
+    return adb.NETWORK_SPEED.FULL;
 }
+exports.ensureNetworkSpeed = ensureNetworkSpeed;
 function prepareAvdArgs(adb, opts) {
-  const {
-    networkSpeed,
-    isHeadless,
-    avdArgs
-  } = opts;
-  const result = [];
-  if (avdArgs) {
-    if (_lodash.default.isArray(avdArgs)) {
-      result.push(...avdArgs);
-    } else {
-      result.push(..._support.util.shellParse(`${avdArgs}`));
-    }
-  }
-  if (networkSpeed) {
-    result.push('-netspeed', ensureNetworkSpeed(adb, networkSpeed));
-  }
-  if (isHeadless) {
-    result.push('-no-window');
-  }
-  return result;
+    const { networkSpeed, isHeadless, avdArgs, } = opts;
+    const result = [];
+    if (avdArgs) {
+        if (lodash_1.default.isArray(avdArgs)) {
+            result.push(...avdArgs);
+        }
+        else {
+            result.push(...(support_1.util.shellParse(`${avdArgs}`)));
+        }
+    }
+    if (networkSpeed) {
+        result.push('-netspeed', ensureNetworkSpeed(adb, networkSpeed));
+    }
+    if (isHeadless) {
+        result.push('-no-window');
+    }
+    return result;
 }
+exports.prepareAvdArgs = prepareAvdArgs;
 function toCredentialType(unlockType) {
-  const result = {
-    [_unlockHelpers.PIN_UNLOCK]: 'pin',
-    [_unlockHelpers.PIN_UNLOCK_KEY_EVENT]: 'pin',
-    [_unlockHelpers.PASSWORD_UNLOCK]: 'password',
-    [_unlockHelpers.PATTERN_UNLOCK]: 'pattern'
-  }[unlockType];
-  if (result) {
-    return result;
-  }
-  throw new Error(`Unlock type '${unlockType}' is not known`);
+    const result = {
+        [unlock_helpers_1.PIN_UNLOCK]: 'pin',
+        [unlock_helpers_1.PIN_UNLOCK_KEY_EVENT]: 'pin',
+        [unlock_helpers_1.PASSWORD_UNLOCK]: 'password',
+        [unlock_helpers_1.PATTERN_UNLOCK]: 'pattern',
+    }[unlockType];
+    if (result) {
+        return result;
+    }
+    throw new Error(`Unlock type '${unlockType}' is not known`);
 }
 const helpers = {};
 exports.helpers = helpers;
 helpers.createBaseADB = async function createBaseADB(opts = {}) {
-  const {
-    adbPort,
-    suppressKillServer,
-    remoteAdbHost,
-    clearDeviceLogsOnStart,
-    adbExecTimeout,
-    useKeystore,
-    keystorePath,
-    keystorePassword,
-    keyAlias,
-    keyPassword,
-    remoteAppsCacheLimit,
-    buildToolsVersion,
-    allowOfflineDevices,
-    allowDelayAdb
-  } = opts;
-  return await _appiumAdb.default.createADB({
-    adbPort,
-    suppressKillServer,
-    remoteAdbHost,
-    clearDeviceLogsOnStart,
-    adbExecTimeout,
-    useKeystore,
-    keystorePath,
-    keystorePassword,
-    keyAlias,
-    keyPassword,
-    remoteAppsCacheLimit,
-    buildToolsVersion,
-    allowOfflineDevices,
-    allowDelayAdb
-  });
+    // filter out any unwanted options sent in
+    // this list should be updated as ADB takes more arguments
+    const { adbPort, suppressKillServer, remoteAdbHost, clearDeviceLogsOnStart, adbExecTimeout, useKeystore, keystorePath, keystorePassword, keyAlias, keyPassword, remoteAppsCacheLimit, buildToolsVersion, allowOfflineDevices, allowDelayAdb, } = opts;
+    return await appium_adb_1.default.createADB({
+        adbPort,
+        suppressKillServer,
+        remoteAdbHost,
+        clearDeviceLogsOnStart,
+        adbExecTimeout,
+        useKeystore,
+        keystorePath,
+        keystorePassword,
+        keyAlias,
+        keyPassword,
+        remoteAppsCacheLimit,
+        buildToolsVersion,
+        allowOfflineDevices,
+        allowDelayAdb,
+    });
 };
 helpers.prepareEmulator = async function prepareEmulator(adb, opts) {
-  const {
-    avd,
-    avdEnv: env,
-    language,
-    locale: country,
-    avdLaunchTimeout: launchTimeout,
-    avdReadyTimeout: readyTimeout
-  } = opts;
-  if (!avd) {
-    throw new Error('Cannot launch AVD without AVD name');
-  }
-  const avdName = avd.replace('@', '');
-  let isEmulatorRunning = true;
-  try {
-    await adb.getRunningAVDWithRetry(avdName, 5000);
-  } catch (e) {
-    _logger.default.debug(`Emulator '${avdName}' is not running: ${e.message}`);
-    isEmulatorRunning = false;
-  }
-  const args = prepareAvdArgs(adb, opts);
-  if (isEmulatorRunning) {
-    if (args.includes('-wipe-data')) {
-      _logger.default.debug(`Killing '${avdName}' because it needs to be wiped at start.`);
-      await adb.killEmulator(avdName);
-    } else {
-      _logger.default.debug('Not launching AVD because it is already running.');
-      return;
-    }
-  }
-  await adb.launchAVD(avd, {
-    args,
-    env,
-    language,
-    country,
-    launchTimeout,
-    readyTimeout
-  });
+    const { avd, avdEnv: env, language, locale: country, avdLaunchTimeout: launchTimeout, avdReadyTimeout: readyTimeout, } = opts;
+    if (!avd) {
+        throw new Error('Cannot launch AVD without AVD name');
+    }
+    const avdName = avd.replace('@', '');
+    let isEmulatorRunning = true;
+    try {
+        await adb.getRunningAVDWithRetry(avdName, 5000);
+    }
+    catch (e) {
+        logger_1.default.debug(`Emulator '${avdName}' is not running: ${e.message}`);
+        isEmulatorRunning = false;
+    }
+    const args = prepareAvdArgs(adb, opts);
+    if (isEmulatorRunning) {
+        if (args.includes('-wipe-data')) {
+            logger_1.default.debug(`Killing '${avdName}' because it needs to be wiped at start.`);
+            await adb.killEmulator(avdName);
+        }
+        else {
+            logger_1.default.debug('Not launching AVD because it is already running.');
+            return;
+        }
+    }
+    await adb.launchAVD(avd, {
+        args,
+        env,
+        language,
+        country,
+        launchTimeout,
+        readyTimeout,
+    });
 };
+/**
+ * Set and ensure the locale name of the device under test.
+ *
+ * @param {Object} adb - The adb module instance.
+ * @param {string} language - Language. The language field is case insensitive, but Locale always canonicalizes to lower case.
+ *                            format: [a-zA-Z]{2,8}. e.g. en, ja : https://developer.android.com/reference/java/util/Locale.html
+ * @param {string} country - Country. The country (region) field is case insensitive, but Locale always canonicalizes to upper case.
+ *                            format: [a-zA-Z]{2} | [0-9]{3}. e.g. US, JP : https://developer.android.com/reference/java/util/Locale.html
+ * @param {?string} script - Script. The script field is case insensitive but Locale always canonicalizes to title case.
+ *                            format: [a-zA-Z]{4}. e.g. Hans in zh-Hans-CN : https://developer.android.com/reference/java/util/Locale.html
+ * @throws {Error} If it failed to set locale properly
+ */
 helpers.ensureDeviceLocale = async function ensureDeviceLocale(adb, language, country, script = null) {
-  if (!_lodash.default.isString(language) && !_lodash.default.isString(country)) {
-    _logger.default.warn(`setDeviceLanguageCountry requires language or country.`);
-    _logger.default.warn(`Got language: '${language}' and country: '${country}'`);
-    return;
-  }
-  await adb.setDeviceLanguageCountry(language, country, script);
-  if (!(await adb.ensureCurrentLocale(language, country, script))) {
-    const message = script ? `language: ${language}, country: ${country} and script: ${script}` : `language: ${language} and country: ${country}`;
-    throw new Error(`Failed to set ${message}`);
-  }
+    if (!lodash_1.default.isString(language) && !lodash_1.default.isString(country)) {
+        logger_1.default.warn(`setDeviceLanguageCountry requires language or country.`);
+        logger_1.default.warn(`Got language: '${language}' and country: '${country}'`);
+        return;
+    }
+    await adb.setDeviceLanguageCountry(language, country, script);
+    if (!await adb.ensureCurrentLocale(language, country, script)) {
+        const message = script ? `language: ${language}, country: ${country} and script: ${script}` : `language: ${language} and country: ${country}`;
+        throw new Error(`Failed to set ${message}`);
+    }
 };
 helpers.getDeviceInfoFromCaps = async function getDeviceInfoFromCaps(opts = {}) {
-  const adb = await helpers.createBaseADB(opts);
-  let udid = opts.udid;
-  let emPort = null;
-  if (opts.avd) {
-    await helpers.prepareEmulator(adb, opts);
-    udid = adb.curDeviceId;
-    emPort = adb.emulatorPort;
-  } else {
-    _logger.default.info('Retrieving device list');
-    let devices = await adb.getDevicesWithRetry();
-    if (udid) {
-      if (!_lodash.default.includes(_lodash.default.map(devices, 'udid'), udid)) {
-        _logger.default.errorAndThrow(`Device ${udid} was not in the list of connected devices`);
-      }
-      emPort = adb.getPortFromEmulatorString(udid);
-    } else if (opts.platformVersion) {
-      opts.platformVersion = `${opts.platformVersion}`.trim();
-      const platformVersion = _semver.default.coerce(opts.platformVersion) || opts.platformVersion;
-      _logger.default.info(`Looking for a device with Android '${platformVersion}'`);
-      const availDevices = [];
-      let partialMatchCandidate = null;
-      for (const device of devices) {
-        await adb.setDeviceId(device.udid);
-        const rawDeviceOS = await adb.getPlatformVersion();
-        availDevices.push(`${device.udid} (${rawDeviceOS})`);
-        const deviceOS = _semver.default.coerce(rawDeviceOS) || rawDeviceOS;
-        if (!deviceOS) {
-          continue;
-        }
-        const bothVersionsCanBeCoerced = _semver.default.valid(deviceOS) && _semver.default.valid(platformVersion);
-        const bothVersionsAreStrings = _lodash.default.isString(deviceOS) && _lodash.default.isString(platformVersion);
-        if (bothVersionsCanBeCoerced && deviceOS.version === platformVersion.version || bothVersionsAreStrings && _lodash.default.toLower(deviceOS) === _lodash.default.toLower(platformVersion)) {
-          udid = device.udid;
-          break;
-        } else if (!bothVersionsCanBeCoerced) {
-          continue;
-        }
-        if ((!_lodash.default.includes(opts.platformVersion, '.') && platformVersion.major === deviceOS.major || platformVersion.major === deviceOS.major && platformVersion.minor === deviceOS.minor) && (partialMatchCandidate && _semver.default.gt(deviceOS, _lodash.default.values(partialMatchCandidate)[0]) || !partialMatchCandidate)) {
-          partialMatchCandidate = {
-            [device.udid]: deviceOS
-          };
-        }
-      }
-      if (!udid && partialMatchCandidate) {
-        udid = _lodash.default.keys(partialMatchCandidate)[0];
-        await adb.setDeviceId(udid);
-      }
-      if (!udid) {
-        _logger.default.errorAndThrow(`Unable to find an active device or emulator ` + `with OS ${opts.platformVersion}. The following are available: ` + availDevices.join(', '));
-      }
-      emPort = adb.getPortFromEmulatorString(udid);
-    } else {
-      udid = devices[0].udid;
-      emPort = adb.getPortFromEmulatorString(udid);
-    }
-  }
-  _logger.default.info(`Using device: ${udid}`);
-  return {
-    udid,
-    emPort
-  };
+    // we can create a throwaway ADB instance here, so there is no dependency
+    // on instantiating on earlier (at this point, we have no udid)
+    // we can only use this ADB object for commands that would not be confused
+    // if multiple devices are connected
+    const adb = await helpers.createBaseADB(opts);
+    let udid = opts.udid;
+    let emPort = null;
+    // a specific avd name was given. try to initialize with that
+    if (opts.avd) {
+        await helpers.prepareEmulator(adb, opts);
+        udid = adb.curDeviceId;
+        emPort = adb.emulatorPort;
+    }
+    else {
+        // no avd given. lets try whatever's plugged in devices/emulators
+        logger_1.default.info('Retrieving device list');
+        let devices = await adb.getDevicesWithRetry();
+        // udid was given, lets try to init with that device
+        if (udid) {
+            if (!lodash_1.default.includes(lodash_1.default.map(devices, 'udid'), udid)) {
+                logger_1.default.errorAndThrow(`Device ${udid} was not in the list of connected devices`);
+            }
+            emPort = adb.getPortFromEmulatorString(udid);
+        }
+        else if (opts.platformVersion) {
+            opts.platformVersion = `${opts.platformVersion}`.trim();
+            // a platform version was given. lets try to find a device with the same os
+            const platformVersion = semver_1.default.coerce(opts.platformVersion) || opts.platformVersion;
+            logger_1.default.info(`Looking for a device with Android '${platformVersion}'`);
+            // in case we fail to find something, give the user a useful log that has
+            // the device udids and os versions so they know what's available
+            const availDevices = [];
+            let partialMatchCandidate = null;
+            // first try started devices/emulators
+            for (const device of devices) {
+                // direct adb calls to the specific device
+                await adb.setDeviceId(device.udid);
+                const rawDeviceOS = await adb.getPlatformVersion();
+                // The device OS could either be a number, like `6.0`
+                // or an abbreviation, like `R`
+                availDevices.push(`${device.udid} (${rawDeviceOS})`);
+                const deviceOS = semver_1.default.coerce(rawDeviceOS) || rawDeviceOS;
+                if (!deviceOS) {
+                    continue;
+                }
+                const bothVersionsCanBeCoerced = semver_1.default.valid(deviceOS) && semver_1.default.valid(platformVersion);
+                const bothVersionsAreStrings = lodash_1.default.isString(deviceOS) && lodash_1.default.isString(platformVersion);
+                if (bothVersionsCanBeCoerced && deviceOS.version === platformVersion.version
+                    || bothVersionsAreStrings && lodash_1.default.toLower(deviceOS) === lodash_1.default.toLower(platformVersion)) {
+                    // Got an exact match - proceed immediately
+                    udid = device.udid;
+                    break;
+                }
+                else if (!bothVersionsCanBeCoerced) {
+                    // There is no point to check for partial match if either of version numbers is not coercible
+                    continue;
+                }
+                if ((!lodash_1.default.includes(opts.platformVersion, '.') && platformVersion.major === deviceOS.major
+                    || platformVersion.major === deviceOS.major && platformVersion.minor === deviceOS.minor)
+                    // Got a partial match - make sure we consider the most recent
+                    // device version available on the host system
+                    && (partialMatchCandidate && semver_1.default.gt(deviceOS, lodash_1.default.values(partialMatchCandidate)[0])
+                        || !partialMatchCandidate)) {
+                    partialMatchCandidate = { [device.udid]: deviceOS };
+                }
+            }
+            if (!udid && partialMatchCandidate) {
+                udid = lodash_1.default.keys(partialMatchCandidate)[0];
+                await adb.setDeviceId(udid);
+            }
+            if (!udid) {
+                // we couldn't find anything! quit
+                logger_1.default.errorAndThrow(`Unable to find an active device or emulator ` +
+                    `with OS ${opts.platformVersion}. The following are available: ` +
+                    availDevices.join(', '));
+            }
+            emPort = adb.getPortFromEmulatorString(udid);
+        }
+        else {
+            // a udid was not given, grab the first device we see
+            udid = devices[0].udid;
+            emPort = adb.getPortFromEmulatorString(udid);
+        }
+    }
+    logger_1.default.info(`Using device: ${udid}`);
+    return { udid, emPort };
 };
+// returns a new adb instance with deviceId set
 helpers.createADB = async function createADB(opts = {}) {
-  const {
-    udid,
-    emPort
-  } = opts;
-  const adb = await helpers.createBaseADB(opts);
-  adb.setDeviceId(udid);
-  if (emPort) {
-    adb.setEmulatorPort(emPort);
-  }
-  return adb;
+    const { udid, emPort } = opts;
+    const adb = await helpers.createBaseADB(opts);
+    adb.setDeviceId(udid);
+    if (emPort) {
+        adb.setEmulatorPort(emPort);
+    }
+    return adb;
 };
 helpers.validatePackageActivityNames = function validatePackageActivityNames(opts) {
-  for (const key of ['appPackage', 'appActivity', 'appWaitPackage', 'appWaitActivity']) {
-    const name = opts[key];
-    if (!name) {
-      continue;
-    }
-    const match = /([^\w.*,])+/.exec(name);
-    if (!match) {
-      continue;
+    for (const key of ['appPackage', 'appActivity', 'appWaitPackage', 'appWaitActivity']) {
+        const name = opts[key];
+        if (!name) {
+            continue;
+        }
+        const match = /([^\w.*,])+/.exec(name);
+        if (!match) {
+            continue;
+        }
+        logger_1.default.warn(`Capability '${key}' is expected to only include latin letters, digits, underscore, dot, comma and asterisk characters.`);
+        logger_1.default.warn(`Current value '${name}' has non-matching character at index ${match.index}: '${name.substring(0, match.index + 1)}'`);
     }
-    _logger.default.warn(`Capability '${key}' is expected to only include latin letters, digits, underscore, dot, comma and asterisk characters.`);
-    _logger.default.warn(`Current value '${name}' has non-matching character at index ${match.index}: '${name.substring(0, match.index + 1)}'`);
-  }
 };
 helpers.getLaunchInfo = async function getLaunchInfo(adb, opts) {
-  let {
-    app,
-    appPackage,
-    appActivity,
-    appWaitPackage,
-    appWaitActivity
-  } = opts;
-  if (!app) {
-    _logger.default.warn('No app sent in, not parsing package/activity');
-    return;
-  }
-  this.validatePackageActivityNames(opts);
-  if (appPackage && appActivity) {
-    return;
-  }
-  _logger.default.debug('Parsing package and activity from app manifest');
-  let {
-    apkPackage,
-    apkActivity
-  } = await adb.packageAndLaunchActivityFromManifest(app);
-  if (apkPackage && !appPackage) {
-    appPackage = apkPackage;
-  }
-  if (!appWaitPackage) {
-    appWaitPackage = appPackage;
-  }
-  if (apkActivity && !appActivity) {
-    appActivity = apkActivity;
-  }
-  if (!appWaitActivity) {
-    appWaitActivity = appActivity;
-  }
-  _logger.default.debug(`Parsed package and activity are: ${apkPackage}/${apkActivity}`);
-  return {
-    appPackage,
-    appWaitPackage,
-    appActivity,
-    appWaitActivity
-  };
+    let { app, appPackage, appActivity, appWaitPackage, appWaitActivity } = opts;
+    if (!app) {
+        logger_1.default.warn('No app sent in, not parsing package/activity');
+        return;
+    }
+    this.validatePackageActivityNames(opts);
+    if (appPackage && appActivity) {
+        return;
+    }
+    logger_1.default.debug('Parsing package and activity from app manifest');
+    let { apkPackage, apkActivity } = await adb.packageAndLaunchActivityFromManifest(app);
+    if (apkPackage && !appPackage) {
+        appPackage = apkPackage;
+    }
+    if (!appWaitPackage) {
+        appWaitPackage = appPackage;
+    }
+    if (apkActivity && !appActivity) {
+        appActivity = apkActivity;
+    }
+    if (!appWaitActivity) {
+        appWaitActivity = appActivity;
+    }
+    logger_1.default.debug(`Parsed package and activity are: ${apkPackage}/${apkActivity}`);
+    return { appPackage, appWaitPackage, appActivity, appWaitActivity };
 };
 helpers.resetApp = async function resetApp(adb, opts = {}) {
-  const {
-    app,
-    appPackage,
-    fastReset,
-    fullReset,
-    androidInstallTimeout = PACKAGE_INSTALL_TIMEOUT_MS,
-    autoGrantPermissions,
-    allowTestPackages
-  } = opts;
-  if (!appPackage) {
-    throw new Error("'appPackage' option is required");
-  }
-  const isInstalled = await adb.isAppInstalled(appPackage);
-  if (isInstalled) {
-    try {
-      await adb.forceStop(appPackage);
-    } catch (ign) {}
-    if (!fullReset && fastReset) {
-      const output = await adb.clear(appPackage);
-      if (_lodash.default.isString(output) && output.toLowerCase().includes('failed')) {
-        throw new Error(`Cannot clear the application data of '${appPackage}'. Original error: ${output}`);
-      }
-      if (autoGrantPermissions) {
+    const { app, appPackage, fastReset, fullReset, androidInstallTimeout = PACKAGE_INSTALL_TIMEOUT_MS, autoGrantPermissions, allowTestPackages } = opts;
+    if (!appPackage) {
+        throw new Error("'appPackage' option is required");
+    }
+    const isInstalled = await adb.isAppInstalled(appPackage);
+    if (isInstalled) {
         try {
-          await adb.grantAllPermissions(appPackage);
-        } catch (error) {
-          _logger.default.error(`Unable to grant permissions requested. Original error: ${error.message}`);
-        }
-      }
-      _logger.default.debug(`Performed fast reset on the installed '${appPackage}' application (stop and clear)`);
-      return;
-    }
-  }
-  if (!app) {
-    throw new Error(`Either provide 'app' option to install '${appPackage}' or ` + `consider setting 'noReset' to 'true' if '${appPackage}' is supposed to be preinstalled.`);
-  }
-  _logger.default.debug(`Running full reset on '${appPackage}' (reinstall)`);
-  if (isInstalled) {
-    await adb.uninstallApk(appPackage);
-  }
-  await adb.install(app, {
-    grantPermissions: autoGrantPermissions,
-    timeout: androidInstallTimeout,
-    allowTestPackages
-  });
+            await adb.forceStop(appPackage);
+        }
+        catch (ign) { }
+        // fullReset has priority over fastReset
+        if (!fullReset && fastReset) {
+            const output = await adb.clear(appPackage);
+            if (lodash_1.default.isString(output) && output.toLowerCase().includes('failed')) {
+                throw new Error(`Cannot clear the application data of '${appPackage}'. Original error: ${output}`);
+            }
+            // executing `shell pm clear` resets previously assigned application permissions as well
+            if (autoGrantPermissions) {
+                try {
+                    await adb.grantAllPermissions(appPackage);
+                }
+                catch (error) {
+                    logger_1.default.error(`Unable to grant permissions requested. Original error: ${error.message}`);
+                }
+            }
+            logger_1.default.debug(`Performed fast reset on the installed '${appPackage}' application (stop and clear)`);
+            return;
+        }
+    }
+    if (!app) {
+        throw new Error(`Either provide 'app' option to install '${appPackage}' or ` +
+            `consider setting 'noReset' to 'true' if '${appPackage}' is supposed to be preinstalled.`);
+    }
+    logger_1.default.debug(`Running full reset on '${appPackage}' (reinstall)`);
+    if (isInstalled) {
+        await adb.uninstallApk(appPackage);
+    }
+    await adb.install(app, {
+        grantPermissions: autoGrantPermissions,
+        timeout: androidInstallTimeout,
+        allowTestPackages,
+    });
 };
 helpers.installApk = async function installApk(adb, opts = {}) {
-  const {
-    app,
-    appPackage,
-    fastReset,
-    fullReset,
-    androidInstallTimeout = PACKAGE_INSTALL_TIMEOUT_MS,
-    autoGrantPermissions,
-    allowTestPackages,
-    enforceAppInstall
-  } = opts;
-  if (!app || !appPackage) {
-    throw new Error("'app' and 'appPackage' options are required");
-  }
-  if (fullReset) {
-    await this.resetApp(adb, opts);
-    return;
-  }
-  const {
-    appState,
-    wasUninstalled
-  } = await adb.installOrUpgrade(app, appPackage, {
-    grantPermissions: autoGrantPermissions,
-    timeout: androidInstallTimeout,
-    allowTestPackages,
-    enforceCurrentBuild: enforceAppInstall
-  });
-  const isInstalledOverExistingApp = !wasUninstalled && appState !== adb.APP_INSTALL_STATE.NOT_INSTALLED;
-  if (fastReset && isInstalledOverExistingApp) {
-    _logger.default.info(`Performing fast reset on '${appPackage}'`);
-    await this.resetApp(adb, opts);
-  }
+    const { app, appPackage, fastReset, fullReset, androidInstallTimeout = PACKAGE_INSTALL_TIMEOUT_MS, autoGrantPermissions, allowTestPackages, enforceAppInstall, } = opts;
+    if (!app || !appPackage) {
+        throw new Error("'app' and 'appPackage' options are required");
+    }
+    if (fullReset) {
+        await this.resetApp(adb, opts);
+        return;
+    }
+    const { appState, wasUninstalled } = await adb.installOrUpgrade(app, appPackage, {
+        grantPermissions: autoGrantPermissions,
+        timeout: androidInstallTimeout,
+        allowTestPackages,
+        enforceCurrentBuild: enforceAppInstall,
+    });
+    // There is no need to reset the newly installed app
+    const isInstalledOverExistingApp = !wasUninstalled
+        && appState !== adb.APP_INSTALL_STATE.NOT_INSTALLED;
+    if (fastReset && isInstalledOverExistingApp) {
+        logger_1.default.info(`Performing fast reset on '${appPackage}'`);
+        await this.resetApp(adb, opts);
+    }
 };
+/**
+ * Installs an array of apks
+ * @param {ADB} adb Instance of Appium ADB object
+ * @param {Object} opts Opts defined in driver.js
+ */
 helpers.installOtherApks = async function installOtherApks(otherApps, adb, opts) {
-  let {
-    androidInstallTimeout = PACKAGE_INSTALL_TIMEOUT_MS,
-    autoGrantPermissions,
-    allowTestPackages
-  } = opts;
-  await _bluebird.default.all(otherApps.map(otherApp => {
-    _logger.default.debug(`Installing app: ${otherApp}`);
-    return adb.installOrUpgrade(otherApp, null, {
-      grantPermissions: autoGrantPermissions,
-      timeout: androidInstallTimeout,
-      allowTestPackages
-    });
-  }));
+    let { androidInstallTimeout = PACKAGE_INSTALL_TIMEOUT_MS, autoGrantPermissions, allowTestPackages } = opts;
+    // Install all of the APK's asynchronously
+    await bluebird_1.default.all(otherApps.map((otherApp) => {
+        logger_1.default.debug(`Installing app: ${otherApp}`);
+        return adb.installOrUpgrade(otherApp, null, {
+            grantPermissions: autoGrantPermissions,
+            timeout: androidInstallTimeout,
+            allowTestPackages,
+        });
+    }));
 };
+/**
+ * Uninstall an array of packages
+ * @param {ADB} adb Instance of Appium ADB object
+ * @param {Array<string>} appPackages An array of package names to uninstall. If this includes `'*'`, uninstall all of 3rd party apps
+ * @param {Array<string>} filterPackages An array of packages does not uninstall when `*` is provided as `appPackages`
+ */
 helpers.uninstallOtherPackages = async function uninstallOtherPackages(adb, appPackages, filterPackages = []) {
-  if (appPackages.includes('*')) {
-    _logger.default.debug('Uninstall third party packages');
-    appPackages = await this.getThirdPartyPackages(adb, filterPackages);
-  }
-  _logger.default.debug(`Uninstalling packages: ${appPackages}`);
-  await _bluebird.default.all(appPackages.map(appPackage => adb.uninstallApk(appPackage)));
+    if (appPackages.includes('*')) {
+        logger_1.default.debug('Uninstall third party packages');
+        appPackages = await this.getThirdPartyPackages(adb, filterPackages);
+    }
+    logger_1.default.debug(`Uninstalling packages: ${appPackages}`);
+    await bluebird_1.default.all(appPackages.map((appPackage) => adb.uninstallApk(appPackage)));
 };
+/**
+ * Get third party packages filtered with `filterPackages`
+ * @param {ADB} adb Instance of Appium ADB object
+ * @param {Array<string>} filterPackages An array of packages does not uninstall when `*` is provided as `appPackages`
+ * @returns {Array<string>} An array of installed third pary packages
+ */
 helpers.getThirdPartyPackages = async function getThirdPartyPackages(adb, filterPackages = []) {
-  try {
-    const packagesString = await adb.shell(['pm', 'list', 'packages', '-3']);
-    const appPackagesArray = packagesString.trim().replace(/package:/g, '').split(_os.EOL);
-    _logger.default.debug(`'${appPackagesArray}' filtered with '${filterPackages}'`);
-    return _lodash.default.difference(appPackagesArray, filterPackages);
-  } catch (err) {
-    _logger.default.warn(`Unable to get packages with 'adb shell pm list packages -3': ${err.message}`);
-    return [];
-  }
+    try {
+        const packagesString = await adb.shell(['pm', 'list', 'packages', '-3']);
+        const appPackagesArray = packagesString.trim().replace(/package:/g, '').split(os_1.EOL);
+        logger_1.default.debug(`'${appPackagesArray}' filtered with '${filterPackages}'`);
+        return lodash_1.default.difference(appPackagesArray, filterPackages);
+    }
+    catch (err) {
+        logger_1.default.warn(`Unable to get packages with 'adb shell pm list packages -3': ${err.message}`);
+        return [];
+    }
 };
 helpers.initUnicodeKeyboard = async function initUnicodeKeyboard(adb) {
-  _logger.default.debug('Enabling Unicode keyboard support');
-  let defaultIME = await adb.defaultIME();
-  _logger.default.debug(`Unsetting previous IME ${defaultIME}`);
-  const appiumIME = `${SETTINGS_HELPER_PKG_ID}/.UnicodeIME`;
-  _logger.default.debug(`Setting IME to '${appiumIME}'`);
-  await adb.enableIME(appiumIME);
-  await adb.setIME(appiumIME);
-  return defaultIME;
+    logger_1.default.debug('Enabling Unicode keyboard support');
+    // get the default IME so we can return back to it later if we want
+    let defaultIME = await adb.defaultIME();
+    logger_1.default.debug(`Unsetting previous IME ${defaultIME}`);
+    const appiumIME = `${SETTINGS_HELPER_PKG_ID}/.UnicodeIME`;
+    logger_1.default.debug(`Setting IME to '${appiumIME}'`);
+    await adb.enableIME(appiumIME);
+    await adb.setIME(appiumIME);
+    return defaultIME;
 };
 helpers.setMockLocationApp = async function setMockLocationApp(adb, app) {
-  try {
-    if ((await adb.getApiLevel()) < 23) {
-      await adb.shell(['settings', 'put', 'secure', 'mock_location', '1']);
-    } else {
-      await adb.shell(['appops', 'set', app, 'android:mock_location', 'allow']);
-    }
-  } catch (err) {
-    _logger.default.warn(`Unable to set mock location for app '${app}': ${err.message}`);
-    return;
-  }
-  try {
-    let pkgIds = [];
-    if (await adb.fileExists(MOCK_APP_IDS_STORE)) {
-      try {
-        pkgIds = JSON.parse(await adb.shell(['cat', MOCK_APP_IDS_STORE]));
-      } catch (ign) {}
-    }
-    if (pkgIds.includes(app)) {
-      return;
-    }
-    pkgIds.push(app);
-    const tmpRoot = await _support.tempDir.openDir();
-    const srcPath = _path.default.posix.join(tmpRoot, _path.default.posix.basename(MOCK_APP_IDS_STORE));
     try {
-      await _support.fs.writeFile(srcPath, JSON.stringify(pkgIds), 'utf8');
-      await adb.push(srcPath, MOCK_APP_IDS_STORE);
-    } finally {
-      await _support.fs.rimraf(tmpRoot);
+        if (await adb.getApiLevel() < 23) {
+            await adb.shell(['settings', 'put', 'secure', 'mock_location', '1']);
+        }
+        else {
+            await adb.shell(['appops', 'set', app, 'android:mock_location', 'allow']);
+        }
+    }
+    catch (err) {
+        logger_1.default.warn(`Unable to set mock location for app '${app}': ${err.message}`);
+        return;
+    }
+    try {
+        let pkgIds = [];
+        if (await adb.fileExists(MOCK_APP_IDS_STORE)) {
+            try {
+                pkgIds = JSON.parse(await adb.shell(['cat', MOCK_APP_IDS_STORE]));
+            }
+            catch (ign) { }
+        }
+        if (pkgIds.includes(app)) {
+            return;
+        }
+        pkgIds.push(app);
+        const tmpRoot = await support_1.tempDir.openDir();
+        const srcPath = path_1.default.posix.join(tmpRoot, path_1.default.posix.basename(MOCK_APP_IDS_STORE));
+        try {
+            await support_1.fs.writeFile(srcPath, JSON.stringify(pkgIds), 'utf8');
+            await adb.push(srcPath, MOCK_APP_IDS_STORE);
+        }
+        finally {
+            await support_1.fs.rimraf(tmpRoot);
+        }
+    }
+    catch (e) {
+        logger_1.default.warn(`Unable to persist mock location app id '${app}': ${e.message}`);
     }
-  } catch (e) {
-    _logger.default.warn(`Unable to persist mock location app id '${app}': ${e.message}`);
-  }
 };
 helpers.resetMockLocation = async function resetMockLocation(adb) {
-  try {
-    if ((await adb.getApiLevel()) < 23) {
-      await adb.shell(['settings', 'put', 'secure', 'mock_location', '0']);
-      return;
-    }
-    const thirdPartyPkgIdsPromise = helpers.getThirdPartyPackages(adb);
-    let pkgIds = [];
-    if (await adb.fileExists(MOCK_APP_IDS_STORE)) {
-      try {
-        pkgIds = JSON.parse(await adb.shell(['cat', MOCK_APP_IDS_STORE]));
-      } catch (ign) {}
-    }
-    const thirdPartyPkgIds = await thirdPartyPkgIdsPromise;
-    const resultPkgs = _lodash.default.intersection(pkgIds, thirdPartyPkgIds);
-    if (_lodash.default.size(resultPkgs) <= 1) {
-      await adb.shell(['appops', 'set', resultPkgs[0] ?? SETTINGS_HELPER_PKG_ID, 'android:mock_location', 'deny']);
-      return;
-    }
-    _logger.default.debug(`Resetting mock_location permission for the following apps: ${resultPkgs}`);
-    await _bluebird.default.all(resultPkgs.map(pkgId => (async () => {
-      try {
-        await adb.shell(['appops', 'set', pkgId, 'android:mock_location', 'deny']);
-      } catch (ign) {}
-    })()));
-  } catch (err) {
-    _logger.default.warn(`Unable to reset mock location: ${err.message}`);
-  }
+    try {
+        if (await adb.getApiLevel() < 23) {
+            await adb.shell(['settings', 'put', 'secure', 'mock_location', '0']);
+            return;
+        }
+        const thirdPartyPkgIdsPromise = helpers.getThirdPartyPackages(adb);
+        let pkgIds = [];
+        if (await adb.fileExists(MOCK_APP_IDS_STORE)) {
+            try {
+                pkgIds = JSON.parse(await adb.shell(['cat', MOCK_APP_IDS_STORE]));
+            }
+            catch (ign) { }
+        }
+        const thirdPartyPkgIds = await thirdPartyPkgIdsPromise;
+        // Only include currently installed packages
+        const resultPkgs = lodash_1.default.intersection(pkgIds, thirdPartyPkgIds);
+        if (lodash_1.default.size(resultPkgs) <= 1) {
+            await adb.shell(['appops', 'set', resultPkgs[0] ?? SETTINGS_HELPER_PKG_ID, 'android:mock_location', 'deny']);
+            return;
+        }
+        logger_1.default.debug(`Resetting mock_location permission for the following apps: ${resultPkgs}`);
+        await bluebird_1.default.all(resultPkgs.map((pkgId) => (async () => {
+            try {
+                await adb.shell(['appops', 'set', pkgId, 'android:mock_location', 'deny']);
+            }
+            catch (ign) { }
+        })()));
+    }
+    catch (err) {
+        logger_1.default.warn(`Unable to reset mock location: ${err.message}`);
+    }
 };
 helpers.installHelperApp = async function installHelperApp(adb, apkPath, packageId) {
-  await (0, _asyncbox.retryInterval)(HELPER_APP_INSTALL_RETRIES, HELPER_APP_INSTALL_RETRY_DELAY_MS, async function retryInstallHelperApp() {
-    await adb.installOrUpgrade(apkPath, packageId, {
-      grantPermissions: true
+    // Sometimes adb push or adb instal take more time than expected to install an app
+    // e.g. https://github.com/appium/io.appium.settings/issues/40#issuecomment-476593174
+    await (0, asyncbox_1.retryInterval)(HELPER_APP_INSTALL_RETRIES, HELPER_APP_INSTALL_RETRY_DELAY_MS, async function retryInstallHelperApp() {
+        await adb.installOrUpgrade(apkPath, packageId, { grantPermissions: true });
     });
-  });
 };
+/**
+ * Pushes and installs io.appium.settings app.
+ * Throws an error if the setting app is required
+ *
+ * @param {Adb} adb - The adb module instance.
+ * @param {Object} opts - Driver options dictionary.
+ * @param {boolean} throwError [false] - Whether throw an error if Settings app fails to start
+ * @throws {Error} If throwError is true and something happens in installation step
+ */
 helpers.pushSettingsApp = async function pushSettingsApp(adb, throwError = false, opts = {}) {
-  _logger.default.debug('Pushing settings apk to device...');
-  try {
-    await helpers.installHelperApp(adb, _ioAppium.path, SETTINGS_HELPER_PKG_ID, throwError);
-  } catch (err) {
-    if (throwError) {
-      throw err;
-    }
-    _logger.default.warn(`Ignored error while installing '${_ioAppium.path}': ` + `'${err.message}'. Features that rely on this helper ` + 'require the apk such as toggle WiFi and getting location ' + 'will raise an error if you try to use them.');
-  }
-  if (await adb.processExists(SETTINGS_HELPER_PKG_ID)) {
-    _logger.default.debug(`${SETTINGS_HELPER_PKG_ID} is already running. ` + `There is no need to reset its permissions.`);
-    return;
-  }
-  const apiLevel = await adb.getApiLevel();
-  if (apiLevel >= 29) {
+    logger_1.default.debug('Pushing settings apk to device...');
     try {
-      await adb.shell(['appops', 'set', SETTINGS_HELPER_PKG_ID, 'PROJECT_MEDIA', 'allow']);
-    } catch (err) {
-      _logger.default.debug(err.message);
+        await helpers.installHelperApp(adb, io_appium_settings_1.path, SETTINGS_HELPER_PKG_ID, throwError);
+    }
+    catch (err) {
+        if (throwError) {
+            throw err;
+        }
+        logger_1.default.warn(`Ignored error while installing '${io_appium_settings_1.path}': ` +
+            `'${err.message}'. Features that rely on this helper ` +
+            'require the apk such as toggle WiFi and getting location ' +
+            'will raise an error if you try to use them.');
+    }
+    // Reinstall would stop the settings helper process anyway, so
+    // there is no need to continue if the application is still running
+    if (await adb.processExists(SETTINGS_HELPER_PKG_ID)) {
+        logger_1.default.debug(`${SETTINGS_HELPER_PKG_ID} is already running. ` +
+            `There is no need to reset its permissions.`);
+        return;
+    }
+    const apiLevel = await adb.getApiLevel();
+    if (apiLevel >= 29) {
+        // https://github.com/appium/io.appium.settings#internal-audio--video-recording
+        try {
+            await adb.shell(['appops', 'set', SETTINGS_HELPER_PKG_ID, 'PROJECT_MEDIA', 'allow']);
+        }
+        catch (err) {
+            logger_1.default.debug(err.message);
+        }
+        try {
+            await adb.shell(['cmd', 'notification', 'allow_listener', SETTING_NOTIFICATIONS_LISTENER_SERVICE]);
+        }
+        catch (err) {
+            logger_1.default.debug(err.message);
+        }
+    }
+    if (apiLevel <= 23) { // Android 6- devices should have granted permissions
+        // https://github.com/appium/appium/pull/11640#issuecomment-438260477
+        const perms = ['SET_ANIMATION_SCALE', 'CHANGE_CONFIGURATION', 'ACCESS_FINE_LOCATION'];
+        logger_1.default.info(`Granting permissions ${perms} to '${SETTINGS_HELPER_PKG_ID}'`);
+        await adb.grantPermissions(SETTINGS_HELPER_PKG_ID, perms.map((x) => `android.permission.${x}`));
     }
+    // launch io.appium.settings app due to settings failing to be set
+    // if the app is not launched prior to start the session on android 7+
+    // see https://github.com/appium/appium/issues/8957
     try {
-      await adb.shell(['cmd', 'notification', 'allow_listener', SETTING_NOTIFICATIONS_LISTENER_SERVICE]);
-    } catch (err) {
-      _logger.default.debug(err.message);
-    }
-  }
-  if (apiLevel <= 23) {
-    const perms = ['SET_ANIMATION_SCALE', 'CHANGE_CONFIGURATION', 'ACCESS_FINE_LOCATION'];
-    _logger.default.info(`Granting permissions ${perms} to '${SETTINGS_HELPER_PKG_ID}'`);
-    await adb.grantPermissions(SETTINGS_HELPER_PKG_ID, perms.map(x => `android.permission.${x}`));
-  }
-  try {
-    await adb.requireRunningSettingsApp({
-      timeout: helpers.isEmulator(adb, opts) ? 30000 : 5000
-    });
-  } catch (err) {
-    _logger.default.debug(err);
-    if (throwError) {
-      throw err;
+        await adb.requireRunningSettingsApp({
+            timeout: helpers.isEmulator(adb, opts) ? 30000 : 5000
+        });
+    }
+    catch (err) {
+        logger_1.default.debug(err);
+        if (throwError) {
+            throw err;
+        }
     }
-  }
 };
+/**
+ * Extracts string.xml and converts it to string.json and pushes
+ * it to /data/local/tmp/string.json on for use of bootstrap
+ * If app is not present to extract string.xml it deletes remote strings.json
+ * If app does not have strings.xml we push an empty json object to remote
+ *
+ * @param {?string} language - Language abbreviation, for example 'fr'. The default language
+ * is used if this argument is not defined.
+ * @param {Object} adb - The adb module instance.
+ * @param {Object} opts - Driver options dictionary.
+ * @returns {Object} The dictionary, where string resource identifiers are keys
+ * along with their corresponding values for the given language or an empty object
+ * if no matching resources were extracted.
+ */
 helpers.pushStrings = async function pushStrings(language, adb, opts) {
-  const remoteDir = '/data/local/tmp';
-  const stringsJson = 'strings.json';
-  const remoteFile = _path.default.posix.resolve(remoteDir, stringsJson);
-  await adb.rimraf(remoteFile);
-  let app;
-  try {
-    app = opts.app || (await adb.pullApk(opts.appPackage, opts.tmpDir));
-  } catch (err) {
-    _logger.default.info(`Failed to pull an apk from '${opts.appPackage}' to '${opts.tmpDir}'. Original error: ${err.message}`);
-  }
-  if (_lodash.default.isEmpty(opts.appPackage) || !(await _support.fs.exists(app))) {
-    _logger.default.debug(`No app or package specified. Returning empty strings`);
+    const remoteDir = '/data/local/tmp';
+    const stringsJson = 'strings.json';
+    const remoteFile = path_1.default.posix.resolve(remoteDir, stringsJson);
+    // clean up remote string.json if present
+    await adb.rimraf(remoteFile);
+    let app;
+    try {
+        app = opts.app || await adb.pullApk(opts.appPackage, opts.tmpDir);
+    }
+    catch (err) {
+        logger_1.default.info(`Failed to pull an apk from '${opts.appPackage}' to '${opts.tmpDir}'. Original error: ${err.message}`);
+    }
+    if (lodash_1.default.isEmpty(opts.appPackage) || !(await support_1.fs.exists(app))) {
+        logger_1.default.debug(`No app or package specified. Returning empty strings`);
+        return {};
+    }
+    const stringsTmpDir = path_1.default.resolve(opts.tmpDir, opts.appPackage);
+    try {
+        logger_1.default.debug('Extracting strings from apk', app, language, stringsTmpDir);
+        const { apkStrings, localPath } = await adb.extractStringsFromApk(app, language, stringsTmpDir);
+        await adb.push(localPath, remoteDir);
+        return apkStrings;
+    }
+    catch (err) {
+        logger_1.default.warn(`Could not get strings, continuing anyway. Original error: ${err.message}`);
+        await adb.shell('echo', [`'{}' > ${remoteFile}`]);
+    }
+    finally {
+        await support_1.fs.rimraf(stringsTmpDir);
+    }
     return {};
-  }
-  const stringsTmpDir = _path.default.resolve(opts.tmpDir, opts.appPackage);
-  try {
-    _logger.default.debug('Extracting strings from apk', app, language, stringsTmpDir);
-    const {
-      apkStrings,
-      localPath
-    } = await adb.extractStringsFromApk(app, language, stringsTmpDir);
-    await adb.push(localPath, remoteDir);
-    return apkStrings;
-  } catch (err) {
-    _logger.default.warn(`Could not get strings, continuing anyway. Original error: ${err.message}`);
-    await adb.shell('echo', [`'{}' > ${remoteFile}`]);
-  } finally {
-    await _support.fs.rimraf(stringsTmpDir);
-  }
-  return {};
 };
 helpers.unlock = async function unlock(driver, adb, capabilities) {
-  if (!(await adb.isScreenLocked())) {
-    _logger.default.info('Screen already unlocked, doing nothing');
-    return;
-  }
-  _logger.default.debug('Screen is locked, trying to unlock');
-  if (!capabilities.unlockType && !capabilities.unlockKey) {
-    _logger.default.info(`Neither 'unlockType' nor 'unlockKey' capability is provided. ` + `Assuming the device is locked with a simple lock screen.`);
-    await adb.dismissKeyguard();
-    return;
-  }
-  const {
-    unlockType,
-    unlockKey,
-    unlockStrategy,
-    unlockSuccessTimeout
-  } = _unlockHelpers.default.validateUnlockCapabilities(capabilities);
-  if (unlockKey && unlockType !== _unlockHelpers.FINGERPRINT_UNLOCK && (_lodash.default.isNil(unlockStrategy) || _lodash.default.toLower(unlockStrategy) === 'locksettings') && (await adb.isLockManagementSupported())) {
-    await _unlockHelpers.default.fastUnlock(adb, {
-      credential: unlockKey,
-      credentialType: toCredentialType(unlockType)
-    });
-  } else {
-    const unlockMethod = {
-      [_unlockHelpers.PIN_UNLOCK]: _unlockHelpers.default.pinUnlock,
-      [_unlockHelpers.PIN_UNLOCK_KEY_EVENT]: _unlockHelpers.default.pinUnlockWithKeyEvent,
-      [_unlockHelpers.PASSWORD_UNLOCK]: _unlockHelpers.default.passwordUnlock,
-      [_unlockHelpers.PATTERN_UNLOCK]: _unlockHelpers.default.patternUnlock,
-      [_unlockHelpers.FINGERPRINT_UNLOCK]: _unlockHelpers.default.fingerprintUnlock
-    }[unlockType];
-    await unlockMethod(adb, driver, capabilities);
-  }
-  await helpers.verifyUnlock(adb, unlockSuccessTimeout);
+    if (!(await adb.isScreenLocked())) {
+        logger_1.default.info('Screen already unlocked, doing nothing');
+        return;
+    }
+    logger_1.default.debug('Screen is locked, trying to unlock');
+    if (!capabilities.unlockType && !capabilities.unlockKey) {
+        logger_1.default.info(`Neither 'unlockType' nor 'unlockKey' capability is provided. ` +
+            `Assuming the device is locked with a simple lock screen.`);
+        await adb.dismissKeyguard();
+        return;
+    }
+    const { unlockType, unlockKey, unlockStrategy, unlockSuccessTimeout, } = unlock_helpers_1.helpers.validateUnlockCapabilities(capabilities);
+    if (unlockKey && unlockType !== unlock_helpers_1.FINGERPRINT_UNLOCK
+        && (lodash_1.default.isNil(unlockStrategy) || lodash_1.default.toLower(unlockStrategy) === 'locksettings')
+        && await adb.isLockManagementSupported()) {
+        await unlock_helpers_1.helpers.fastUnlock(adb, {
+            credential: unlockKey,
+            credentialType: toCredentialType(unlockType),
+        });
+    }
+    else {
+        const unlockMethod = {
+            [unlock_helpers_1.PIN_UNLOCK]: unlock_helpers_1.helpers.pinUnlock,
+            [unlock_helpers_1.PIN_UNLOCK_KEY_EVENT]: unlock_helpers_1.helpers.pinUnlockWithKeyEvent,
+            [unlock_helpers_1.PASSWORD_UNLOCK]: unlock_helpers_1.helpers.passwordUnlock,
+            [unlock_helpers_1.PATTERN_UNLOCK]: unlock_helpers_1.helpers.patternUnlock,
+            [unlock_helpers_1.FINGERPRINT_UNLOCK]: unlock_helpers_1.helpers.fingerprintUnlock,
+        }[unlockType];
+        await unlockMethod(adb, driver, capabilities);
+    }
+    await helpers.verifyUnlock(adb, unlockSuccessTimeout);
 };
 helpers.verifyUnlock = async function verifyUnlock(adb, timeoutMs = null) {
-  try {
-    await (0, _asyncbox.waitForCondition)(async () => !(await adb.isScreenLocked()), {
-      waitMs: timeoutMs ?? 2000,
-      intervalMs: 500
-    });
-  } catch (ign) {
-    throw new Error('The device has failed to be unlocked');
-  }
-  _logger.default.info('The device has been successfully unlocked');
+    try {
+        await (0, asyncbox_1.waitForCondition)(async () => !(await adb.isScreenLocked()), {
+            waitMs: timeoutMs ?? 2000,
+            intervalMs: 500,
+        });
+    }
+    catch (ign) {
+        throw new Error('The device has failed to be unlocked');
+    }
+    logger_1.default.info('The device has been successfully unlocked');
 };
 helpers.initDevice = async function initDevice(adb, opts) {
-  const {
-    skipDeviceInitialization,
-    locale,
-    language,
-    localeScript,
-    unicodeKeyboard,
-    disableWindowAnimation,
-    skipUnlock,
-    mockLocationApp,
-    skipLogcatCapture,
-    logcatFormat,
-    logcatFilterSpecs
-  } = opts;
-  if (skipDeviceInitialization) {
-    _logger.default.info(`'skipDeviceInitialization' is set. Skipping device initialization.`);
-  } else {
-    if (helpers.isEmulator(adb, opts)) {
-      await adb.waitForDevice();
-    }
-    const shouldThrowError = language || locale || localeScript || unicodeKeyboard || disableWindowAnimation || !skipUnlock;
-    await helpers.pushSettingsApp(adb, shouldThrowError, opts);
-  }
-  if (!helpers.isEmulator(adb, opts)) {
-    if (mockLocationApp || _lodash.default.isUndefined(mockLocationApp)) {
-      await helpers.setMockLocationApp(adb, mockLocationApp || SETTINGS_HELPER_PKG_ID);
-    } else {
-      await helpers.resetMockLocation(adb);
-    }
-  }
-  if (language || locale) {
-    await helpers.ensureDeviceLocale(adb, language, locale, localeScript);
-  }
-  if (skipLogcatCapture) {
-    _logger.default.info(`'skipLogcatCapture' is set. Skipping starting logcat capture.`);
-  } else {
-    await adb.startLogcat({
-      format: logcatFormat,
-      filterSpecs: logcatFilterSpecs
-    });
-  }
-  if (unicodeKeyboard) {
-    return await helpers.initUnicodeKeyboard(adb);
-  }
+    const { skipDeviceInitialization, locale, language, localeScript, unicodeKeyboard, disableWindowAnimation, skipUnlock, mockLocationApp, skipLogcatCapture, logcatFormat, logcatFilterSpecs, } = opts;
+    if (skipDeviceInitialization) {
+        logger_1.default.info(`'skipDeviceInitialization' is set. Skipping device initialization.`);
+    }
+    else {
+        if (helpers.isEmulator(adb, opts)) {
+            // Check if the device wake up only for an emulator.
+            // It takes 1 second or so even when the device is already awake in a real device.
+            await adb.waitForDevice();
+        }
+        // pushSettingsApp required before calling ensureDeviceLocale for API Level 24+
+        // Some feature such as location/wifi are not necessary for all users,
+        // but they require the settings app. So, try to configure it while Appium
+        // does not throw error even if they fail.
+        const shouldThrowError = language
+            || locale
+            || localeScript
+            || unicodeKeyboard
+            || disableWindowAnimation
+            || !skipUnlock;
+        await helpers.pushSettingsApp(adb, shouldThrowError, opts);
+    }
+    if (!helpers.isEmulator(adb, opts)) {
+        if (mockLocationApp || lodash_1.default.isUndefined(mockLocationApp)) {
+            await helpers.setMockLocationApp(adb, mockLocationApp || SETTINGS_HELPER_PKG_ID);
+        }
+        else {
+            await helpers.resetMockLocation(adb);
+        }
+    }
+    if (language || locale) {
+        await helpers.ensureDeviceLocale(adb, language, locale, localeScript);
+    }
+    if (skipLogcatCapture) {
+        logger_1.default.info(`'skipLogcatCapture' is set. Skipping starting logcat capture.`);
+    }
+    else {
+        await adb.startLogcat({
+            format: logcatFormat,
+            filterSpecs: logcatFilterSpecs,
+        });
+    }
+    if (unicodeKeyboard) {
+        return await helpers.initUnicodeKeyboard(adb);
+    }
 };
 helpers.removeNullProperties = function removeNullProperties(obj) {
-  for (let key of _lodash.default.keys(obj)) {
-    if (_lodash.default.isNull(obj[key]) || _lodash.default.isUndefined(obj[key])) {
-      delete obj[key];
+    for (let key of lodash_1.default.keys(obj)) {
+        if (lodash_1.default.isNull(obj[key]) || lodash_1.default.isUndefined(obj[key])) {
+            delete obj[key];
+        }
     }
-  }
 };
 helpers.truncateDecimals = function truncateDecimals(number, digits) {
-  let multiplier = Math.pow(10, digits),
-    adjustedNum = number * multiplier,
-    truncatedNum = Math[adjustedNum < 0 ? 'ceil' : 'floor'](adjustedNum);
-  return truncatedNum / multiplier;
+    let multiplier = Math.pow(10, digits), adjustedNum = number * multiplier, truncatedNum = Math[adjustedNum < 0 ? 'ceil' : 'floor'](adjustedNum);
+    return truncatedNum / multiplier;
 };
 helpers.isChromeBrowser = function isChromeBrowser(browser) {
-  return _lodash.default.includes(Object.keys(CHROME_BROWSER_PACKAGE_ACTIVITY), (browser || '').toLowerCase());
+    return lodash_1.default.includes(Object.keys(CHROME_BROWSER_PACKAGE_ACTIVITY), (browser || '').toLowerCase());
 };
 helpers.getChromePkg = function getChromePkg(browser) {
-  return CHROME_BROWSER_PACKAGE_ACTIVITY[browser.toLowerCase()] || CHROME_BROWSER_PACKAGE_ACTIVITY.default;
+    return CHROME_BROWSER_PACKAGE_ACTIVITY[browser.toLowerCase()] || CHROME_BROWSER_PACKAGE_ACTIVITY.default;
 };
 helpers.removeAllSessionWebSocketHandlers = async function removeAllSessionWebSocketHandlers(server, sessionId) {
-  if (!server || !_lodash.default.isFunction(server.getWebSocketHandlers)) {
-    return;
-  }
-  const activeHandlers = await server.getWebSocketHandlers(sessionId);
-  for (const pathname of _lodash.default.keys(activeHandlers)) {
-    await server.removeWebSocketHandler(pathname);
-  }
+    if (!server || !lodash_1.default.isFunction(server.getWebSocketHandlers)) {
+        return;
+    }
+    const activeHandlers = await server.getWebSocketHandlers(sessionId);
+    for (const pathname of lodash_1.default.keys(activeHandlers)) {
+        await server.removeWebSocketHandler(pathname);
+    }
 };
+/**
+ * Takes a desired capability and tries to JSON.parse it as an array,
+ * and either returns the parsed array or a singleton array.
+ *
+ * @param {any} cap A desired capability
+ */
 helpers.parseArray = function parseArray(cap) {
-  let parsedCaps;
-  try {
-    parsedCaps = JSON.parse(cap);
-  } catch (ign) {}
-  if (_lodash.default.isArray(parsedCaps)) {
-    return parsedCaps;
-  } else if (_lodash.default.isString(cap)) {
-    return [cap];
-  }
-  throw new Error(`must provide a string or JSON Array; received ${cap}`);
+    let parsedCaps;
+    try {
+        parsedCaps = JSON.parse(cap);
+    }
+    catch (ign) { }
+    if (lodash_1.default.isArray(parsedCaps)) {
+        return parsedCaps;
+    }
+    else if (lodash_1.default.isString(cap)) {
+        return [cap];
+    }
+    throw new Error(`must provide a string or JSON Array; received ${cap}`);
 };
+/**
+ * Validate desired capabilities. Returns true if capability is valid
+ *
+ * @param {*} cap A desired capability
+ * @return {boolean} Returns true if the capability is valid
+ * @throws {Error} If the caps has invalid capability
+ */
 helpers.validateDesiredCaps = function validateDesiredCaps(caps) {
-  if (caps.browserName) {
-    if (caps.app) {
-      _logger.default.warn(`The desired capabilities should generally not include both an 'app' and a 'browserName'`);
-    }
-    if (caps.appPackage) {
-      _logger.default.errorAndThrow(`The desired should not include both of an 'appPackage' and a 'browserName'`);
+    if (caps.browserName) {
+        if (caps.app) {
+            // warn if the capabilities have both `app` and `browser, although this is common with selenium grid
+            logger_1.default.warn(`The desired capabilities should generally not include both an 'app' and a 'browserName'`);
+        }
+        if (caps.appPackage) {
+            logger_1.default.errorAndThrow(`The desired should not include both of an 'appPackage' and a 'browserName'`);
+        }
     }
-  }
-  if (caps.uninstallOtherPackages) {
-    try {
-      this.parseArray(caps.uninstallOtherPackages);
-    } catch (e) {
-      _logger.default.errorAndThrow(`Could not parse "uninstallOtherPackages" capability: ${e.message}`);
+    if (caps.uninstallOtherPackages) {
+        try {
+            this.parseArray(caps.uninstallOtherPackages);
+        }
+        catch (e) {
+            logger_1.default.errorAndThrow(`Could not parse "uninstallOtherPackages" capability: ${e.message}`);
+        }
     }
-  }
-  return true;
+    return true;
 };
+/**
+ * Adjust the capabilities for a browser session
+ *
+ * @param {Object} caps - Current capabilities object
+ * !!! The object is mutated by this method call !!!
+ * @returns {Object} The same possibly mutated `opts` instance.
+ * No mutation is happening is the current session if
+ * appPackage/appActivity caps have already been provided.
+ */
 helpers.adjustBrowserSessionCaps = function adjustBrowserSessionCaps(caps = {}) {
-  const {
-    browserName
-  } = caps;
-  _logger.default.info(`The current session is considered browser-based`);
-  _logger.default.info(`Supported browser names: ${JSON.stringify(_lodash.default.keys(CHROME_BROWSER_PACKAGE_ACTIVITY))}`);
-  if (caps.appPackage || caps.appActivity) {
-    _logger.default.info(`Not overriding appPackage/appActivity capability values for '${browserName}' ` + 'because some of them have been already provided');
+    const { browserName } = caps;
+    logger_1.default.info(`The current session is considered browser-based`);
+    logger_1.default.info(`Supported browser names: ${JSON.stringify(lodash_1.default.keys(CHROME_BROWSER_PACKAGE_ACTIVITY))}`);
+    if (caps.appPackage || caps.appActivity) {
+        logger_1.default.info(`Not overriding appPackage/appActivity capability values for '${browserName}' ` +
+            'because some of them have been already provided');
+        return caps;
+    }
+    const { pkg, activity } = this.getChromePkg(browserName);
+    caps.appPackage = pkg;
+    caps.appActivity = activity;
+    logger_1.default.info(`appPackage/appActivity capabilities have been automatically set to ${pkg}/${activity} ` +
+        `for '${browserName}'`);
+    logger_1.default.info(`Consider changing the browserName to the one from the list of supported browser names ` +
+        `or provide custom appPackage/appActivity capability values if the automatically assigned ones do ` +
+        `not make sense`);
     return caps;
-  }
-  const {
-    pkg,
-    activity
-  } = this.getChromePkg(browserName);
-  caps.appPackage = pkg;
-  caps.appActivity = activity;
-  _logger.default.info(`appPackage/appActivity capabilities have been automatically set to ${pkg}/${activity} ` + `for '${browserName}'`);
-  _logger.default.info(`Consider changing the browserName to the one from the list of supported browser names ` + `or provide custom appPackage/appActivity capability values if the automatically assigned ones do ` + `not make sense`);
-  return caps;
 };
+/**
+ * Checks whether the current device under test is an emulator
+ *
+ * @param {ADB} adb - appium-adb instance
+ * @param {Object} opts - driver options mapping
+ * @returns {boolean} `true` if the device is an Android emulator
+ */
 helpers.isEmulator = function isEmulator(adb, opts) {
-  const possibleNames = [opts.udid, adb === null || adb === void 0 ? void 0 : adb.curDeviceId];
-  return !!opts.avd || possibleNames.some(x => EMULATOR_PATTERN.test(x));
-};
-helpers.bootstrap = _bootstrap.default;
-helpers.unlocker = _unlockHelpers.default;
-var _default = helpers;
-exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_path","_asyncbox","_logger","_support","_ioAppium","_bootstrap","_bluebird","_appiumAdb","_unlockHelpers","_interopRequireWildcard","_os","_semver","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","MOCK_APP_IDS_STORE","PACKAGE_INSTALL_TIMEOUT_MS","HELPER_APP_INSTALL_RETRIES","HELPER_APP_INSTALL_RETRY_DELAY_MS","CHROME_BROWSER_PACKAGE_ACTIVITY","chrome","pkg","activity","chromium","chromebeta","browser","SETTINGS_HELPER_PKG_ID","exports","SETTING_NOTIFICATIONS_LISTENER_SERVICE","EMULATOR_PATTERN","APP_STATE","freeze","NOT_INSTALLED","NOT_RUNNING","RUNNING_IN_BACKGROUND","RUNNING_IN_FOREGROUND","ensureNetworkSpeed","adb","networkSpeed","_","values","NETWORK_SPEED","includes","logger","warn","FULL","prepareAvdArgs","opts","isHeadless","avdArgs","result","isArray","push","util","shellParse","toCredentialType","unlockType","PIN_UNLOCK","PIN_UNLOCK_KEY_EVENT","PASSWORD_UNLOCK","PATTERN_UNLOCK","Error","helpers","createBaseADB","adbPort","suppressKillServer","remoteAdbHost","clearDeviceLogsOnStart","adbExecTimeout","useKeystore","keystorePath","keystorePassword","keyAlias","keyPassword","remoteAppsCacheLimit","buildToolsVersion","allowOfflineDevices","allowDelayAdb","ADB","createADB","prepareEmulator","avd","avdEnv","env","language","locale","country","avdLaunchTimeout","launchTimeout","avdReadyTimeout","readyTimeout","avdName","replace","isEmulatorRunning","getRunningAVDWithRetry","e","debug","message","args","killEmulator","launchAVD","ensureDeviceLocale","script","isString","setDeviceLanguageCountry","ensureCurrentLocale","getDeviceInfoFromCaps","udid","emPort","curDeviceId","emulatorPort","info","devices","getDevicesWithRetry","map","errorAndThrow","getPortFromEmulatorString","platformVersion","trim","semver","coerce","availDevices","partialMatchCandidate","device","setDeviceId","rawDeviceOS","getPlatformVersion","deviceOS","bothVersionsCanBeCoerced","valid","bothVersionsAreStrings","version","toLower","major","minor","gt","keys","join","setEmulatorPort","validatePackageActivityNames","name","match","exec","index","substring","getLaunchInfo","app","appPackage","appActivity","appWaitPackage","appWaitActivity","apkPackage","apkActivity","packageAndLaunchActivityFromManifest","resetApp","fastReset","fullReset","androidInstallTimeout","autoGrantPermissions","allowTestPackages","isInstalled","isAppInstalled","forceStop","ign","output","clear","toLowerCase","grantAllPermissions","error","uninstallApk","install","grantPermissions","timeout","installApk","enforceAppInstall","appState","wasUninstalled","installOrUpgrade","enforceCurrentBuild","isInstalledOverExistingApp","APP_INSTALL_STATE","installOtherApks","otherApps","B","all","otherApp","uninstallOtherPackages","appPackages","filterPackages","getThirdPartyPackages","packagesString","shell","appPackagesArray","split","EOL","difference","err","initUnicodeKeyboard","defaultIME","appiumIME","enableIME","setIME","setMockLocationApp","getApiLevel","pkgIds","fileExists","JSON","parse","tmpRoot","tempDir","openDir","srcPath","path","posix","basename","fs","writeFile","stringify","rimraf","resetMockLocation","thirdPartyPkgIdsPromise","thirdPartyPkgIds","resultPkgs","intersection","size","pkgId","installHelperApp","apkPath","packageId","retryInterval","retryInstallHelperApp","pushSettingsApp","throwError","settingsApkPath","processExists","apiLevel","perms","x","requireRunningSettingsApp","isEmulator","pushStrings","remoteDir","stringsJson","remoteFile","resolve","pullApk","tmpDir","isEmpty","exists","stringsTmpDir","apkStrings","localPath","extractStringsFromApk","unlock","driver","capabilities","isScreenLocked","unlockKey","dismissKeyguard","unlockStrategy","unlockSuccessTimeout","unlocker","validateUnlockCapabilities","FINGERPRINT_UNLOCK","isNil","isLockManagementSupported","fastUnlock","credential","credentialType","unlockMethod","pinUnlock","pinUnlockWithKeyEvent","passwordUnlock","patternUnlock","fingerprintUnlock","verifyUnlock","timeoutMs","waitForCondition","waitMs","intervalMs","initDevice","skipDeviceInitialization","localeScript","unicodeKeyboard","disableWindowAnimation","skipUnlock","mockLocationApp","skipLogcatCapture","logcatFormat","logcatFilterSpecs","waitForDevice","shouldThrowError","isUndefined","startLogcat","format","filterSpecs","removeNullProperties","isNull","truncateDecimals","number","digits","multiplier","Math","pow","adjustedNum","truncatedNum","isChromeBrowser","getChromePkg","removeAllSessionWebSocketHandlers","server","sessionId","isFunction","getWebSocketHandlers","activeHandlers","pathname","removeWebSocketHandler","parseArray","cap","parsedCaps","validateDesiredCaps","caps","browserName","adjustBrowserSessionCaps","possibleNames","some","test","bootstrap","Bootstrap","_default"],"sources":["../../lib/android-helpers.js"],"sourcesContent":["import _ from 'lodash';\nimport path from 'path';\nimport { retryInterval, waitForCondition } from 'asyncbox';\nimport logger from './logger';\nimport { fs, util, tempDir } from '@appium/support';\nimport { path as settingsApkPath } from 'io.appium.settings';\nimport Bootstrap from './bootstrap';\nimport B from 'bluebird';\nimport ADB from 'appium-adb';\nimport {\n  default as unlocker, PIN_UNLOCK, PIN_UNLOCK_KEY_EVENT,\n  PASSWORD_UNLOCK, PATTERN_UNLOCK, FINGERPRINT_UNLOCK\n} from './unlock-helpers';\nimport { EOL } from 'os';\nimport semver from 'semver';\n\nconst MOCK_APP_IDS_STORE = '/data/local/tmp/mock_apps.json';\nconst PACKAGE_INSTALL_TIMEOUT_MS = 90000;\nconst HELPER_APP_INSTALL_RETRIES = 3;\nconst HELPER_APP_INSTALL_RETRY_DELAY_MS = 5000;\n// https://cs.chromium.org/chromium/src/chrome/browser/devtools/device/android_device_info_query.cc\nconst CHROME_BROWSER_PACKAGE_ACTIVITY = {\n  chrome: {\n    pkg: 'com.android.chrome',\n    activity: 'com.google.android.apps.chrome.Main',\n  },\n  chromium: {\n    pkg: 'org.chromium.chrome.shell',\n    activity: '.ChromeShellActivity',\n  },\n  chromebeta: {\n    pkg: 'com.chrome.beta',\n    activity: 'com.google.android.apps.chrome.Main',\n  },\n  browser: {\n    pkg: 'com.android.browser',\n    activity: 'com.android.browser.BrowserActivity',\n  },\n  'chromium-browser': {\n    pkg: 'org.chromium.chrome',\n    activity: 'com.google.android.apps.chrome.Main',\n  },\n  'chromium-webview': {\n    pkg: 'org.chromium.webview_shell',\n    activity: 'org.chromium.webview_shell.WebViewBrowserActivity',\n  },\n  default: {\n    pkg: 'com.android.chrome',\n    activity: 'com.google.android.apps.chrome.Main',\n  },\n};\nconst SETTINGS_HELPER_PKG_ID = 'io.appium.settings';\nconst SETTING_NOTIFICATIONS_LISTENER_SERVICE = `${SETTINGS_HELPER_PKG_ID}/.NLService`;\nconst EMULATOR_PATTERN = /\\bemulator\\b/i;\n// These constants are in sync with\n// https://developer.apple.com/documentation/xctest/xcuiapplicationstate/xcuiapplicationstaterunningbackground?language=objc\nconst APP_STATE = Object.freeze({\n  NOT_INSTALLED: 0,\n  NOT_RUNNING: 1,\n  RUNNING_IN_BACKGROUND: 3,\n  RUNNING_IN_FOREGROUND: 4\n});\n\n\nfunction ensureNetworkSpeed (adb, networkSpeed) {\n  if (_.values(adb.NETWORK_SPEED).includes(networkSpeed)) {\n    return networkSpeed;\n  }\n  logger.warn(`Wrong network speed param '${networkSpeed}', using default: ${adb.NETWORK_SPEED.FULL}. ` +\n    `Supported values: ${_.values(adb.NETWORK_SPEED)}`);\n  return adb.NETWORK_SPEED.FULL;\n}\n\nfunction prepareAvdArgs (adb, opts) {\n  const {\n    networkSpeed,\n    isHeadless,\n    avdArgs,\n  } = opts;\n  const result = [];\n  if (avdArgs) {\n    if (_.isArray(avdArgs)) {\n      result.push(...avdArgs);\n    } else {\n      result.push(...(util.shellParse(`${avdArgs}`)));\n    }\n  }\n  if (networkSpeed) {\n    result.push('-netspeed', ensureNetworkSpeed(adb, networkSpeed));\n  }\n  if (isHeadless) {\n    result.push('-no-window');\n  }\n  return result;\n}\n\nfunction toCredentialType (unlockType) {\n  const result = {\n    [PIN_UNLOCK]: 'pin',\n    [PIN_UNLOCK_KEY_EVENT]: 'pin',\n    [PASSWORD_UNLOCK]: 'password',\n    [PATTERN_UNLOCK]: 'pattern',\n  }[unlockType];\n  if (result) {\n    return result;\n  }\n  throw new Error(`Unlock type '${unlockType}' is not known`);\n}\n\n\nconst helpers = {};\n\nhelpers.createBaseADB = async function createBaseADB (opts = {}) {\n  // filter out any unwanted options sent in\n  // this list should be updated as ADB takes more arguments\n  const {\n    adbPort,\n    suppressKillServer,\n    remoteAdbHost,\n    clearDeviceLogsOnStart,\n    adbExecTimeout,\n    useKeystore,\n    keystorePath,\n    keystorePassword,\n    keyAlias,\n    keyPassword,\n    remoteAppsCacheLimit,\n    buildToolsVersion,\n    allowOfflineDevices,\n    allowDelayAdb,\n  } = opts;\n  return await ADB.createADB({\n    adbPort,\n    suppressKillServer,\n    remoteAdbHost,\n    clearDeviceLogsOnStart,\n    adbExecTimeout,\n    useKeystore,\n    keystorePath,\n    keystorePassword,\n    keyAlias,\n    keyPassword,\n    remoteAppsCacheLimit,\n    buildToolsVersion,\n    allowOfflineDevices,\n    allowDelayAdb,\n  });\n};\n\nhelpers.prepareEmulator = async function prepareEmulator (adb, opts) {\n  const {\n    avd,\n    avdEnv: env,\n    language,\n    locale: country,\n    avdLaunchTimeout: launchTimeout,\n    avdReadyTimeout: readyTimeout,\n  } = opts;\n  if (!avd) {\n    throw new Error('Cannot launch AVD without AVD name');\n  }\n\n  const avdName = avd.replace('@', '');\n  let isEmulatorRunning = true;\n  try {\n    await adb.getRunningAVDWithRetry(avdName, 5000);\n  } catch (e) {\n    logger.debug(`Emulator '${avdName}' is not running: ${e.message}`);\n    isEmulatorRunning = false;\n  }\n  const args = prepareAvdArgs(adb, opts);\n  if (isEmulatorRunning) {\n    if (args.includes('-wipe-data')) {\n      logger.debug(`Killing '${avdName}' because it needs to be wiped at start.`);\n      await adb.killEmulator(avdName);\n    } else {\n      logger.debug('Not launching AVD because it is already running.');\n      return;\n    }\n  }\n  await adb.launchAVD(avd, {\n    args,\n    env,\n    language,\n    country,\n    launchTimeout,\n    readyTimeout,\n  });\n};\n\n/**\n * Set and ensure the locale name of the device under test.\n *\n * @param {Object} adb - The adb module instance.\n * @param {string} language - Language. The language field is case insensitive, but Locale always canonicalizes to lower case.\n *                            format: [a-zA-Z]{2,8}. e.g. en, ja : https://developer.android.com/reference/java/util/Locale.html\n * @param {string} country - Country. The country (region) field is case insensitive, but Locale always canonicalizes to upper case.\n *                            format: [a-zA-Z]{2} | [0-9]{3}. e.g. US, JP : https://developer.android.com/reference/java/util/Locale.html\n * @param {?string} script - Script. The script field is case insensitive but Locale always canonicalizes to title case.\n *                            format: [a-zA-Z]{4}. e.g. Hans in zh-Hans-CN : https://developer.android.com/reference/java/util/Locale.html\n * @throws {Error} If it failed to set locale properly\n */\nhelpers.ensureDeviceLocale = async function ensureDeviceLocale (adb, language, country, script = null) {\n  if (!_.isString(language) && !_.isString(country)) {\n    logger.warn(`setDeviceLanguageCountry requires language or country.`);\n    logger.warn(`Got language: '${language}' and country: '${country}'`);\n    return;\n  }\n\n  await adb.setDeviceLanguageCountry(language, country, script);\n\n  if (!await adb.ensureCurrentLocale(language, country, script)) {\n    const message = script ? `language: ${language}, country: ${country} and script: ${script}` : `language: ${language} and country: ${country}`;\n    throw new Error(`Failed to set ${message}`);\n  }\n};\n\nhelpers.getDeviceInfoFromCaps = async function getDeviceInfoFromCaps (opts = {}) {\n  // we can create a throwaway ADB instance here, so there is no dependency\n  // on instantiating on earlier (at this point, we have no udid)\n  // we can only use this ADB object for commands that would not be confused\n  // if multiple devices are connected\n  const adb = await helpers.createBaseADB(opts);\n  let udid = opts.udid;\n  let emPort = null;\n\n  // a specific avd name was given. try to initialize with that\n  if (opts.avd) {\n    await helpers.prepareEmulator(adb, opts);\n    udid = adb.curDeviceId;\n    emPort = adb.emulatorPort;\n  } else {\n    // no avd given. lets try whatever's plugged in devices/emulators\n    logger.info('Retrieving device list');\n    let devices = await adb.getDevicesWithRetry();\n\n    // udid was given, lets try to init with that device\n    if (udid) {\n      if (!_.includes(_.map(devices, 'udid'), udid)) {\n        logger.errorAndThrow(`Device ${udid} was not in the list of connected devices`);\n      }\n      emPort = adb.getPortFromEmulatorString(udid);\n    } else if (opts.platformVersion) {\n      opts.platformVersion = `${opts.platformVersion}`.trim();\n\n      // a platform version was given. lets try to find a device with the same os\n      const platformVersion = semver.coerce(opts.platformVersion) || opts.platformVersion;\n      logger.info(`Looking for a device with Android '${platformVersion}'`);\n\n      // in case we fail to find something, give the user a useful log that has\n      // the device udids and os versions so they know what's available\n      const availDevices = [];\n      let partialMatchCandidate = null;\n      // first try started devices/emulators\n      for (const device of devices) {\n        // direct adb calls to the specific device\n        await adb.setDeviceId(device.udid);\n        const rawDeviceOS = await adb.getPlatformVersion();\n        // The device OS could either be a number, like `6.0`\n        // or an abbreviation, like `R`\n        availDevices.push(`${device.udid} (${rawDeviceOS})`);\n        const deviceOS = semver.coerce(rawDeviceOS) || rawDeviceOS;\n        if (!deviceOS) {\n          continue;\n        }\n\n        const bothVersionsCanBeCoerced = semver.valid(deviceOS) && semver.valid(platformVersion);\n        const bothVersionsAreStrings = _.isString(deviceOS) && _.isString(platformVersion);\n        if (bothVersionsCanBeCoerced && deviceOS.version === platformVersion.version\n            || bothVersionsAreStrings && _.toLower(deviceOS) === _.toLower(platformVersion)) {\n          // Got an exact match - proceed immediately\n          udid = device.udid;\n          break;\n        } else if (!bothVersionsCanBeCoerced) {\n          // There is no point to check for partial match if either of version numbers is not coercible\n          continue;\n        }\n\n        if ((!_.includes(opts.platformVersion, '.') && platformVersion.major === deviceOS.major\n            || platformVersion.major === deviceOS.major && platformVersion.minor === deviceOS.minor)\n            // Got a partial match - make sure we consider the most recent\n            // device version available on the host system\n            && (partialMatchCandidate && semver.gt(deviceOS, _.values(partialMatchCandidate)[0])\n                || !partialMatchCandidate)) {\n          partialMatchCandidate = {[device.udid]: deviceOS};\n        }\n      }\n      if (!udid && partialMatchCandidate) {\n        udid = _.keys(partialMatchCandidate)[0];\n        await adb.setDeviceId(udid);\n      }\n\n      if (!udid) {\n        // we couldn't find anything! quit\n        logger.errorAndThrow(`Unable to find an active device or emulator ` +\n          `with OS ${opts.platformVersion}. The following are available: ` +\n          availDevices.join(', '));\n      }\n\n      emPort = adb.getPortFromEmulatorString(udid);\n    } else {\n      // a udid was not given, grab the first device we see\n      udid = devices[0].udid;\n      emPort = adb.getPortFromEmulatorString(udid);\n    }\n  }\n\n  logger.info(`Using device: ${udid}`);\n  return {udid, emPort};\n};\n\n// returns a new adb instance with deviceId set\nhelpers.createADB = async function createADB (opts = {}) {\n  const {udid, emPort} = opts;\n  const adb = await helpers.createBaseADB(opts);\n  adb.setDeviceId(udid);\n  if (emPort) {\n    adb.setEmulatorPort(emPort);\n  }\n\n  return adb;\n};\n\nhelpers.validatePackageActivityNames = function validatePackageActivityNames (opts) {\n  for (const key of ['appPackage', 'appActivity', 'appWaitPackage', 'appWaitActivity']) {\n    const name = opts[key];\n    if (!name) {\n      continue;\n    }\n\n    const match = /([^\\w.*,])+/.exec(name);\n    if (!match) {\n      continue;\n    }\n\n    logger.warn(`Capability '${key}' is expected to only include latin letters, digits, underscore, dot, comma and asterisk characters.`);\n    logger.warn(`Current value '${name}' has non-matching character at index ${match.index}: '${name.substring(0, match.index + 1)}'`);\n  }\n};\n\nhelpers.getLaunchInfo = async function getLaunchInfo (adb, opts) {\n  let {app, appPackage, appActivity, appWaitPackage, appWaitActivity} = opts;\n  if (!app) {\n    logger.warn('No app sent in, not parsing package/activity');\n    return;\n  }\n\n  this.validatePackageActivityNames(opts);\n\n  if (appPackage && appActivity) {\n    return;\n  }\n\n  logger.debug('Parsing package and activity from app manifest');\n  let {apkPackage, apkActivity} =\n    await adb.packageAndLaunchActivityFromManifest(app);\n  if (apkPackage && !appPackage) {\n    appPackage = apkPackage;\n  }\n  if (!appWaitPackage) {\n    appWaitPackage = appPackage;\n  }\n  if (apkActivity && !appActivity) {\n    appActivity = apkActivity;\n  }\n  if (!appWaitActivity) {\n    appWaitActivity = appActivity;\n  }\n  logger.debug(`Parsed package and activity are: ${apkPackage}/${apkActivity}`);\n  return {appPackage, appWaitPackage, appActivity, appWaitActivity};\n};\n\nhelpers.resetApp = async function resetApp (adb, opts = {}) {\n  const {\n    app,\n    appPackage,\n    fastReset,\n    fullReset,\n    androidInstallTimeout = PACKAGE_INSTALL_TIMEOUT_MS,\n    autoGrantPermissions,\n    allowTestPackages\n  } = opts;\n\n  if (!appPackage) {\n    throw new Error(\"'appPackage' option is required\");\n  }\n\n  const isInstalled = await adb.isAppInstalled(appPackage);\n\n  if (isInstalled) {\n    try {\n      await adb.forceStop(appPackage);\n    } catch (ign) {}\n    // fullReset has priority over fastReset\n    if (!fullReset && fastReset) {\n      const output = await adb.clear(appPackage);\n      if (_.isString(output) && output.toLowerCase().includes('failed')) {\n        throw new Error(`Cannot clear the application data of '${appPackage}'. Original error: ${output}`);\n      }\n      // executing `shell pm clear` resets previously assigned application permissions as well\n      if (autoGrantPermissions) {\n        try {\n          await adb.grantAllPermissions(appPackage);\n        } catch (error) {\n          logger.error(`Unable to grant permissions requested. Original error: ${error.message}`);\n        }\n      }\n      logger.debug(`Performed fast reset on the installed '${appPackage}' application (stop and clear)`);\n      return;\n    }\n  }\n\n  if (!app) {\n    throw new Error(`Either provide 'app' option to install '${appPackage}' or ` +\n      `consider setting 'noReset' to 'true' if '${appPackage}' is supposed to be preinstalled.`);\n  }\n\n  logger.debug(`Running full reset on '${appPackage}' (reinstall)`);\n  if (isInstalled) {\n    await adb.uninstallApk(appPackage);\n  }\n  await adb.install(app, {\n    grantPermissions: autoGrantPermissions,\n    timeout: androidInstallTimeout,\n    allowTestPackages,\n  });\n};\n\nhelpers.installApk = async function installApk (adb, opts = {}) {\n  const {\n    app,\n    appPackage,\n    fastReset,\n    fullReset,\n    androidInstallTimeout = PACKAGE_INSTALL_TIMEOUT_MS,\n    autoGrantPermissions,\n    allowTestPackages,\n    enforceAppInstall,\n  } = opts;\n\n  if (!app || !appPackage) {\n    throw new Error(\"'app' and 'appPackage' options are required\");\n  }\n\n  if (fullReset) {\n    await this.resetApp(adb, opts);\n    return;\n  }\n\n  const {\n    appState,\n    wasUninstalled\n  } = await adb.installOrUpgrade(app, appPackage, {\n    grantPermissions: autoGrantPermissions,\n    timeout: androidInstallTimeout,\n    allowTestPackages,\n    enforceCurrentBuild: enforceAppInstall,\n  });\n\n  // There is no need to reset the newly installed app\n  const isInstalledOverExistingApp = !wasUninstalled\n    && appState !== adb.APP_INSTALL_STATE.NOT_INSTALLED;\n  if (fastReset && isInstalledOverExistingApp) {\n    logger.info(`Performing fast reset on '${appPackage}'`);\n    await this.resetApp(adb, opts);\n  }\n};\n\n/**\n * Installs an array of apks\n * @param {ADB} adb Instance of Appium ADB object\n * @param {Object} opts Opts defined in driver.js\n */\nhelpers.installOtherApks = async function installOtherApks (otherApps, adb, opts) {\n  let {\n    androidInstallTimeout = PACKAGE_INSTALL_TIMEOUT_MS,\n    autoGrantPermissions,\n    allowTestPackages\n  } = opts;\n\n  // Install all of the APK's asynchronously\n  await B.all(otherApps.map((otherApp) => {\n    logger.debug(`Installing app: ${otherApp}`);\n    return adb.installOrUpgrade(otherApp, null, {\n      grantPermissions: autoGrantPermissions,\n      timeout: androidInstallTimeout,\n      allowTestPackages,\n    });\n  }));\n};\n\n/**\n * Uninstall an array of packages\n * @param {ADB} adb Instance of Appium ADB object\n * @param {Array<string>} appPackages An array of package names to uninstall. If this includes `'*'`, uninstall all of 3rd party apps\n * @param {Array<string>} filterPackages An array of packages does not uninstall when `*` is provided as `appPackages`\n */\nhelpers.uninstallOtherPackages = async function uninstallOtherPackages (adb, appPackages, filterPackages = []) {\n  if (appPackages.includes('*')) {\n    logger.debug('Uninstall third party packages');\n    appPackages = await this.getThirdPartyPackages(adb, filterPackages);\n  }\n\n  logger.debug(`Uninstalling packages: ${appPackages}`);\n  await B.all(appPackages.map((appPackage) => adb.uninstallApk(appPackage)));\n};\n\n/**\n * Get third party packages filtered with `filterPackages`\n * @param {ADB} adb Instance of Appium ADB object\n * @param {Array<string>} filterPackages An array of packages does not uninstall when `*` is provided as `appPackages`\n * @returns {Array<string>} An array of installed third pary packages\n */\nhelpers.getThirdPartyPackages = async function getThirdPartyPackages (adb, filterPackages = []) {\n  try {\n    const packagesString = await adb.shell(['pm', 'list', 'packages', '-3']);\n    const appPackagesArray = packagesString.trim().replace(/package:/g, '').split(EOL);\n    logger.debug(`'${appPackagesArray}' filtered with '${filterPackages}'`);\n    return _.difference(appPackagesArray, filterPackages);\n  } catch (err) {\n    logger.warn(`Unable to get packages with 'adb shell pm list packages -3': ${err.message}`);\n    return [];\n  }\n};\n\nhelpers.initUnicodeKeyboard = async function initUnicodeKeyboard (adb) {\n  logger.debug('Enabling Unicode keyboard support');\n\n  // get the default IME so we can return back to it later if we want\n  let defaultIME = await adb.defaultIME();\n\n  logger.debug(`Unsetting previous IME ${defaultIME}`);\n  const appiumIME = `${SETTINGS_HELPER_PKG_ID}/.UnicodeIME`;\n  logger.debug(`Setting IME to '${appiumIME}'`);\n  await adb.enableIME(appiumIME);\n  await adb.setIME(appiumIME);\n  return defaultIME;\n};\n\nhelpers.setMockLocationApp = async function setMockLocationApp (adb, app) {\n  try {\n    if (await adb.getApiLevel() < 23) {\n      await adb.shell(['settings', 'put', 'secure', 'mock_location', '1']);\n    } else {\n      await adb.shell(['appops', 'set', app, 'android:mock_location', 'allow']);\n    }\n  } catch (err) {\n    logger.warn(`Unable to set mock location for app '${app}': ${err.message}`);\n    return;\n  }\n  try {\n    let pkgIds = [];\n    if (await adb.fileExists(MOCK_APP_IDS_STORE)) {\n      try {\n        pkgIds = JSON.parse(await adb.shell(['cat', MOCK_APP_IDS_STORE]));\n      } catch (ign) {}\n    }\n    if (pkgIds.includes(app)) {\n      return;\n    }\n    pkgIds.push(app);\n    const tmpRoot = await tempDir.openDir();\n    const srcPath = path.posix.join(tmpRoot, path.posix.basename(MOCK_APP_IDS_STORE));\n    try {\n      await fs.writeFile(srcPath, JSON.stringify(pkgIds), 'utf8');\n      await adb.push(srcPath, MOCK_APP_IDS_STORE);\n    } finally {\n      await fs.rimraf(tmpRoot);\n    }\n  } catch (e) {\n    logger.warn(`Unable to persist mock location app id '${app}': ${e.message}`);\n  }\n};\n\nhelpers.resetMockLocation = async function resetMockLocation (adb) {\n  try {\n    if (await adb.getApiLevel() < 23) {\n      await adb.shell(['settings', 'put', 'secure', 'mock_location', '0']);\n      return;\n    }\n\n    const thirdPartyPkgIdsPromise = helpers.getThirdPartyPackages(adb);\n    let pkgIds = [];\n    if (await adb.fileExists(MOCK_APP_IDS_STORE)) {\n      try {\n        pkgIds = JSON.parse(await adb.shell(['cat', MOCK_APP_IDS_STORE]));\n      } catch (ign) {}\n    }\n    const thirdPartyPkgIds = await thirdPartyPkgIdsPromise;\n    // Only include currently installed packages\n    const resultPkgs = _.intersection(pkgIds, thirdPartyPkgIds);\n    if (_.size(resultPkgs) <= 1) {\n      await adb.shell(['appops', 'set', resultPkgs[0] ?? SETTINGS_HELPER_PKG_ID, 'android:mock_location', 'deny']);\n      return;\n    }\n\n    logger.debug(`Resetting mock_location permission for the following apps: ${resultPkgs}`);\n    await B.all(resultPkgs.map((pkgId) => (async () => {\n      try {\n        await adb.shell(['appops', 'set', pkgId, 'android:mock_location', 'deny']);\n      } catch (ign) {}\n    })()));\n  } catch (err) {\n    logger.warn(`Unable to reset mock location: ${err.message}`);\n  }\n};\n\nhelpers.installHelperApp = async function installHelperApp (adb, apkPath, packageId) {\n  // Sometimes adb push or adb instal take more time than expected to install an app\n  // e.g. https://github.com/appium/io.appium.settings/issues/40#issuecomment-476593174\n  await retryInterval(HELPER_APP_INSTALL_RETRIES, HELPER_APP_INSTALL_RETRY_DELAY_MS,\n    async function retryInstallHelperApp () {\n      await adb.installOrUpgrade(apkPath, packageId, {grantPermissions: true});\n    }\n  );\n};\n\n/**\n * Pushes and installs io.appium.settings app.\n * Throws an error if the setting app is required\n *\n * @param {Adb} adb - The adb module instance.\n * @param {Object} opts - Driver options dictionary.\n * @param {boolean} throwError [false] - Whether throw an error if Settings app fails to start\n * @throws {Error} If throwError is true and something happens in installation step\n */\nhelpers.pushSettingsApp = async function pushSettingsApp (adb, throwError = false, opts = {}) {\n  logger.debug('Pushing settings apk to device...');\n\n  try {\n    await helpers.installHelperApp(adb, settingsApkPath, SETTINGS_HELPER_PKG_ID, throwError);\n  } catch (err) {\n    if (throwError) {\n      throw err;\n    }\n\n    logger.warn(`Ignored error while installing '${settingsApkPath}': ` +\n                `'${err.message}'. Features that rely on this helper ` +\n                'require the apk such as toggle WiFi and getting location ' +\n                'will raise an error if you try to use them.');\n  }\n\n  // Reinstall would stop the settings helper process anyway, so\n  // there is no need to continue if the application is still running\n  if (await adb.processExists(SETTINGS_HELPER_PKG_ID)) {\n    logger.debug(`${SETTINGS_HELPER_PKG_ID} is already running. ` +\n      `There is no need to reset its permissions.`);\n    return;\n  }\n\n  const apiLevel = await adb.getApiLevel();\n  if (apiLevel >= 29) {\n    // https://github.com/appium/io.appium.settings#internal-audio--video-recording\n    try {\n      await adb.shell(['appops', 'set', SETTINGS_HELPER_PKG_ID, 'PROJECT_MEDIA', 'allow']);\n    } catch (err) {\n      logger.debug(err.message);\n    }\n    try {\n      await adb.shell(['cmd', 'notification', 'allow_listener', SETTING_NOTIFICATIONS_LISTENER_SERVICE]);\n    } catch (err) {\n      logger.debug(err.message);\n    }\n  }\n  if (apiLevel <= 23) { // Android 6- devices should have granted permissions\n    // https://github.com/appium/appium/pull/11640#issuecomment-438260477\n    const perms = ['SET_ANIMATION_SCALE', 'CHANGE_CONFIGURATION', 'ACCESS_FINE_LOCATION'];\n    logger.info(`Granting permissions ${perms} to '${SETTINGS_HELPER_PKG_ID}'`);\n    await adb.grantPermissions(SETTINGS_HELPER_PKG_ID, perms.map((x) => `android.permission.${x}`));\n  }\n\n  // launch io.appium.settings app due to settings failing to be set\n  // if the app is not launched prior to start the session on android 7+\n  // see https://github.com/appium/appium/issues/8957\n  try {\n    await adb.requireRunningSettingsApp({\n      timeout: helpers.isEmulator(adb, opts) ? 30000 : 5000\n    });\n  } catch (err) {\n    logger.debug(err);\n    if (throwError) {\n      throw err;\n    }\n  }\n};\n\n/**\n * Extracts string.xml and converts it to string.json and pushes\n * it to /data/local/tmp/string.json on for use of bootstrap\n * If app is not present to extract string.xml it deletes remote strings.json\n * If app does not have strings.xml we push an empty json object to remote\n *\n * @param {?string} language - Language abbreviation, for example 'fr'. The default language\n * is used if this argument is not defined.\n * @param {Object} adb - The adb module instance.\n * @param {Object} opts - Driver options dictionary.\n * @returns {Object} The dictionary, where string resource identifiers are keys\n * along with their corresponding values for the given language or an empty object\n * if no matching resources were extracted.\n */\nhelpers.pushStrings = async function pushStrings (language, adb, opts) {\n  const remoteDir = '/data/local/tmp';\n  const stringsJson = 'strings.json';\n  const remoteFile = path.posix.resolve(remoteDir, stringsJson);\n\n  // clean up remote string.json if present\n  await adb.rimraf(remoteFile);\n\n  let app;\n  try {\n    app = opts.app || await adb.pullApk(opts.appPackage, opts.tmpDir);\n  } catch (err) {\n    logger.info(`Failed to pull an apk from '${opts.appPackage}' to '${opts.tmpDir}'. Original error: ${err.message}`);\n  }\n\n  if (_.isEmpty(opts.appPackage) || !(await fs.exists(app))) {\n    logger.debug(`No app or package specified. Returning empty strings`);\n    return {};\n  }\n\n  const stringsTmpDir = path.resolve(opts.tmpDir, opts.appPackage);\n  try {\n    logger.debug('Extracting strings from apk', app, language, stringsTmpDir);\n    const {apkStrings, localPath} = await adb.extractStringsFromApk(app, language, stringsTmpDir);\n    await adb.push(localPath, remoteDir);\n    return apkStrings;\n  } catch (err) {\n    logger.warn(`Could not get strings, continuing anyway. Original error: ${err.message}`);\n    await adb.shell('echo', [`'{}' > ${remoteFile}`]);\n  } finally {\n    await fs.rimraf(stringsTmpDir);\n  }\n  return {};\n};\n\nhelpers.unlock = async function unlock (driver, adb, capabilities) {\n  if (!(await adb.isScreenLocked())) {\n    logger.info('Screen already unlocked, doing nothing');\n    return;\n  }\n\n  logger.debug('Screen is locked, trying to unlock');\n  if (!capabilities.unlockType && !capabilities.unlockKey) {\n    logger.info(`Neither 'unlockType' nor 'unlockKey' capability is provided. ` +\n      `Assuming the device is locked with a simple lock screen.`);\n    await adb.dismissKeyguard();\n    return;\n  }\n\n  const {\n    unlockType,\n    unlockKey,\n    unlockStrategy,\n    unlockSuccessTimeout,\n  } = unlocker.validateUnlockCapabilities(capabilities);\n  if (unlockKey && unlockType !== FINGERPRINT_UNLOCK\n      && (_.isNil(unlockStrategy) || _.toLower(unlockStrategy) === 'locksettings')\n      && await adb.isLockManagementSupported()) {\n    await unlocker.fastUnlock(adb, {\n      credential: unlockKey,\n      credentialType: toCredentialType(unlockType),\n    });\n  } else {\n    const unlockMethod = {\n      [PIN_UNLOCK]: unlocker.pinUnlock,\n      [PIN_UNLOCK_KEY_EVENT]: unlocker.pinUnlockWithKeyEvent,\n      [PASSWORD_UNLOCK]: unlocker.passwordUnlock,\n      [PATTERN_UNLOCK]: unlocker.patternUnlock,\n      [FINGERPRINT_UNLOCK]: unlocker.fingerprintUnlock,\n    }[unlockType];\n    await unlockMethod(adb, driver, capabilities);\n  }\n  await helpers.verifyUnlock(adb, unlockSuccessTimeout);\n};\n\nhelpers.verifyUnlock = async function verifyUnlock (adb, timeoutMs = null) {\n  try {\n    await waitForCondition(async () => !(await adb.isScreenLocked()), {\n      waitMs: timeoutMs ?? 2000,\n      intervalMs: 500,\n    });\n  } catch (ign) {\n    throw new Error('The device has failed to be unlocked');\n  }\n  logger.info('The device has been successfully unlocked');\n};\n\nhelpers.initDevice = async function initDevice (adb, opts) {\n  const {\n    skipDeviceInitialization,\n    locale,\n    language,\n    localeScript,\n    unicodeKeyboard,\n    disableWindowAnimation,\n    skipUnlock,\n    mockLocationApp,\n    skipLogcatCapture,\n    logcatFormat,\n    logcatFilterSpecs,\n  } = opts;\n\n  if (skipDeviceInitialization) {\n    logger.info(`'skipDeviceInitialization' is set. Skipping device initialization.`);\n  } else {\n    if (helpers.isEmulator(adb, opts)) {\n      // Check if the device wake up only for an emulator.\n      // It takes 1 second or so even when the device is already awake in a real device.\n      await adb.waitForDevice();\n    }\n    // pushSettingsApp required before calling ensureDeviceLocale for API Level 24+\n\n    // Some feature such as location/wifi are not necessary for all users,\n    // but they require the settings app. So, try to configure it while Appium\n    // does not throw error even if they fail.\n    const shouldThrowError = language\n      || locale\n      || localeScript\n      || unicodeKeyboard\n      || disableWindowAnimation\n      || !skipUnlock;\n    await helpers.pushSettingsApp(adb, shouldThrowError, opts);\n  }\n\n  if (!helpers.isEmulator(adb, opts)) {\n    if (mockLocationApp || _.isUndefined(mockLocationApp)) {\n      await helpers.setMockLocationApp(adb, mockLocationApp || SETTINGS_HELPER_PKG_ID);\n    } else {\n      await helpers.resetMockLocation(adb);\n    }\n  }\n\n  if (language || locale) {\n    await helpers.ensureDeviceLocale(adb, language, locale, localeScript);\n  }\n\n  if (skipLogcatCapture) {\n    logger.info(`'skipLogcatCapture' is set. Skipping starting logcat capture.`);\n  } else {\n    await adb.startLogcat({\n      format: logcatFormat,\n      filterSpecs: logcatFilterSpecs,\n    });\n  }\n\n  if (unicodeKeyboard) {\n    return await helpers.initUnicodeKeyboard(adb);\n  }\n};\n\nhelpers.removeNullProperties = function removeNullProperties (obj) {\n  for (let key of _.keys(obj)) {\n    if (_.isNull(obj[key]) || _.isUndefined(obj[key])) {\n      delete obj[key];\n    }\n  }\n};\n\nhelpers.truncateDecimals = function truncateDecimals (number, digits) {\n  let multiplier = Math.pow(10, digits),\n      adjustedNum = number * multiplier,\n      truncatedNum = Math[adjustedNum < 0 ? 'ceil' : 'floor'](adjustedNum);\n\n  return truncatedNum / multiplier;\n};\n\nhelpers.isChromeBrowser = function isChromeBrowser (browser) {\n  return _.includes(Object.keys(CHROME_BROWSER_PACKAGE_ACTIVITY), (browser || '').toLowerCase());\n};\n\nhelpers.getChromePkg = function getChromePkg (browser) {\n  return CHROME_BROWSER_PACKAGE_ACTIVITY[browser.toLowerCase()] || CHROME_BROWSER_PACKAGE_ACTIVITY.default;\n};\n\nhelpers.removeAllSessionWebSocketHandlers = async function removeAllSessionWebSocketHandlers (server, sessionId) {\n  if (!server || !_.isFunction(server.getWebSocketHandlers)) {\n    return;\n  }\n\n  const activeHandlers = await server.getWebSocketHandlers(sessionId);\n  for (const pathname of _.keys(activeHandlers)) {\n    await server.removeWebSocketHandler(pathname);\n  }\n};\n\n/**\n * Takes a desired capability and tries to JSON.parse it as an array,\n * and either returns the parsed array or a singleton array.\n *\n * @param {any} cap A desired capability\n */\nhelpers.parseArray = function parseArray (cap) {\n  let parsedCaps;\n  try {\n    parsedCaps = JSON.parse(cap);\n  } catch (ign) { }\n\n  if (_.isArray(parsedCaps)) {\n    return parsedCaps;\n  } else if (_.isString(cap)) {\n    return [cap];\n  }\n\n  throw new Error(`must provide a string or JSON Array; received ${cap}`);\n};\n\n/**\n * Validate desired capabilities. Returns true if capability is valid\n *\n * @param {*} cap A desired capability\n * @return {boolean} Returns true if the capability is valid\n * @throws {Error} If the caps has invalid capability\n */\nhelpers.validateDesiredCaps = function validateDesiredCaps (caps) {\n  if (caps.browserName) {\n    if (caps.app) {\n      // warn if the capabilities have both `app` and `browser, although this is common with selenium grid\n      logger.warn(`The desired capabilities should generally not include both an 'app' and a 'browserName'`);\n    }\n    if (caps.appPackage) {\n      logger.errorAndThrow(`The desired should not include both of an 'appPackage' and a 'browserName'`);\n    }\n  }\n\n  if (caps.uninstallOtherPackages) {\n    try {\n      this.parseArray(caps.uninstallOtherPackages);\n    } catch (e) {\n      logger.errorAndThrow(`Could not parse \"uninstallOtherPackages\" capability: ${e.message}`);\n    }\n  }\n\n  return true;\n};\n\n/**\n * Adjust the capabilities for a browser session\n *\n * @param {Object} caps - Current capabilities object\n * !!! The object is mutated by this method call !!!\n * @returns {Object} The same possibly mutated `opts` instance.\n * No mutation is happening is the current session if\n * appPackage/appActivity caps have already been provided.\n */\nhelpers.adjustBrowserSessionCaps = function adjustBrowserSessionCaps (caps = {}) {\n  const { browserName } = caps;\n  logger.info(`The current session is considered browser-based`);\n  logger.info(`Supported browser names: ${JSON.stringify(_.keys(CHROME_BROWSER_PACKAGE_ACTIVITY))}`);\n  if (caps.appPackage || caps.appActivity) {\n    logger.info(`Not overriding appPackage/appActivity capability values for '${browserName}' ` +\n      'because some of them have been already provided');\n    return caps;\n  }\n\n  const {pkg, activity} = this.getChromePkg(browserName);\n  caps.appPackage = pkg;\n  caps.appActivity = activity;\n  logger.info(`appPackage/appActivity capabilities have been automatically set to ${pkg}/${activity} ` +\n    `for '${browserName}'`);\n  logger.info(`Consider changing the browserName to the one from the list of supported browser names ` +\n    `or provide custom appPackage/appActivity capability values if the automatically assigned ones do ` +\n    `not make sense`);\n  return caps;\n};\n\n/**\n * Checks whether the current device under test is an emulator\n *\n * @param {ADB} adb - appium-adb instance\n * @param {Object} opts - driver options mapping\n * @returns {boolean} `true` if the device is an Android emulator\n */\nhelpers.isEmulator = function isEmulator (adb, opts) {\n  const possibleNames = [opts.udid, adb?.curDeviceId];\n  return !!opts.avd || possibleNames.some((x) => EMULATOR_PATTERN.test(x));\n};\n\nhelpers.bootstrap = Bootstrap;\nhelpers.unlocker = unlocker;\n\nexport { helpers, SETTINGS_HELPER_PKG_ID, APP_STATE, prepareAvdArgs, ensureNetworkSpeed };\nexport default helpers;\n"],"mappings":";;;;;;;;;;;AAAA,IAAAA,OAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,KAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AACA,IAAAG,OAAA,GAAAJ,sBAAA,CAAAC,OAAA;AACA,IAAAI,QAAA,GAAAJ,OAAA;AACA,IAAAK,SAAA,GAAAL,OAAA;AACA,IAAAM,UAAA,GAAAP,sBAAA,CAAAC,OAAA;AACA,IAAAO,SAAA,GAAAR,sBAAA,CAAAC,OAAA;AACA,IAAAQ,UAAA,GAAAT,sBAAA,CAAAC,OAAA;AACA,IAAAS,cAAA,GAAAC,uBAAA,CAAAV,OAAA;AAIA,IAAAW,GAAA,GAAAX,OAAA;AACA,IAAAY,OAAA,GAAAb,sBAAA,CAAAC,OAAA;AAA4B,SAAAa,yBAAAC,WAAA,eAAAC,OAAA,kCAAAC,iBAAA,OAAAD,OAAA,QAAAE,gBAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,WAAA,WAAAA,WAAA,GAAAG,gBAAA,GAAAD,iBAAA,KAAAF,WAAA;AAAA,SAAAJ,wBAAAQ,GAAA,EAAAJ,WAAA,SAAAA,WAAA,IAAAI,GAAA,IAAAA,GAAA,CAAAC,UAAA,WAAAD,GAAA,QAAAA,GAAA,oBAAAA,GAAA,wBAAAA,GAAA,4BAAAE,OAAA,EAAAF,GAAA,UAAAG,KAAA,GAAAR,wBAAA,CAAAC,WAAA,OAAAO,KAAA,IAAAA,KAAA,CAAAC,GAAA,CAAAJ,GAAA,YAAAG,KAAA,CAAAE,GAAA,CAAAL,GAAA,SAAAM,MAAA,WAAAC,qBAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,GAAA,IAAAX,GAAA,QAAAW,GAAA,kBAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAd,GAAA,EAAAW,GAAA,SAAAI,IAAA,GAAAR,qBAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAV,GAAA,EAAAW,GAAA,cAAAI,IAAA,KAAAA,IAAA,CAAAV,GAAA,IAAAU,IAAA,CAAAC,GAAA,KAAAR,MAAA,CAAAC,cAAA,CAAAH,MAAA,EAAAK,GAAA,EAAAI,IAAA,YAAAT,MAAA,CAAAK,GAAA,IAAAX,GAAA,CAAAW,GAAA,SAAAL,MAAA,CAAAJ,OAAA,GAAAF,GAAA,MAAAG,KAAA,IAAAA,KAAA,CAAAa,GAAA,CAAAhB,GAAA,EAAAM,MAAA,YAAAA,MAAA;AAE5B,MAAMW,kBAAkB,GAAG,gCAAgC;AAC3D,MAAMC,0BAA0B,GAAG,KAAK;AACxC,MAAMC,0BAA0B,GAAG,CAAC;AACpC,MAAMC,iCAAiC,GAAG,IAAI;AAE9C,MAAMC,+BAA+B,GAAG;EACtCC,MAAM,EAAE;IACNC,GAAG,EAAE,oBAAoB;IACzBC,QAAQ,EAAE;EACZ,CAAC;EACDC,QAAQ,EAAE;IACRF,GAAG,EAAE,2BAA2B;IAChCC,QAAQ,EAAE;EACZ,CAAC;EACDE,UAAU,EAAE;IACVH,GAAG,EAAE,iBAAiB;IACtBC,QAAQ,EAAE;EACZ,CAAC;EACDG,OAAO,EAAE;IACPJ,GAAG,EAAE,qBAAqB;IAC1BC,QAAQ,EAAE;EACZ,CAAC;EACD,kBAAkB,EAAE;IAClBD,GAAG,EAAE,qBAAqB;IAC1BC,QAAQ,EAAE;EACZ,CAAC;EACD,kBAAkB,EAAE;IAClBD,GAAG,EAAE,4BAA4B;IACjCC,QAAQ,EAAE;EACZ,CAAC;EACDtB,OAAO,EAAE;IACPqB,GAAG,EAAE,oBAAoB;IACzBC,QAAQ,EAAE;EACZ;AACF,CAAC;AACD,MAAMI,sBAAsB,GAAG,oBAAoB;AAACC,OAAA,CAAAD,sBAAA,GAAAA,sBAAA;AACpD,MAAME,sCAAsC,GAAI,GAAEF,sBAAuB,aAAY;AACrF,MAAMG,gBAAgB,GAAG,eAAe;AAGxC,MAAMC,SAAS,GAAGxB,MAAM,CAACyB,MAAM,CAAC;EAC9BC,aAAa,EAAE,CAAC;EAChBC,WAAW,EAAE,CAAC;EACdC,qBAAqB,EAAE,CAAC;EACxBC,qBAAqB,EAAE;AACzB,CAAC,CAAC;AAACR,OAAA,CAAAG,SAAA,GAAAA,SAAA;AAGH,SAASM,kBAAkBA,CAAEC,GAAG,EAAEC,YAAY,EAAE;EAC9C,IAAIC,eAAC,CAACC,MAAM,CAACH,GAAG,CAACI,aAAa,CAAC,CAACC,QAAQ,CAACJ,YAAY,CAAC,EAAE;IACtD,OAAOA,YAAY;EACrB;EACAK,eAAM,CAACC,IAAI,CAAE,8BAA6BN,YAAa,qBAAoBD,GAAG,CAACI,aAAa,CAACI,IAAK,IAAG,GAClG,qBAAoBN,eAAC,CAACC,MAAM,CAACH,GAAG,CAACI,aAAa,CAAE,EAAC,CAAC;EACrD,OAAOJ,GAAG,CAACI,aAAa,CAACI,IAAI;AAC/B;AAEA,SAASC,cAAcA,CAAET,GAAG,EAAEU,IAAI,EAAE;EAClC,MAAM;IACJT,YAAY;IACZU,UAAU;IACVC;EACF,CAAC,GAAGF,IAAI;EACR,MAAMG,MAAM,GAAG,EAAE;EACjB,IAAID,OAAO,EAAE;IACX,IAAIV,eAAC,CAACY,OAAO,CAACF,OAAO,CAAC,EAAE;MACtBC,MAAM,CAACE,IAAI,CAAC,GAAGH,OAAO,CAAC;IACzB,CAAC,MAAM;MACLC,MAAM,CAACE,IAAI,CAAC,GAAIC,aAAI,CAACC,UAAU,CAAE,GAAEL,OAAQ,EAAC,CAAE,CAAC;IACjD;EACF;EACA,IAAIX,YAAY,EAAE;IAChBY,MAAM,CAACE,IAAI,CAAC,WAAW,EAAEhB,kBAAkB,CAACC,GAAG,EAAEC,YAAY,CAAC,CAAC;EACjE;EACA,IAAIU,UAAU,EAAE;IACdE,MAAM,CAACE,IAAI,CAAC,YAAY,CAAC;EAC3B;EACA,OAAOF,MAAM;AACf;AAEA,SAASK,gBAAgBA,CAAEC,UAAU,EAAE;EACrC,MAAMN,MAAM,GAAG;IACb,CAACO,yBAAU,GAAG,KAAK;IACnB,CAACC,mCAAoB,GAAG,KAAK;IAC7B,CAACC,8BAAe,GAAG,UAAU;IAC7B,CAACC,6BAAc,GAAG;EACpB,CAAC,CAACJ,UAAU,CAAC;EACb,IAAIN,MAAM,EAAE;IACV,OAAOA,MAAM;EACf;EACA,MAAM,IAAIW,KAAK,CAAE,gBAAeL,UAAW,gBAAe,CAAC;AAC7D;AAGA,MAAMM,OAAO,GAAG,CAAC,CAAC;AAACnC,OAAA,CAAAmC,OAAA,GAAAA,OAAA;AAEnBA,OAAO,CAACC,aAAa,GAAG,eAAeA,aAAaA,CAAEhB,IAAI,GAAG,CAAC,CAAC,EAAE;EAG/D,MAAM;IACJiB,OAAO;IACPC,kBAAkB;IAClBC,aAAa;IACbC,sBAAsB;IACtBC,cAAc;IACdC,WAAW;IACXC,YAAY;IACZC,gBAAgB;IAChBC,QAAQ;IACRC,WAAW;IACXC,oBAAoB;IACpBC,iBAAiB;IACjBC,mBAAmB;IACnBC;EACF,CAAC,GAAG9B,IAAI;EACR,OAAO,MAAM+B,kBAAG,CAACC,SAAS,CAAC;IACzBf,OAAO;IACPC,kBAAkB;IAClBC,aAAa;IACbC,sBAAsB;IACtBC,cAAc;IACdC,WAAW;IACXC,YAAY;IACZC,gBAAgB;IAChBC,QAAQ;IACRC,WAAW;IACXC,oBAAoB;IACpBC,iBAAiB;IACjBC,mBAAmB;IACnBC;EACF,CAAC,CAAC;AACJ,CAAC;AAEDf,OAAO,CAACkB,eAAe,GAAG,eAAeA,eAAeA,CAAE3C,GAAG,EAAEU,IAAI,EAAE;EACnE,MAAM;IACJkC,GAAG;IACHC,MAAM,EAAEC,GAAG;IACXC,QAAQ;IACRC,MAAM,EAAEC,OAAO;IACfC,gBAAgB,EAAEC,aAAa;IAC/BC,eAAe,EAAEC;EACnB,CAAC,GAAG3C,IAAI;EACR,IAAI,CAACkC,GAAG,EAAE;IACR,MAAM,IAAIpB,KAAK,CAAC,oCAAoC,CAAC;EACvD;EAEA,MAAM8B,OAAO,GAAGV,GAAG,CAACW,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC;EACpC,IAAIC,iBAAiB,GAAG,IAAI;EAC5B,IAAI;IACF,MAAMxD,GAAG,CAACyD,sBAAsB,CAACH,OAAO,EAAE,IAAI,CAAC;EACjD,CAAC,CAAC,OAAOI,CAAC,EAAE;IACVpD,eAAM,CAACqD,KAAK,CAAE,aAAYL,OAAQ,qBAAoBI,CAAC,CAACE,OAAQ,EAAC,CAAC;IAClEJ,iBAAiB,GAAG,KAAK;EAC3B;EACA,MAAMK,IAAI,GAAGpD,cAAc,CAACT,GAAG,EAAEU,IAAI,CAAC;EACtC,IAAI8C,iBAAiB,EAAE;IACrB,IAAIK,IAAI,CAACxD,QAAQ,CAAC,YAAY,CAAC,EAAE;MAC/BC,eAAM,CAACqD,KAAK,CAAE,YAAWL,OAAQ,0CAAyC,CAAC;MAC3E,MAAMtD,GAAG,CAAC8D,YAAY,CAACR,OAAO,CAAC;IACjC,CAAC,MAAM;MACLhD,eAAM,CAACqD,KAAK,CAAC,kDAAkD,CAAC;MAChE;IACF;EACF;EACA,MAAM3D,GAAG,CAAC+D,SAAS,CAACnB,GAAG,EAAE;IACvBiB,IAAI;IACJf,GAAG;IACHC,QAAQ;IACRE,OAAO;IACPE,aAAa;IACbE;EACF,CAAC,CAAC;AACJ,CAAC;AAcD5B,OAAO,CAACuC,kBAAkB,GAAG,eAAeA,kBAAkBA,CAAEhE,GAAG,EAAE+C,QAAQ,EAAEE,OAAO,EAAEgB,MAAM,GAAG,IAAI,EAAE;EACrG,IAAI,CAAC/D,eAAC,CAACgE,QAAQ,CAACnB,QAAQ,CAAC,IAAI,CAAC7C,eAAC,CAACgE,QAAQ,CAACjB,OAAO,CAAC,EAAE;IACjD3C,eAAM,CAACC,IAAI,CAAE,wDAAuD,CAAC;IACrED,eAAM,CAACC,IAAI,CAAE,kBAAiBwC,QAAS,mBAAkBE,OAAQ,GAAE,CAAC;IACpE;EACF;EAEA,MAAMjD,GAAG,CAACmE,wBAAwB,CAACpB,QAAQ,EAAEE,OAAO,EAAEgB,MAAM,CAAC;EAE7D,IAAI,EAAC,MAAMjE,GAAG,CAACoE,mBAAmB,CAACrB,QAAQ,EAAEE,OAAO,EAAEgB,MAAM,CAAC,GAAE;IAC7D,MAAML,OAAO,GAAGK,MAAM,GAAI,aAAYlB,QAAS,cAAaE,OAAQ,gBAAegB,MAAO,EAAC,GAAI,aAAYlB,QAAS,iBAAgBE,OAAQ,EAAC;IAC7I,MAAM,IAAIzB,KAAK,CAAE,iBAAgBoC,OAAQ,EAAC,CAAC;EAC7C;AACF,CAAC;AAEDnC,OAAO,CAAC4C,qBAAqB,GAAG,eAAeA,qBAAqBA,CAAE3D,IAAI,GAAG,CAAC,CAAC,EAAE;EAK/E,MAAMV,GAAG,GAAG,MAAMyB,OAAO,CAACC,aAAa,CAAChB,IAAI,CAAC;EAC7C,IAAI4D,IAAI,GAAG5D,IAAI,CAAC4D,IAAI;EACpB,IAAIC,MAAM,GAAG,IAAI;EAGjB,IAAI7D,IAAI,CAACkC,GAAG,EAAE;IACZ,MAAMnB,OAAO,CAACkB,eAAe,CAAC3C,GAAG,EAAEU,IAAI,CAAC;IACxC4D,IAAI,GAAGtE,GAAG,CAACwE,WAAW;IACtBD,MAAM,GAAGvE,GAAG,CAACyE,YAAY;EAC3B,CAAC,MAAM;IAELnE,eAAM,CAACoE,IAAI,CAAC,wBAAwB,CAAC;IACrC,IAAIC,OAAO,GAAG,MAAM3E,GAAG,CAAC4E,mBAAmB,CAAC,CAAC;IAG7C,IAAIN,IAAI,EAAE;MACR,IAAI,CAACpE,eAAC,CAACG,QAAQ,CAACH,eAAC,CAAC2E,GAAG,CAACF,OAAO,EAAE,MAAM,CAAC,EAAEL,IAAI,CAAC,EAAE;QAC7ChE,eAAM,CAACwE,aAAa,CAAE,UAASR,IAAK,2CAA0C,CAAC;MACjF;MACAC,MAAM,GAAGvE,GAAG,CAAC+E,yBAAyB,CAACT,IAAI,CAAC;IAC9C,CAAC,MAAM,IAAI5D,IAAI,CAACsE,eAAe,EAAE;MAC/BtE,IAAI,CAACsE,eAAe,GAAI,GAAEtE,IAAI,CAACsE,eAAgB,EAAC,CAACC,IAAI,CAAC,CAAC;MAGvD,MAAMD,eAAe,GAAGE,eAAM,CAACC,MAAM,CAACzE,IAAI,CAACsE,eAAe,CAAC,IAAItE,IAAI,CAACsE,eAAe;MACnF1E,eAAM,CAACoE,IAAI,CAAE,sCAAqCM,eAAgB,GAAE,CAAC;MAIrE,MAAMI,YAAY,GAAG,EAAE;MACvB,IAAIC,qBAAqB,GAAG,IAAI;MAEhC,KAAK,MAAMC,MAAM,IAAIX,OAAO,EAAE;QAE5B,MAAM3E,GAAG,CAACuF,WAAW,CAACD,MAAM,CAAChB,IAAI,CAAC;QAClC,MAAMkB,WAAW,GAAG,MAAMxF,GAAG,CAACyF,kBAAkB,CAAC,CAAC;QAGlDL,YAAY,CAACrE,IAAI,CAAE,GAAEuE,MAAM,CAAChB,IAAK,KAAIkB,WAAY,GAAE,CAAC;QACpD,MAAME,QAAQ,GAAGR,eAAM,CAACC,MAAM,CAACK,WAAW,CAAC,IAAIA,WAAW;QAC1D,IAAI,CAACE,QAAQ,EAAE;UACb;QACF;QAEA,MAAMC,wBAAwB,GAAGT,eAAM,CAACU,KAAK,CAACF,QAAQ,CAAC,IAAIR,eAAM,CAACU,KAAK,CAACZ,eAAe,CAAC;QACxF,MAAMa,sBAAsB,GAAG3F,eAAC,CAACgE,QAAQ,CAACwB,QAAQ,CAAC,IAAIxF,eAAC,CAACgE,QAAQ,CAACc,eAAe,CAAC;QAClF,IAAIW,wBAAwB,IAAID,QAAQ,CAACI,OAAO,KAAKd,eAAe,CAACc,OAAO,IACrED,sBAAsB,IAAI3F,eAAC,CAAC6F,OAAO,CAACL,QAAQ,CAAC,KAAKxF,eAAC,CAAC6F,OAAO,CAACf,eAAe,CAAC,EAAE;UAEnFV,IAAI,GAAGgB,MAAM,CAAChB,IAAI;UAClB;QACF,CAAC,MAAM,IAAI,CAACqB,wBAAwB,EAAE;UAEpC;QACF;QAEA,IAAI,CAAC,CAACzF,eAAC,CAACG,QAAQ,CAACK,IAAI,CAACsE,eAAe,EAAE,GAAG,CAAC,IAAIA,eAAe,CAACgB,KAAK,KAAKN,QAAQ,CAACM,KAAK,IAChFhB,eAAe,CAACgB,KAAK,KAAKN,QAAQ,CAACM,KAAK,IAAIhB,eAAe,CAACiB,KAAK,KAAKP,QAAQ,CAACO,KAAK,MAGnFZ,qBAAqB,IAAIH,eAAM,CAACgB,EAAE,CAACR,QAAQ,EAAExF,eAAC,CAACC,MAAM,CAACkF,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,IAC7E,CAACA,qBAAqB,CAAC,EAAE;UAClCA,qBAAqB,GAAG;YAAC,CAACC,MAAM,CAAChB,IAAI,GAAGoB;UAAQ,CAAC;QACnD;MACF;MACA,IAAI,CAACpB,IAAI,IAAIe,qBAAqB,EAAE;QAClCf,IAAI,GAAGpE,eAAC,CAACiG,IAAI,CAACd,qBAAqB,CAAC,CAAC,CAAC,CAAC;QACvC,MAAMrF,GAAG,CAACuF,WAAW,CAACjB,IAAI,CAAC;MAC7B;MAEA,IAAI,CAACA,IAAI,EAAE;QAEThE,eAAM,CAACwE,aAAa,CAAE,8CAA6C,GAChE,WAAUpE,IAAI,CAACsE,eAAgB,iCAAgC,GAChEI,YAAY,CAACgB,IAAI,CAAC,IAAI,CAAC,CAAC;MAC5B;MAEA7B,MAAM,GAAGvE,GAAG,CAAC+E,yBAAyB,CAACT,IAAI,CAAC;IAC9C,CAAC,MAAM;MAELA,IAAI,GAAGK,OAAO,CAAC,CAAC,CAAC,CAACL,IAAI;MACtBC,MAAM,GAAGvE,GAAG,CAAC+E,yBAAyB,CAACT,IAAI,CAAC;IAC9C;EACF;EAEAhE,eAAM,CAACoE,IAAI,CAAE,iBAAgBJ,IAAK,EAAC,CAAC;EACpC,OAAO;IAACA,IAAI;IAAEC;EAAM,CAAC;AACvB,CAAC;AAGD9C,OAAO,CAACiB,SAAS,GAAG,eAAeA,SAASA,CAAEhC,IAAI,GAAG,CAAC,CAAC,EAAE;EACvD,MAAM;IAAC4D,IAAI;IAAEC;EAAM,CAAC,GAAG7D,IAAI;EAC3B,MAAMV,GAAG,GAAG,MAAMyB,OAAO,CAACC,aAAa,CAAChB,IAAI,CAAC;EAC7CV,GAAG,CAACuF,WAAW,CAACjB,IAAI,CAAC;EACrB,IAAIC,MAAM,EAAE;IACVvE,GAAG,CAACqG,eAAe,CAAC9B,MAAM,CAAC;EAC7B;EAEA,OAAOvE,GAAG;AACZ,CAAC;AAEDyB,OAAO,CAAC6E,4BAA4B,GAAG,SAASA,4BAA4BA,CAAE5F,IAAI,EAAE;EAClF,KAAK,MAAMtC,GAAG,IAAI,CAAC,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,iBAAiB,CAAC,EAAE;IACpF,MAAMmI,IAAI,GAAG7F,IAAI,CAACtC,GAAG,CAAC;IACtB,IAAI,CAACmI,IAAI,EAAE;MACT;IACF;IAEA,MAAMC,KAAK,GAAG,aAAa,CAACC,IAAI,CAACF,IAAI,CAAC;IACtC,IAAI,CAACC,KAAK,EAAE;MACV;IACF;IAEAlG,eAAM,CAACC,IAAI,CAAE,eAAcnC,GAAI,sGAAqG,CAAC;IACrIkC,eAAM,CAACC,IAAI,CAAE,kBAAiBgG,IAAK,yCAAwCC,KAAK,CAACE,KAAM,MAAKH,IAAI,CAACI,SAAS,CAAC,CAAC,EAAEH,KAAK,CAACE,KAAK,GAAG,CAAC,CAAE,GAAE,CAAC;EACpI;AACF,CAAC;AAEDjF,OAAO,CAACmF,aAAa,GAAG,eAAeA,aAAaA,CAAE5G,GAAG,EAAEU,IAAI,EAAE;EAC/D,IAAI;IAACmG,GAAG;IAAEC,UAAU;IAAEC,WAAW;IAAEC,cAAc;IAAEC;EAAe,CAAC,GAAGvG,IAAI;EAC1E,IAAI,CAACmG,GAAG,EAAE;IACRvG,eAAM,CAACC,IAAI,CAAC,8CAA8C,CAAC;IAC3D;EACF;EAEA,IAAI,CAAC+F,4BAA4B,CAAC5F,IAAI,CAAC;EAEvC,IAAIoG,UAAU,IAAIC,WAAW,EAAE;IAC7B;EACF;EAEAzG,eAAM,CAACqD,KAAK,CAAC,gDAAgD,CAAC;EAC9D,IAAI;IAACuD,UAAU;IAAEC;EAAW,CAAC,GAC3B,MAAMnH,GAAG,CAACoH,oCAAoC,CAACP,GAAG,CAAC;EACrD,IAAIK,UAAU,IAAI,CAACJ,UAAU,EAAE;IAC7BA,UAAU,GAAGI,UAAU;EACzB;EACA,IAAI,CAACF,cAAc,EAAE;IACnBA,cAAc,GAAGF,UAAU;EAC7B;EACA,IAAIK,WAAW,IAAI,CAACJ,WAAW,EAAE;IAC/BA,WAAW,GAAGI,WAAW;EAC3B;EACA,IAAI,CAACF,eAAe,EAAE;IACpBA,eAAe,GAAGF,WAAW;EAC/B;EACAzG,eAAM,CAACqD,KAAK,CAAE,oCAAmCuD,UAAW,IAAGC,WAAY,EAAC,CAAC;EAC7E,OAAO;IAACL,UAAU;IAAEE,cAAc;IAAED,WAAW;IAAEE;EAAe,CAAC;AACnE,CAAC;AAEDxF,OAAO,CAAC4F,QAAQ,GAAG,eAAeA,QAAQA,CAAErH,GAAG,EAAEU,IAAI,GAAG,CAAC,CAAC,EAAE;EAC1D,MAAM;IACJmG,GAAG;IACHC,UAAU;IACVQ,SAAS;IACTC,SAAS;IACTC,qBAAqB,GAAG7I,0BAA0B;IAClD8I,oBAAoB;IACpBC;EACF,CAAC,GAAGhH,IAAI;EAER,IAAI,CAACoG,UAAU,EAAE;IACf,MAAM,IAAItF,KAAK,CAAC,iCAAiC,CAAC;EACpD;EAEA,MAAMmG,WAAW,GAAG,MAAM3H,GAAG,CAAC4H,cAAc,CAACd,UAAU,CAAC;EAExD,IAAIa,WAAW,EAAE;IACf,IAAI;MACF,MAAM3H,GAAG,CAAC6H,SAAS,CAACf,UAAU,CAAC;IACjC,CAAC,CAAC,OAAOgB,GAAG,EAAE,CAAC;IAEf,IAAI,CAACP,SAAS,IAAID,SAAS,EAAE;MAC3B,MAAMS,MAAM,GAAG,MAAM/H,GAAG,CAACgI,KAAK,CAAClB,UAAU,CAAC;MAC1C,IAAI5G,eAAC,CAACgE,QAAQ,CAAC6D,MAAM,CAAC,IAAIA,MAAM,CAACE,WAAW,CAAC,CAAC,CAAC5H,QAAQ,CAAC,QAAQ,CAAC,EAAE;QACjE,MAAM,IAAImB,KAAK,CAAE,yCAAwCsF,UAAW,sBAAqBiB,MAAO,EAAC,CAAC;MACpG;MAEA,IAAIN,oBAAoB,EAAE;QACxB,IAAI;UACF,MAAMzH,GAAG,CAACkI,mBAAmB,CAACpB,UAAU,CAAC;QAC3C,CAAC,CAAC,OAAOqB,KAAK,EAAE;UACd7H,eAAM,CAAC6H,KAAK,CAAE,0DAAyDA,KAAK,CAACvE,OAAQ,EAAC,CAAC;QACzF;MACF;MACAtD,eAAM,CAACqD,KAAK,CAAE,0CAAyCmD,UAAW,gCAA+B,CAAC;MAClG;IACF;EACF;EAEA,IAAI,CAACD,GAAG,EAAE;IACR,MAAM,IAAIrF,KAAK,CAAE,2CAA0CsF,UAAW,OAAM,GACzE,4CAA2CA,UAAW,mCAAkC,CAAC;EAC9F;EAEAxG,eAAM,CAACqD,KAAK,CAAE,0BAAyBmD,UAAW,eAAc,CAAC;EACjE,IAAIa,WAAW,EAAE;IACf,MAAM3H,GAAG,CAACoI,YAAY,CAACtB,UAAU,CAAC;EACpC;EACA,MAAM9G,GAAG,CAACqI,OAAO,CAACxB,GAAG,EAAE;IACrByB,gBAAgB,EAAEb,oBAAoB;IACtCc,OAAO,EAAEf,qBAAqB;IAC9BE;EACF,CAAC,CAAC;AACJ,CAAC;AAEDjG,OAAO,CAAC+G,UAAU,GAAG,eAAeA,UAAUA,CAAExI,GAAG,EAAEU,IAAI,GAAG,CAAC,CAAC,EAAE;EAC9D,MAAM;IACJmG,GAAG;IACHC,UAAU;IACVQ,SAAS;IACTC,SAAS;IACTC,qBAAqB,GAAG7I,0BAA0B;IAClD8I,oBAAoB;IACpBC,iBAAiB;IACjBe;EACF,CAAC,GAAG/H,IAAI;EAER,IAAI,CAACmG,GAAG,IAAI,CAACC,UAAU,EAAE;IACvB,MAAM,IAAItF,KAAK,CAAC,6CAA6C,CAAC;EAChE;EAEA,IAAI+F,SAAS,EAAE;IACb,MAAM,IAAI,CAACF,QAAQ,CAACrH,GAAG,EAAEU,IAAI,CAAC;IAC9B;EACF;EAEA,MAAM;IACJgI,QAAQ;IACRC;EACF,CAAC,GAAG,MAAM3I,GAAG,CAAC4I,gBAAgB,CAAC/B,GAAG,EAAEC,UAAU,EAAE;IAC9CwB,gBAAgB,EAAEb,oBAAoB;IACtCc,OAAO,EAAEf,qBAAqB;IAC9BE,iBAAiB;IACjBmB,mBAAmB,EAAEJ;EACvB,CAAC,CAAC;EAGF,MAAMK,0BAA0B,GAAG,CAACH,cAAc,IAC7CD,QAAQ,KAAK1I,GAAG,CAAC+I,iBAAiB,CAACpJ,aAAa;EACrD,IAAI2H,SAAS,IAAIwB,0BAA0B,EAAE;IAC3CxI,eAAM,CAACoE,IAAI,CAAE,6BAA4BoC,UAAW,GAAE,CAAC;IACvD,MAAM,IAAI,CAACO,QAAQ,CAACrH,GAAG,EAAEU,IAAI,CAAC;EAChC;AACF,CAAC;AAODe,OAAO,CAACuH,gBAAgB,GAAG,eAAeA,gBAAgBA,CAAEC,SAAS,EAAEjJ,GAAG,EAAEU,IAAI,EAAE;EAChF,IAAI;IACF8G,qBAAqB,GAAG7I,0BAA0B;IAClD8I,oBAAoB;IACpBC;EACF,CAAC,GAAGhH,IAAI;EAGR,MAAMwI,iBAAC,CAACC,GAAG,CAACF,SAAS,CAACpE,GAAG,CAAEuE,QAAQ,IAAK;IACtC9I,eAAM,CAACqD,KAAK,CAAE,mBAAkByF,QAAS,EAAC,CAAC;IAC3C,OAAOpJ,GAAG,CAAC4I,gBAAgB,CAACQ,QAAQ,EAAE,IAAI,EAAE;MAC1Cd,gBAAgB,EAAEb,oBAAoB;MACtCc,OAAO,EAAEf,qBAAqB;MAC9BE;IACF,CAAC,CAAC;EACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAQDjG,OAAO,CAAC4H,sBAAsB,GAAG,eAAeA,sBAAsBA,CAAErJ,GAAG,EAAEsJ,WAAW,EAAEC,cAAc,GAAG,EAAE,EAAE;EAC7G,IAAID,WAAW,CAACjJ,QAAQ,CAAC,GAAG,CAAC,EAAE;IAC7BC,eAAM,CAACqD,KAAK,CAAC,gCAAgC,CAAC;IAC9C2F,WAAW,GAAG,MAAM,IAAI,CAACE,qBAAqB,CAACxJ,GAAG,EAAEuJ,cAAc,CAAC;EACrE;EAEAjJ,eAAM,CAACqD,KAAK,CAAE,0BAAyB2F,WAAY,EAAC,CAAC;EACrD,MAAMJ,iBAAC,CAACC,GAAG,CAACG,WAAW,CAACzE,GAAG,CAAEiC,UAAU,IAAK9G,GAAG,CAACoI,YAAY,CAACtB,UAAU,CAAC,CAAC,CAAC;AAC5E,CAAC;AAQDrF,OAAO,CAAC+H,qBAAqB,GAAG,eAAeA,qBAAqBA,CAAExJ,GAAG,EAAEuJ,cAAc,GAAG,EAAE,EAAE;EAC9F,IAAI;IACF,MAAME,cAAc,GAAG,MAAMzJ,GAAG,CAAC0J,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;IACxE,MAAMC,gBAAgB,GAAGF,cAAc,CAACxE,IAAI,CAAC,CAAC,CAAC1B,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAACqG,KAAK,CAACC,OAAG,CAAC;IAClFvJ,eAAM,CAACqD,KAAK,CAAE,IAAGgG,gBAAiB,oBAAmBJ,cAAe,GAAE,CAAC;IACvE,OAAOrJ,eAAC,CAAC4J,UAAU,CAACH,gBAAgB,EAAEJ,cAAc,CAAC;EACvD,CAAC,CAAC,OAAOQ,GAAG,EAAE;IACZzJ,eAAM,CAACC,IAAI,CAAE,gEAA+DwJ,GAAG,CAACnG,OAAQ,EAAC,CAAC;IAC1F,OAAO,EAAE;EACX;AACF,CAAC;AAEDnC,OAAO,CAACuI,mBAAmB,GAAG,eAAeA,mBAAmBA,CAAEhK,GAAG,EAAE;EACrEM,eAAM,CAACqD,KAAK,CAAC,mCAAmC,CAAC;EAGjD,IAAIsG,UAAU,GAAG,MAAMjK,GAAG,CAACiK,UAAU,CAAC,CAAC;EAEvC3J,eAAM,CAACqD,KAAK,CAAE,0BAAyBsG,UAAW,EAAC,CAAC;EACpD,MAAMC,SAAS,GAAI,GAAE7K,sBAAuB,cAAa;EACzDiB,eAAM,CAACqD,KAAK,CAAE,mBAAkBuG,SAAU,GAAE,CAAC;EAC7C,MAAMlK,GAAG,CAACmK,SAAS,CAACD,SAAS,CAAC;EAC9B,MAAMlK,GAAG,CAACoK,MAAM,CAACF,SAAS,CAAC;EAC3B,OAAOD,UAAU;AACnB,CAAC;AAEDxI,OAAO,CAAC4I,kBAAkB,GAAG,eAAeA,kBAAkBA,CAAErK,GAAG,EAAE6G,GAAG,EAAE;EACxE,IAAI;IACF,IAAI,OAAM7G,GAAG,CAACsK,WAAW,CAAC,CAAC,IAAG,EAAE,EAAE;MAChC,MAAMtK,GAAG,CAAC0J,KAAK,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,GAAG,CAAC,CAAC;IACtE,CAAC,MAAM;MACL,MAAM1J,GAAG,CAAC0J,KAAK,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE7C,GAAG,EAAE,uBAAuB,EAAE,OAAO,CAAC,CAAC;IAC3E;EACF,CAAC,CAAC,OAAOkD,GAAG,EAAE;IACZzJ,eAAM,CAACC,IAAI,CAAE,wCAAuCsG,GAAI,MAAKkD,GAAG,CAACnG,OAAQ,EAAC,CAAC;IAC3E;EACF;EACA,IAAI;IACF,IAAI2G,MAAM,GAAG,EAAE;IACf,IAAI,MAAMvK,GAAG,CAACwK,UAAU,CAAC9L,kBAAkB,CAAC,EAAE;MAC5C,IAAI;QACF6L,MAAM,GAAGE,IAAI,CAACC,KAAK,CAAC,MAAM1K,GAAG,CAAC0J,KAAK,CAAC,CAAC,KAAK,EAAEhL,kBAAkB,CAAC,CAAC,CAAC;MACnE,CAAC,CAAC,OAAOoJ,GAAG,EAAE,CAAC;IACjB;IACA,IAAIyC,MAAM,CAAClK,QAAQ,CAACwG,GAAG,CAAC,EAAE;MACxB;IACF;IACA0D,MAAM,CAACxJ,IAAI,CAAC8F,GAAG,CAAC;IAChB,MAAM8D,OAAO,GAAG,MAAMC,gBAAO,CAACC,OAAO,CAAC,CAAC;IACvC,MAAMC,OAAO,GAAGC,aAAI,CAACC,KAAK,CAAC5E,IAAI,CAACuE,OAAO,EAAEI,aAAI,CAACC,KAAK,CAACC,QAAQ,CAACvM,kBAAkB,CAAC,CAAC;IACjF,IAAI;MACF,MAAMwM,WAAE,CAACC,SAAS,CAACL,OAAO,EAAEL,IAAI,CAACW,SAAS,CAACb,MAAM,CAAC,EAAE,MAAM,CAAC;MAC3D,MAAMvK,GAAG,CAACe,IAAI,CAAC+J,OAAO,EAAEpM,kBAAkB,CAAC;IAC7C,CAAC,SAAS;MACR,MAAMwM,WAAE,CAACG,MAAM,CAACV,OAAO,CAAC;IAC1B;EACF,CAAC,CAAC,OAAOjH,CAAC,EAAE;IACVpD,eAAM,CAACC,IAAI,CAAE,2CAA0CsG,GAAI,MAAKnD,CAAC,CAACE,OAAQ,EAAC,CAAC;EAC9E;AACF,CAAC;AAEDnC,OAAO,CAAC6J,iBAAiB,GAAG,eAAeA,iBAAiBA,CAAEtL,GAAG,EAAE;EACjE,IAAI;IACF,IAAI,OAAMA,GAAG,CAACsK,WAAW,CAAC,CAAC,IAAG,EAAE,EAAE;MAChC,MAAMtK,GAAG,CAAC0J,KAAK,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,GAAG,CAAC,CAAC;MACpE;IACF;IAEA,MAAM6B,uBAAuB,GAAG9J,OAAO,CAAC+H,qBAAqB,CAACxJ,GAAG,CAAC;IAClE,IAAIuK,MAAM,GAAG,EAAE;IACf,IAAI,MAAMvK,GAAG,CAACwK,UAAU,CAAC9L,kBAAkB,CAAC,EAAE;MAC5C,IAAI;QACF6L,MAAM,GAAGE,IAAI,CAACC,KAAK,CAAC,MAAM1K,GAAG,CAAC0J,KAAK,CAAC,CAAC,KAAK,EAAEhL,kBAAkB,CAAC,CAAC,CAAC;MACnE,CAAC,CAAC,OAAOoJ,GAAG,EAAE,CAAC;IACjB;IACA,MAAM0D,gBAAgB,GAAG,MAAMD,uBAAuB;IAEtD,MAAME,UAAU,GAAGvL,eAAC,CAACwL,YAAY,CAACnB,MAAM,EAAEiB,gBAAgB,CAAC;IAC3D,IAAItL,eAAC,CAACyL,IAAI,CAACF,UAAU,CAAC,IAAI,CAAC,EAAE;MAC3B,MAAMzL,GAAG,CAAC0J,KAAK,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE+B,UAAU,CAAC,CAAC,CAAC,IAAIpM,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,CAAC,CAAC;MAC5G;IACF;IAEAiB,eAAM,CAACqD,KAAK,CAAE,8DAA6D8H,UAAW,EAAC,CAAC;IACxF,MAAMvC,iBAAC,CAACC,GAAG,CAACsC,UAAU,CAAC5G,GAAG,CAAE+G,KAAK,IAAK,CAAC,YAAY;MACjD,IAAI;QACF,MAAM5L,GAAG,CAAC0J,KAAK,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAEkC,KAAK,EAAE,uBAAuB,EAAE,MAAM,CAAC,CAAC;MAC5E,CAAC,CAAC,OAAO9D,GAAG,EAAE,CAAC;IACjB,CAAC,EAAE,CAAC,CAAC,CAAC;EACR,CAAC,CAAC,OAAOiC,GAAG,EAAE;IACZzJ,eAAM,CAACC,IAAI,CAAE,kCAAiCwJ,GAAG,CAACnG,OAAQ,EAAC,CAAC;EAC9D;AACF,CAAC;AAEDnC,OAAO,CAACoK,gBAAgB,GAAG,eAAeA,gBAAgBA,CAAE7L,GAAG,EAAE8L,OAAO,EAAEC,SAAS,EAAE;EAGnF,MAAM,IAAAC,uBAAa,EAACpN,0BAA0B,EAAEC,iCAAiC,EAC/E,eAAeoN,qBAAqBA,CAAA,EAAI;IACtC,MAAMjM,GAAG,CAAC4I,gBAAgB,CAACkD,OAAO,EAAEC,SAAS,EAAE;MAACzD,gBAAgB,EAAE;IAAI,CAAC,CAAC;EAC1E,CACF,CAAC;AACH,CAAC;AAWD7G,OAAO,CAACyK,eAAe,GAAG,eAAeA,eAAeA,CAAElM,GAAG,EAAEmM,UAAU,GAAG,KAAK,EAAEzL,IAAI,GAAG,CAAC,CAAC,EAAE;EAC5FJ,eAAM,CAACqD,KAAK,CAAC,mCAAmC,CAAC;EAEjD,IAAI;IACF,MAAMlC,OAAO,CAACoK,gBAAgB,CAAC7L,GAAG,EAAEoM,cAAe,EAAE/M,sBAAsB,EAAE8M,UAAU,CAAC;EAC1F,CAAC,CAAC,OAAOpC,GAAG,EAAE;IACZ,IAAIoC,UAAU,EAAE;MACd,MAAMpC,GAAG;IACX;IAEAzJ,eAAM,CAACC,IAAI,CAAE,mCAAkC6L,cAAgB,KAAI,GACtD,IAAGrC,GAAG,CAACnG,OAAQ,uCAAsC,GACtD,2DAA2D,GAC3D,6CAA6C,CAAC;EAC5D;EAIA,IAAI,MAAM5D,GAAG,CAACqM,aAAa,CAAChN,sBAAsB,CAAC,EAAE;IACnDiB,eAAM,CAACqD,KAAK,CAAE,GAAEtE,sBAAuB,uBAAsB,GAC1D,4CAA2C,CAAC;IAC/C;EACF;EAEA,MAAMiN,QAAQ,GAAG,MAAMtM,GAAG,CAACsK,WAAW,CAAC,CAAC;EACxC,IAAIgC,QAAQ,IAAI,EAAE,EAAE;IAElB,IAAI;MACF,MAAMtM,GAAG,CAAC0J,KAAK,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAErK,sBAAsB,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACtF,CAAC,CAAC,OAAO0K,GAAG,EAAE;MACZzJ,eAAM,CAACqD,KAAK,CAACoG,GAAG,CAACnG,OAAO,CAAC;IAC3B;IACA,IAAI;MACF,MAAM5D,GAAG,CAAC0J,KAAK,CAAC,CAAC,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAEnK,sCAAsC,CAAC,CAAC;IACpG,CAAC,CAAC,OAAOwK,GAAG,EAAE;MACZzJ,eAAM,CAACqD,KAAK,CAACoG,GAAG,CAACnG,OAAO,CAAC;IAC3B;EACF;EACA,IAAI0I,QAAQ,IAAI,EAAE,EAAE;IAElB,MAAMC,KAAK,GAAG,CAAC,qBAAqB,EAAE,sBAAsB,EAAE,sBAAsB,CAAC;IACrFjM,eAAM,CAACoE,IAAI,CAAE,wBAAuB6H,KAAM,QAAOlN,sBAAuB,GAAE,CAAC;IAC3E,MAAMW,GAAG,CAACsI,gBAAgB,CAACjJ,sBAAsB,EAAEkN,KAAK,CAAC1H,GAAG,CAAE2H,CAAC,IAAM,sBAAqBA,CAAE,EAAC,CAAC,CAAC;EACjG;EAKA,IAAI;IACF,MAAMxM,GAAG,CAACyM,yBAAyB,CAAC;MAClClE,OAAO,EAAE9G,OAAO,CAACiL,UAAU,CAAC1M,GAAG,EAAEU,IAAI,CAAC,GAAG,KAAK,GAAG;IACnD,CAAC,CAAC;EACJ,CAAC,CAAC,OAAOqJ,GAAG,EAAE;IACZzJ,eAAM,CAACqD,KAAK,CAACoG,GAAG,CAAC;IACjB,IAAIoC,UAAU,EAAE;MACd,MAAMpC,GAAG;IACX;EACF;AACF,CAAC;AAgBDtI,OAAO,CAACkL,WAAW,GAAG,eAAeA,WAAWA,CAAE5J,QAAQ,EAAE/C,GAAG,EAAEU,IAAI,EAAE;EACrE,MAAMkM,SAAS,GAAG,iBAAiB;EACnC,MAAMC,WAAW,GAAG,cAAc;EAClC,MAAMC,UAAU,GAAG/B,aAAI,CAACC,KAAK,CAAC+B,OAAO,CAACH,SAAS,EAAEC,WAAW,CAAC;EAG7D,MAAM7M,GAAG,CAACqL,MAAM,CAACyB,UAAU,CAAC;EAE5B,IAAIjG,GAAG;EACP,IAAI;IACFA,GAAG,GAAGnG,IAAI,CAACmG,GAAG,KAAI,MAAM7G,GAAG,CAACgN,OAAO,CAACtM,IAAI,CAACoG,UAAU,EAAEpG,IAAI,CAACuM,MAAM,CAAC;EACnE,CAAC,CAAC,OAAOlD,GAAG,EAAE;IACZzJ,eAAM,CAACoE,IAAI,CAAE,+BAA8BhE,IAAI,CAACoG,UAAW,SAAQpG,IAAI,CAACuM,MAAO,sBAAqBlD,GAAG,CAACnG,OAAQ,EAAC,CAAC;EACpH;EAEA,IAAI1D,eAAC,CAACgN,OAAO,CAACxM,IAAI,CAACoG,UAAU,CAAC,IAAI,EAAE,MAAMoE,WAAE,CAACiC,MAAM,CAACtG,GAAG,CAAC,CAAC,EAAE;IACzDvG,eAAM,CAACqD,KAAK,CAAE,sDAAqD,CAAC;IACpE,OAAO,CAAC,CAAC;EACX;EAEA,MAAMyJ,aAAa,GAAGrC,aAAI,CAACgC,OAAO,CAACrM,IAAI,CAACuM,MAAM,EAAEvM,IAAI,CAACoG,UAAU,CAAC;EAChE,IAAI;IACFxG,eAAM,CAACqD,KAAK,CAAC,6BAA6B,EAAEkD,GAAG,EAAE9D,QAAQ,EAAEqK,aAAa,CAAC;IACzE,MAAM;MAACC,UAAU;MAAEC;IAAS,CAAC,GAAG,MAAMtN,GAAG,CAACuN,qBAAqB,CAAC1G,GAAG,EAAE9D,QAAQ,EAAEqK,aAAa,CAAC;IAC7F,MAAMpN,GAAG,CAACe,IAAI,CAACuM,SAAS,EAAEV,SAAS,CAAC;IACpC,OAAOS,UAAU;EACnB,CAAC,CAAC,OAAOtD,GAAG,EAAE;IACZzJ,eAAM,CAACC,IAAI,CAAE,6DAA4DwJ,GAAG,CAACnG,OAAQ,EAAC,CAAC;IACvF,MAAM5D,GAAG,CAAC0J,KAAK,CAAC,MAAM,EAAE,CAAE,UAASoD,UAAW,EAAC,CAAC,CAAC;EACnD,CAAC,SAAS;IACR,MAAM5B,WAAE,CAACG,MAAM,CAAC+B,aAAa,CAAC;EAChC;EACA,OAAO,CAAC,CAAC;AACX,CAAC;AAED3L,OAAO,CAAC+L,MAAM,GAAG,eAAeA,MAAMA,CAAEC,MAAM,EAAEzN,GAAG,EAAE0N,YAAY,EAAE;EACjE,IAAI,EAAE,MAAM1N,GAAG,CAAC2N,cAAc,CAAC,CAAC,CAAC,EAAE;IACjCrN,eAAM,CAACoE,IAAI,CAAC,wCAAwC,CAAC;IACrD;EACF;EAEApE,eAAM,CAACqD,KAAK,CAAC,oCAAoC,CAAC;EAClD,IAAI,CAAC+J,YAAY,CAACvM,UAAU,IAAI,CAACuM,YAAY,CAACE,SAAS,EAAE;IACvDtN,eAAM,CAACoE,IAAI,CAAE,+DAA8D,GACxE,0DAAyD,CAAC;IAC7D,MAAM1E,GAAG,CAAC6N,eAAe,CAAC,CAAC;IAC3B;EACF;EAEA,MAAM;IACJ1M,UAAU;IACVyM,SAAS;IACTE,cAAc;IACdC;EACF,CAAC,GAAGC,sBAAQ,CAACC,0BAA0B,CAACP,YAAY,CAAC;EACrD,IAAIE,SAAS,IAAIzM,UAAU,KAAK+M,iCAAkB,KAC1ChO,eAAC,CAACiO,KAAK,CAACL,cAAc,CAAC,IAAI5N,eAAC,CAAC6F,OAAO,CAAC+H,cAAc,CAAC,KAAK,cAAc,CAAC,KACzE,MAAM9N,GAAG,CAACoO,yBAAyB,CAAC,CAAC,GAAE;IAC5C,MAAMJ,sBAAQ,CAACK,UAAU,CAACrO,GAAG,EAAE;MAC7BsO,UAAU,EAAEV,SAAS;MACrBW,cAAc,EAAErN,gBAAgB,CAACC,UAAU;IAC7C,CAAC,CAAC;EACJ,CAAC,MAAM;IACL,MAAMqN,YAAY,GAAG;MACnB,CAACpN,yBAAU,GAAG4M,sBAAQ,CAACS,SAAS;MAChC,CAACpN,mCAAoB,GAAG2M,sBAAQ,CAACU,qBAAqB;MACtD,CAACpN,8BAAe,GAAG0M,sBAAQ,CAACW,cAAc;MAC1C,CAACpN,6BAAc,GAAGyM,sBAAQ,CAACY,aAAa;MACxC,CAACV,iCAAkB,GAAGF,sBAAQ,CAACa;IACjC,CAAC,CAAC1N,UAAU,CAAC;IACb,MAAMqN,YAAY,CAACxO,GAAG,EAAEyN,MAAM,EAAEC,YAAY,CAAC;EAC/C;EACA,MAAMjM,OAAO,CAACqN,YAAY,CAAC9O,GAAG,EAAE+N,oBAAoB,CAAC;AACvD,CAAC;AAEDtM,OAAO,CAACqN,YAAY,GAAG,eAAeA,YAAYA,CAAE9O,GAAG,EAAE+O,SAAS,GAAG,IAAI,EAAE;EACzE,IAAI;IACF,MAAM,IAAAC,0BAAgB,EAAC,YAAY,EAAE,MAAMhP,GAAG,CAAC2N,cAAc,CAAC,CAAC,CAAC,EAAE;MAChEsB,MAAM,EAAEF,SAAS,IAAI,IAAI;MACzBG,UAAU,EAAE;IACd,CAAC,CAAC;EACJ,CAAC,CAAC,OAAOpH,GAAG,EAAE;IACZ,MAAM,IAAItG,KAAK,CAAC,sCAAsC,CAAC;EACzD;EACAlB,eAAM,CAACoE,IAAI,CAAC,2CAA2C,CAAC;AAC1D,CAAC;AAEDjD,OAAO,CAAC0N,UAAU,GAAG,eAAeA,UAAUA,CAAEnP,GAAG,EAAEU,IAAI,EAAE;EACzD,MAAM;IACJ0O,wBAAwB;IACxBpM,MAAM;IACND,QAAQ;IACRsM,YAAY;IACZC,eAAe;IACfC,sBAAsB;IACtBC,UAAU;IACVC,eAAe;IACfC,iBAAiB;IACjBC,YAAY;IACZC;EACF,CAAC,GAAGlP,IAAI;EAER,IAAI0O,wBAAwB,EAAE;IAC5B9O,eAAM,CAACoE,IAAI,CAAE,oEAAmE,CAAC;EACnF,CAAC,MAAM;IACL,IAAIjD,OAAO,CAACiL,UAAU,CAAC1M,GAAG,EAAEU,IAAI,CAAC,EAAE;MAGjC,MAAMV,GAAG,CAAC6P,aAAa,CAAC,CAAC;IAC3B;IAMA,MAAMC,gBAAgB,GAAG/M,QAAQ,IAC5BC,MAAM,IACNqM,YAAY,IACZC,eAAe,IACfC,sBAAsB,IACtB,CAACC,UAAU;IAChB,MAAM/N,OAAO,CAACyK,eAAe,CAAClM,GAAG,EAAE8P,gBAAgB,EAAEpP,IAAI,CAAC;EAC5D;EAEA,IAAI,CAACe,OAAO,CAACiL,UAAU,CAAC1M,GAAG,EAAEU,IAAI,CAAC,EAAE;IAClC,IAAI+O,eAAe,IAAIvP,eAAC,CAAC6P,WAAW,CAACN,eAAe,CAAC,EAAE;MACrD,MAAMhO,OAAO,CAAC4I,kBAAkB,CAACrK,GAAG,EAAEyP,eAAe,IAAIpQ,sBAAsB,CAAC;IAClF,CAAC,MAAM;MACL,MAAMoC,OAAO,CAAC6J,iBAAiB,CAACtL,GAAG,CAAC;IACtC;EACF;EAEA,IAAI+C,QAAQ,IAAIC,MAAM,EAAE;IACtB,MAAMvB,OAAO,CAACuC,kBAAkB,CAAChE,GAAG,EAAE+C,QAAQ,EAAEC,MAAM,EAAEqM,YAAY,CAAC;EACvE;EAEA,IAAIK,iBAAiB,EAAE;IACrBpP,eAAM,CAACoE,IAAI,CAAE,+DAA8D,CAAC;EAC9E,CAAC,MAAM;IACL,MAAM1E,GAAG,CAACgQ,WAAW,CAAC;MACpBC,MAAM,EAAEN,YAAY;MACpBO,WAAW,EAAEN;IACf,CAAC,CAAC;EACJ;EAEA,IAAIN,eAAe,EAAE;IACnB,OAAO,MAAM7N,OAAO,CAACuI,mBAAmB,CAAChK,GAAG,CAAC;EAC/C;AACF,CAAC;AAEDyB,OAAO,CAAC0O,oBAAoB,GAAG,SAASA,oBAAoBA,CAAE1S,GAAG,EAAE;EACjE,KAAK,IAAIW,GAAG,IAAI8B,eAAC,CAACiG,IAAI,CAAC1I,GAAG,CAAC,EAAE;IAC3B,IAAIyC,eAAC,CAACkQ,MAAM,CAAC3S,GAAG,CAACW,GAAG,CAAC,CAAC,IAAI8B,eAAC,CAAC6P,WAAW,CAACtS,GAAG,CAACW,GAAG,CAAC,CAAC,EAAE;MACjD,OAAOX,GAAG,CAACW,GAAG,CAAC;IACjB;EACF;AACF,CAAC;AAEDqD,OAAO,CAAC4O,gBAAgB,GAAG,SAASA,gBAAgBA,CAAEC,MAAM,EAAEC,MAAM,EAAE;EACpE,IAAIC,UAAU,GAAGC,IAAI,CAACC,GAAG,CAAC,EAAE,EAAEH,MAAM,CAAC;IACjCI,WAAW,GAAGL,MAAM,GAAGE,UAAU;IACjCI,YAAY,GAAGH,IAAI,CAACE,WAAW,GAAG,CAAC,GAAG,MAAM,GAAG,OAAO,CAAC,CAACA,WAAW,CAAC;EAExE,OAAOC,YAAY,GAAGJ,UAAU;AAClC,CAAC;AAED/O,OAAO,CAACoP,eAAe,GAAG,SAASA,eAAeA,CAAEzR,OAAO,EAAE;EAC3D,OAAOc,eAAC,CAACG,QAAQ,CAACpC,MAAM,CAACkI,IAAI,CAACrH,+BAA+B,CAAC,EAAE,CAACM,OAAO,IAAI,EAAE,EAAE6I,WAAW,CAAC,CAAC,CAAC;AAChG,CAAC;AAEDxG,OAAO,CAACqP,YAAY,GAAG,SAASA,YAAYA,CAAE1R,OAAO,EAAE;EACrD,OAAON,+BAA+B,CAACM,OAAO,CAAC6I,WAAW,CAAC,CAAC,CAAC,IAAInJ,+BAA+B,CAACnB,OAAO;AAC1G,CAAC;AAED8D,OAAO,CAACsP,iCAAiC,GAAG,eAAeA,iCAAiCA,CAAEC,MAAM,EAAEC,SAAS,EAAE;EAC/G,IAAI,CAACD,MAAM,IAAI,CAAC9Q,eAAC,CAACgR,UAAU,CAACF,MAAM,CAACG,oBAAoB,CAAC,EAAE;IACzD;EACF;EAEA,MAAMC,cAAc,GAAG,MAAMJ,MAAM,CAACG,oBAAoB,CAACF,SAAS,CAAC;EACnE,KAAK,MAAMI,QAAQ,IAAInR,eAAC,CAACiG,IAAI,CAACiL,cAAc,CAAC,EAAE;IAC7C,MAAMJ,MAAM,CAACM,sBAAsB,CAACD,QAAQ,CAAC;EAC/C;AACF,CAAC;AAQD5P,OAAO,CAAC8P,UAAU,GAAG,SAASA,UAAUA,CAAEC,GAAG,EAAE;EAC7C,IAAIC,UAAU;EACd,IAAI;IACFA,UAAU,GAAGhH,IAAI,CAACC,KAAK,CAAC8G,GAAG,CAAC;EAC9B,CAAC,CAAC,OAAO1J,GAAG,EAAE,CAAE;EAEhB,IAAI5H,eAAC,CAACY,OAAO,CAAC2Q,UAAU,CAAC,EAAE;IACzB,OAAOA,UAAU;EACnB,CAAC,MAAM,IAAIvR,eAAC,CAACgE,QAAQ,CAACsN,GAAG,CAAC,EAAE;IAC1B,OAAO,CAACA,GAAG,CAAC;EACd;EAEA,MAAM,IAAIhQ,KAAK,CAAE,iDAAgDgQ,GAAI,EAAC,CAAC;AACzE,CAAC;AASD/P,OAAO,CAACiQ,mBAAmB,GAAG,SAASA,mBAAmBA,CAAEC,IAAI,EAAE;EAChE,IAAIA,IAAI,CAACC,WAAW,EAAE;IACpB,IAAID,IAAI,CAAC9K,GAAG,EAAE;MAEZvG,eAAM,CAACC,IAAI,CAAE,yFAAwF,CAAC;IACxG;IACA,IAAIoR,IAAI,CAAC7K,UAAU,EAAE;MACnBxG,eAAM,CAACwE,aAAa,CAAE,4EAA2E,CAAC;IACpG;EACF;EAEA,IAAI6M,IAAI,CAACtI,sBAAsB,EAAE;IAC/B,IAAI;MACF,IAAI,CAACkI,UAAU,CAACI,IAAI,CAACtI,sBAAsB,CAAC;IAC9C,CAAC,CAAC,OAAO3F,CAAC,EAAE;MACVpD,eAAM,CAACwE,aAAa,CAAE,wDAAuDpB,CAAC,CAACE,OAAQ,EAAC,CAAC;IAC3F;EACF;EAEA,OAAO,IAAI;AACb,CAAC;AAWDnC,OAAO,CAACoQ,wBAAwB,GAAG,SAASA,wBAAwBA,CAAEF,IAAI,GAAG,CAAC,CAAC,EAAE;EAC/E,MAAM;IAAEC;EAAY,CAAC,GAAGD,IAAI;EAC5BrR,eAAM,CAACoE,IAAI,CAAE,iDAAgD,CAAC;EAC9DpE,eAAM,CAACoE,IAAI,CAAE,4BAA2B+F,IAAI,CAACW,SAAS,CAAClL,eAAC,CAACiG,IAAI,CAACrH,+BAA+B,CAAC,CAAE,EAAC,CAAC;EAClG,IAAI6S,IAAI,CAAC7K,UAAU,IAAI6K,IAAI,CAAC5K,WAAW,EAAE;IACvCzG,eAAM,CAACoE,IAAI,CAAE,gEAA+DkN,WAAY,IAAG,GACzF,iDAAiD,CAAC;IACpD,OAAOD,IAAI;EACb;EAEA,MAAM;IAAC3S,GAAG;IAAEC;EAAQ,CAAC,GAAG,IAAI,CAAC6R,YAAY,CAACc,WAAW,CAAC;EACtDD,IAAI,CAAC7K,UAAU,GAAG9H,GAAG;EACrB2S,IAAI,CAAC5K,WAAW,GAAG9H,QAAQ;EAC3BqB,eAAM,CAACoE,IAAI,CAAE,sEAAqE1F,GAAI,IAAGC,QAAS,GAAE,GACjG,QAAO2S,WAAY,GAAE,CAAC;EACzBtR,eAAM,CAACoE,IAAI,CAAE,wFAAuF,GACjG,mGAAkG,GAClG,gBAAe,CAAC;EACnB,OAAOiN,IAAI;AACb,CAAC;AASDlQ,OAAO,CAACiL,UAAU,GAAG,SAASA,UAAUA,CAAE1M,GAAG,EAAEU,IAAI,EAAE;EACnD,MAAMoR,aAAa,GAAG,CAACpR,IAAI,CAAC4D,IAAI,EAAEtE,GAAG,aAAHA,GAAG,uBAAHA,GAAG,CAAEwE,WAAW,CAAC;EACnD,OAAO,CAAC,CAAC9D,IAAI,CAACkC,GAAG,IAAIkP,aAAa,CAACC,IAAI,CAAEvF,CAAC,IAAKhN,gBAAgB,CAACwS,IAAI,CAACxF,CAAC,CAAC,CAAC;AAC1E,CAAC;AAED/K,OAAO,CAACwQ,SAAS,GAAGC,kBAAS;AAC7BzQ,OAAO,CAACuM,QAAQ,GAAGA,sBAAQ;AAAC,IAAAmE,QAAA,GAGb1Q,OAAO;AAAAnC,OAAA,CAAA3B,OAAA,GAAAwU,QAAA"}
+    const possibleNames = [opts.udid, adb?.curDeviceId];
+    return !!opts.avd || possibleNames.some((x) => EMULATOR_PATTERN.test(x));
+};
+helpers.bootstrap = bootstrap_1.default;
+helpers.unlocker = unlock_helpers_1.helpers;
+exports.default = helpers;
+//# sourceMappingURL=android-helpers.js.map