"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
Object.defineProperty(exports, "DEFAULT_ADB_EXEC_TIMEOUT", {
  enumerable: true,
  get: function () {
    return _helpers.DEFAULT_ADB_EXEC_TIMEOUT;
  }
});
exports.default = void 0;

require("source-map-support/register");

var _path = _interopRequireDefault(require("path"));

var _logger = _interopRequireDefault(require("../logger.js"));

var _bluebird = _interopRequireDefault(require("bluebird"));

var _appiumSupport = require("appium-support");

var _helpers = require("../helpers");

var _teen_process = require("teen_process");

var _asyncbox = require("asyncbox");

var _lodash = _interopRequireDefault(require("lodash"));

let systemCallMethods = {};
const DEFAULT_ADB_REBOOT_RETRIES = 90;
const LINKER_WARNING_REGEXP = /^WARNING: linker.+$/m;
const PROTOCOL_FAULT_ERROR_REGEXP = new RegExp('protocol fault \\(no status\\)', 'i');
const DEVICE_NOT_FOUND_ERROR_REGEXP = new RegExp(`error: device ('.+' )?not found`, 'i');
const DEVICE_CONNECTING_ERROR_REGEXP = new RegExp('error: device still connecting', 'i');
const CERTS_ROOT = '/system/etc/security/cacerts';

systemCallMethods.getSdkBinaryPath = async function getSdkBinaryPath(binaryName) {
  if (this.sdkRoot) {
    return await this.getBinaryFromSdkRoot(binaryName);
  }

  _logger.default.warn(`The ANDROID_HOME environment variable is not set to the Android SDK ` + `root directory path. ANDROID_HOME is required for compatibility ` + `with SDK 23+. Checking along PATH for ${binaryName}.`);

  return await this.getBinaryFromPath(binaryName);
};

systemCallMethods.getBinaryNameForOS = _lodash.default.memoize(function getBinaryNameForOS(binaryName) {
  if (!_appiumSupport.system.isWindows()) {
    return binaryName;
  }

  if (['android', 'apksigner', 'apkanalyzer'].includes(binaryName)) {
    return `${binaryName}.bat`;
  }

  if (!_path.default.extname(binaryName)) {
    return `${binaryName}.exe`;
  }

  return binaryName;
});

systemCallMethods.getBinaryFromSdkRoot = async function getBinaryFromSdkRoot(binaryName) {
  if (this.binaries[binaryName]) {
    return this.binaries[binaryName];
  }

  const fullBinaryName = this.getBinaryNameForOS(binaryName);
  const binaryLocs = ['platform-tools', 'emulator', 'tools', `tools${_path.default.sep}bin`].map(x => _path.default.resolve(this.sdkRoot, x, fullBinaryName));
  let buildToolsDirs = await (0, _helpers.getBuildToolsDirs)(this.sdkRoot);

  if (this.buildToolsVersion) {
    buildToolsDirs = buildToolsDirs.filter(x => _path.default.basename(x) === this.buildToolsVersion);

    if (_lodash.default.isEmpty(buildToolsDirs)) {
      _logger.default.info(`Found no build tools whose version matches to '${this.buildToolsVersion}'`);
    } else {
      _logger.default.info(`Using build tools at '${buildToolsDirs}'`);
    }
  }

  binaryLocs.push(..._lodash.default.flatten(buildToolsDirs.map(dir => [_path.default.resolve(dir, fullBinaryName), _path.default.resolve(dir, 'lib', fullBinaryName)])));
  let binaryLoc = null;

  for (const loc of binaryLocs) {
    if (await _appiumSupport.fs.exists(loc)) {
      binaryLoc = loc;
      break;
    }
  }

  if (_lodash.default.isNull(binaryLoc)) {
    throw new Error(`Could not find '${fullBinaryName}' in ${JSON.stringify(binaryLocs)}. ` + `Do you have Android Build Tools ${this.buildToolsVersion ? `v ${this.buildToolsVersion} ` : ''}` + `installed at '${this.sdkRoot}'?`);
  }

  _logger.default.info(`Using '${fullBinaryName}' from '${binaryLoc}'`);

  this.binaries[binaryName] = binaryLoc;
  return binaryLoc;
};

systemCallMethods.getBinaryFromPath = async function getBinaryFromPath(binaryName) {
  if (this.binaries[binaryName]) {
    return this.binaries[binaryName];
  }

  const fullBinaryName = this.getBinaryNameForOS(binaryName);

  try {
    const binaryLoc = await _appiumSupport.fs.which(fullBinaryName);

    _logger.default.info(`Using '${fullBinaryName}' from '${binaryLoc}'`);

    this.binaries[binaryName] = binaryLoc;
    return binaryLoc;
  } catch (e) {
    throw new Error(`Could not find '${fullBinaryName}' in PATH. Please set the ANDROID_HOME ` + `or ANDROID_SDK_ROOT environment variables to the correct Android SDK root directory path.`);
  }
};

systemCallMethods.getConnectedDevices = async function getConnectedDevices() {
  _logger.default.debug('Getting connected devices...');

  let stdout;

  try {
    ({
      stdout
    } = await (0, _teen_process.exec)(this.executable.path, [...this.executable.defaultArgs, 'devices']));
  } catch (e) {
    throw new Error(`Error while getting connected devices. Original error: ${e.message}`);
  }

  const listHeader = 'List of devices';
  const startingIndex = stdout.indexOf(listHeader);

  if (startingIndex < 0) {
    throw new Error(`Unexpected output while trying to get devices: ${stdout}`);
  }

  stdout = stdout.slice(startingIndex);
  let excludedLines = [listHeader, 'adb server', '* daemon'];

  if (!this.allowOfflineDevices) {
    excludedLines.push('offline');
  }

  const devices = stdout.split('\n').map(_lodash.default.trim).filter(line => line && !excludedLines.some(x => line.includes(x))).reduce((acc, line) => {
    const [udid, state] = line.split(/\s+/);
    acc.push({
      udid,
      state
    });
    return acc;
  }, []);

  if (_lodash.default.isEmpty(devices)) {
    _logger.default.debug('No connected devices have been detected');
  } else {
    _logger.default.debug(`Connected devices: ${JSON.stringify(devices)}`);
  }

  return devices;
};

systemCallMethods.getDevicesWithRetry = async function getDevicesWithRetry(timeoutMs = 20000) {
  const timer = new _appiumSupport.timing.Timer().start();

  _logger.default.debug('Trying to find a connected android device');

  const getDevices = async () => {
    if (timer.getDuration().asMilliSeconds > timeoutMs) {
      throw new Error(`Could not find a connected Android device in ${timer.getDuration().asMilliSeconds.toFixed(0)}ms.`);
    }

    try {
      const devices = await this.getConnectedDevices();

      if (devices.length > 0) {
        return devices;
      }
    } catch (ign) {}

    _logger.default.debug('Could not find devices, restarting adb server...');

    await this.restartAdb();
    await (0, _asyncbox.sleep)(200);
    return await getDevices();
  };

  return await getDevices();
};

systemCallMethods.restartAdb = async function restartAdb() {
  if (this.suppressKillServer) {
    _logger.default.debug(`Not restarting abd since 'suppressKillServer' is on`);

    return;
  }

  _logger.default.debug('Restarting adb');

  try {
    await this.killServer();
  } catch (e) {
    _logger.default.error(`Error killing ADB server, going to see if it's online anyway`);
  }
};

systemCallMethods.killServer = async function killServer() {
  _logger.default.debug(`Killing adb server on port '${this.adbPort}'`);

  await this.adbExec(['kill-server'], {
    exclusive: true
  });
};

systemCallMethods.resetTelnetAuthToken = _lodash.default.memoize(async function resetTelnetAuthToken() {
  const homeFolderPath = process.env[process.platform === 'win32' ? 'USERPROFILE' : 'HOME'];

  if (!homeFolderPath) {
    _logger.default.warn(`Cannot find the path to user home folder. Ignoring resetting of emulator's telnet authentication token`);

    return false;
  }

  const dstPath = _path.default.resolve(homeFolderPath, '.emulator_console_auth_token');

  _logger.default.debug(`Overriding ${dstPath} with an empty string to avoid telnet authentication for emulator commands`);

  try {
    await _appiumSupport.fs.writeFile(dstPath, '');
  } catch (e) {
    _logger.default.warn(`Error ${e.message} while resetting the content of ${dstPath}. Ignoring resetting of emulator's telnet authentication token`);

    return false;
  }

  return true;
});

systemCallMethods.adbExecEmu = async function adbExecEmu(cmd) {
  await this.verifyEmulatorConnected();
  await this.resetTelnetAuthToken();
  await this.adbExec(['emu', ...cmd]);
};

let isExecLocked = false;

systemCallMethods.adbExec = async function adbExec(cmd, opts = {}) {
  if (!cmd) {
    throw new Error('You need to pass in a command to adbExec()');
  }

  opts = _lodash.default.cloneDeep(opts);
  opts.timeout = opts.timeout || this.adbExecTimeout || _helpers.DEFAULT_ADB_EXEC_TIMEOUT;
  opts.timeoutCapName = opts.timeoutCapName || 'adbExecTimeout';
  cmd = _lodash.default.isArray(cmd) ? cmd : [cmd];
  let adbRetried = false;

  const execFunc = async () => {
    try {
      const args = [...this.executable.defaultArgs, ...cmd];

      _logger.default.debug(`Running '${this.executable.path} ${_appiumSupport.util.quote(args)}'`);

      let {
        stdout
      } = await (0, _teen_process.exec)(this.executable.path, args, opts);
      stdout = stdout.replace(LINKER_WARNING_REGEXP, '').trim();
      return stdout;
    } catch (e) {
      const errText = `${e.message}, ${e.stdout}, ${e.stderr}`;
      const protocolFaultError = PROTOCOL_FAULT_ERROR_REGEXP.test(errText);
      const deviceNotFoundError = DEVICE_NOT_FOUND_ERROR_REGEXP.test(errText);
      const deviceConnectingError = DEVICE_CONNECTING_ERROR_REGEXP.test(errText);

      if (protocolFaultError || deviceNotFoundError || deviceConnectingError) {
        _logger.default.info(`Error sending command, reconnecting device and retrying: ${cmd}`);

        await (0, _asyncbox.sleep)(1000);
        await this.getDevicesWithRetry();

        if (adbRetried) {
          adbRetried = true;
          return await execFunc();
        }
      }

      if (e.code === 0 && e.stdout) {
        return e.stdout.replace(LINKER_WARNING_REGEXP, '').trim();
      }

      if (_lodash.default.isNull(e.code)) {
        e.message = `Error executing adbExec. Original error: '${e.message}'. ` + `Try to increase the ${opts.timeout}ms adb execution timeout represented by '${opts.timeoutCapName}' capability`;
      } else {
        e.message = `Error executing adbExec. Original error: '${e.message}'; ` + `Stderr: '${(e.stderr || '').trim()}'; Code: '${e.code}'`;
      }

      throw e;
    }
  };

  if (isExecLocked) {
    _logger.default.debug('Waiting until the other exclusive ADB command is completed');

    await (0, _asyncbox.waitForCondition)(() => !isExecLocked, {
      waitMs: Number.MAX_SAFE_INTEGER,
      intervalMs: 10
    });

    _logger.default.debug('Continuing with the current ADB command');
  }

  if (opts.exclusive) {
    isExecLocked = true;
  }

  try {
    return await execFunc();
  } finally {
    if (opts.exclusive) {
      isExecLocked = false;
    }
  }
};

systemCallMethods.shell = async function shell(cmd, opts = {}) {
  const {
    privileged,
    keepPrivileged
  } = opts;
  let shouldRestoreUser = false;

  if (privileged) {
    _logger.default.info(`'adb shell ${cmd}' requires root access. Attempting to gain root access now.`);

    const {
      wasAlreadyRooted,
      isSuccessful
    } = await this.root();
    shouldRestoreUser = !wasAlreadyRooted;

    if (wasAlreadyRooted) {
      _logger.default.info('Device already had root access');
    } else {
      _logger.default.info(isSuccessful ? 'Root access successfully gained' : 'Could not gain root access');
    }
  }

  let didCommandFail = false;

  try {
    try {
      return await this.adbExec(_lodash.default.isArray(cmd) ? ['shell', ...cmd] : ['shell', cmd], opts);
    } catch (err) {
      didCommandFail = true;
      throw err;
    }
  } finally {
    if (privileged && shouldRestoreUser && (!keepPrivileged || didCommandFail)) {
      const {
        isSuccessful
      } = await this.unroot();

      _logger.default.debug(isSuccessful ? 'Returned device to unrooted state' : 'Could not return device to unrooted state');
    }
  }
};

systemCallMethods.createSubProcess = function createSubProcess(args = []) {
  args = this.executable.defaultArgs.concat(args);

  _logger.default.debug(`Creating ADB subprocess with args: ${JSON.stringify(args)}`);

  return new _teen_process.SubProcess(this.getAdbPath(), args);
};

systemCallMethods.getAdbServerPort = function getAdbServerPort() {
  return this.adbPort;
};

systemCallMethods.getEmulatorPort = async function getEmulatorPort() {
  _logger.default.debug('Getting running emulator port');

  if (this.emulatorPort !== null) {
    return this.emulatorPort;
  }

  try {
    let devices = await this.getConnectedDevices();
    let port = this.getPortFromEmulatorString(devices[0].udid);

    if (port) {
      return port;
    } else {
      throw new Error(`Emulator port not found`);
    }
  } catch (e) {
    throw new Error(`No devices connected. Original error: ${e.message}`);
  }
};

systemCallMethods.getPortFromEmulatorString = function getPortFromEmulatorString(emStr) {
  let portPattern = /emulator-(\d+)/;

  if (portPattern.test(emStr)) {
    return parseInt(portPattern.exec(emStr)[1], 10);
  }

  return false;
};

systemCallMethods.getConnectedEmulators = async function getConnectedEmulators() {
  _logger.default.debug('Getting connected emulators');

  try {
    let devices = await this.getConnectedDevices();
    let emulators = [];

    for (let device of devices) {
      let port = this.getPortFromEmulatorString(device.udid);

      if (port) {
        device.port = port;
        emulators.push(device);
      }
    }

    _logger.default.debug(`${_appiumSupport.util.pluralize('emulator', emulators.length, true)} connected`);

    return emulators;
  } catch (e) {
    throw new Error(`Error getting emulators. Original error: ${e.message}`);
  }
};

systemCallMethods.setEmulatorPort = function setEmulatorPort(emPort) {
  this.emulatorPort = emPort;
};

systemCallMethods.setDeviceId = function setDeviceId(deviceId) {
  _logger.default.debug(`Setting device id to ${deviceId}`);

  this.curDeviceId = deviceId;
  let argsHasDevice = this.executable.defaultArgs.indexOf('-s');

  if (argsHasDevice !== -1) {
    this.executable.defaultArgs.splice(argsHasDevice, 2);
  }

  this.executable.defaultArgs.push('-s', deviceId);
};

systemCallMethods.setDevice = function setDevice(deviceObj) {
  let deviceId = deviceObj.udid;
  let emPort = this.getPortFromEmulatorString(deviceId);
  this.setEmulatorPort(emPort);
  this.setDeviceId(deviceId);
};

systemCallMethods.getRunningAVD = async function getRunningAVD(avdName) {
  _logger.default.debug(`Trying to find '${avdName}' emulator`);

  try {
    const emulators = await this.getConnectedEmulators();

    for (const emulator of emulators) {
      this.setEmulatorPort(emulator.port);
      const runningAVDName = await this.sendTelnetCommand('avd name');

      if (_lodash.default.toLower(avdName) === _lodash.default.toLower(runningAVDName)) {
        _logger.default.debug(`Found emulator '${avdName}' on port ${emulator.port}`);

        this.setDeviceId(emulator.udid);
        return emulator;
      }
    }

    _logger.default.debug(`Emulator '${avdName}' not running`);

    return null;
  } catch (e) {
    throw new Error(`Error getting AVD. Original error: ${e.message}`);
  }
};

systemCallMethods.getRunningAVDWithRetry = async function getRunningAVDWithRetry(avdName, timeoutMs = 20000) {
  let runningAvd;

  try {
    await (0, _asyncbox.waitForCondition)(async () => {
      try {
        runningAvd = await this.getRunningAVD(avdName.replace('@', ''));
        return runningAvd;
      } catch (e) {
        _logger.default.debug(e.message);

        return false;
      }
    }, {
      waitMs: timeoutMs,
      intervalMs: 1000
    });
  } catch (e) {
    throw new Error(`Error getting AVD with retry. Original error: ${e.message}`);
  }

  return runningAvd;
};

systemCallMethods.killAllEmulators = async function killAllEmulators() {
  let cmd, args;

  if (_appiumSupport.system.isWindows()) {
    cmd = 'TASKKILL';
    args = ['TASKKILL', '/IM', 'emulator.exe'];
  } else {
    cmd = '/usr/bin/killall';
    args = ['-m', 'emulator*'];
  }

  try {
    await (0, _teen_process.exec)(cmd, args);
  } catch (e) {
    throw new Error(`Error killing emulators. Original error: ${e.message}`);
  }
};

systemCallMethods.killEmulator = async function killEmulator(avdName = null, timeout = 60000) {
  if (_appiumSupport.util.hasValue(avdName)) {
    _logger.default.debug(`Killing avd '${avdName}'`);

    const device = await this.getRunningAVD(avdName);

    if (!device) {
      _logger.default.info(`No avd with name '${avdName}' running. Skipping kill step.`);

      return false;
    }
  } else {
    _logger.default.debug(`Killing avd with id '${this.curDeviceId}'`);

    if (!(await this.isEmulatorConnected())) {
      _logger.default.debug(`Emulator with id '${this.curDeviceId}' not connected. Skipping kill step`);

      return false;
    }
  }

  await this.adbExec(['emu', 'kill']);

  _logger.default.debug(`Waiting up to ${timeout}ms until the emulator '${avdName ? avdName : this.curDeviceId}' is killed`);

  try {
    await (0, _asyncbox.waitForCondition)(async () => {
      try {
        return _appiumSupport.util.hasValue(avdName) ? !(await this.getRunningAVD(avdName)) : !(await this.isEmulatorConnected());
      } catch (ign) {}

      return false;
    }, {
      waitMs: timeout,
      intervalMs: 2000
    });
  } catch (e) {
    throw new Error(`The emulator '${avdName ? avdName : this.curDeviceId}' is still running after being killed ${timeout}ms ago`);
  }

  _logger.default.info(`Successfully killed the '${avdName ? avdName : this.curDeviceId}' emulator`);

  return true;
};

systemCallMethods.launchAVD = async function launchAVD(avdName, avdArgs, language, country, avdLaunchTimeout = 60000, avdReadyTimeout = 60000, retryTimes = 1) {
  _logger.default.debug(`Launching Emulator with AVD ${avdName}, launchTimeout ` + `${avdLaunchTimeout}ms and readyTimeout ${avdReadyTimeout}ms`);

  let emulatorBinaryPath = await this.getSdkBinaryPath('emulator');

  if (avdName[0] === '@') {
    avdName = avdName.substr(1);
  }

  await this.checkAvdExist(avdName);
  let launchArgs = ['-avd', avdName];

  if (_lodash.default.isString(language)) {
    _logger.default.debug(`Setting Android Device Language to ${language}`);

    launchArgs.push('-prop', `persist.sys.language=${language.toLowerCase()}`);
  }

  if (_lodash.default.isString(country)) {
    _logger.default.debug(`Setting Android Device Country to ${country}`);

    launchArgs.push('-prop', `persist.sys.country=${country.toUpperCase()}`);
  }

  let locale;

  if (_lodash.default.isString(language) && _lodash.default.isString(country)) {
    locale = language.toLowerCase() + '-' + country.toUpperCase();
  } else if (_lodash.default.isString(language)) {
    locale = language.toLowerCase();
  } else if (_lodash.default.isString(country)) {
    locale = country;
  }

  if (_lodash.default.isString(locale)) {
    _logger.default.debug(`Setting Android Device Locale to ${locale}`);

    launchArgs.push('-prop', `persist.sys.locale=${locale}`);
  }

  if (!_lodash.default.isEmpty(avdArgs)) {
    launchArgs.push(...(_lodash.default.isArray(avdArgs) ? avdArgs : avdArgs.split(' ')));
  }

  _logger.default.debug(`Running '${emulatorBinaryPath}' with args: ${JSON.stringify(launchArgs)}`);

  let proc = new _teen_process.SubProcess(emulatorBinaryPath, launchArgs);
  await proc.start(0);
  proc.on('output', (stdout, stderr) => {
    for (let line of (stdout || stderr || '').split('\n').filter(Boolean)) {
      _logger.default.info(`[AVD OUTPUT] ${line}`);
    }
  });
  proc.on('die', (code, signal) => {
    _logger.default.warn(`Emulator avd ${avdName} exited with code ${code}${signal ? `, signal ${signal}` : ''}`);
  });
  await (0, _asyncbox.retry)(retryTimes, async () => await this.getRunningAVDWithRetry(avdName, avdLaunchTimeout));
  await this.waitForEmulatorReady(avdReadyTimeout);
  return proc;
};

systemCallMethods.getAdbVersion = _lodash.default.memoize(async function getAdbVersion() {
  try {
    let adbVersion = (await this.adbExec('version')).replace(/Android\sDebug\sBridge\sversion\s([\d.]*)[\s\w-]*/, '$1');
    let parts = adbVersion.split('.');
    return {
      versionString: adbVersion,
      versionFloat: parseFloat(adbVersion),
      major: parseInt(parts[0], 10),
      minor: parseInt(parts[1], 10),
      patch: parts[2] ? parseInt(parts[2], 10) : undefined
    };
  } catch (e) {
    throw new Error(`Error getting adb version. Original error: '${e.message}'; ` + `Stderr: '${(e.stderr || '').trim()}'; Code: '${e.code}'`);
  }
});

systemCallMethods.checkAvdExist = async function checkAvdExist(avdName) {
  let cmd, result;

  try {
    cmd = await this.getSdkBinaryPath('emulator');
    result = await (0, _teen_process.exec)(cmd, ['-list-avds']);
  } catch (e) {
    let unknownOptionError = new RegExp('unknown option: -list-avds', 'i').test(e.stderr);

    if (!unknownOptionError) {
      throw new Error(`Error executing checkAvdExist. Original error: '${e.message}'; ` + `Stderr: '${(e.stderr || '').trim()}'; Code: '${e.code}'`);
    }

    const sdkVersion = await (0, _helpers.getSdkToolsVersion)();
    let binaryName = 'android';

    if (sdkVersion) {
      if (sdkVersion.major >= 25) {
        binaryName = 'avdmanager';
      }
    } else {
      _logger.default.warn(`Defaulting binary name to '${binaryName}', because SDK version cannot be parsed`);
    }

    cmd = await this.getSdkBinaryPath(binaryName);
    result = await (0, _teen_process.exec)(cmd, ['list', 'avd', '-c']);
  }

  if (result.stdout.indexOf(avdName) === -1) {
    let existings = `(${result.stdout.trim().replace(/[\n]/g, '), (')})`;
    throw new Error(`Avd '${avdName}' is not available. please select your avd name from one of these: '${existings}'`);
  }
};

systemCallMethods.waitForEmulatorReady = async function waitForEmulatorReady(timeoutMs = 20000) {
  try {
    await (0, _asyncbox.waitForCondition)(async () => {
      try {
        if (!(await this.shell(['getprop', 'init.svc.bootanim'])).includes('stopped')) {
          return false;
        }

        return /\d+\[\w+\]/.test(await this.shell(['pm', 'get-install-location']));
      } catch (err) {
        _logger.default.debug(`Waiting for emulator startup. Intermediate error: ${err.message}`);

        return false;
      }
    }, {
      waitMs: timeoutMs,
      intervalMs: 3000
    });
  } catch (e) {
    throw new Error(`Emulator is not ready within ${timeoutMs}ms`);
  }
};

systemCallMethods.waitForDevice = async function waitForDevice(appDeviceReadyTimeout = 30) {
  this.appDeviceReadyTimeout = appDeviceReadyTimeout;
  const retries = 3;
  const timeout = parseInt(this.appDeviceReadyTimeout, 10) / retries * 1000;
  await (0, _asyncbox.retry)(retries, async () => {
    try {
      await this.adbExec('wait-for-device', {
        timeout
      });
      await this.ping();
    } catch (e) {
      await this.restartAdb();
      await this.getConnectedDevices();
      throw new Error(`Error waiting for the device to be available. Original error: '${e.message}'`);
    }
  });
};

systemCallMethods.reboot = async function reboot(retries = DEFAULT_ADB_REBOOT_RETRIES) {
  const {
    wasAlreadyRooted
  } = await this.root();

  try {
    await this.shell(['stop']);
    await _bluebird.default.delay(2000);
    await this.setDeviceProperty('sys.boot_completed', 0, {
      privileged: false
    });
    await this.shell(['start']);
  } catch (e) {
    const {
      message
    } = e;

    if (message.includes('must be root')) {
      throw new Error(`Could not reboot device. Rebooting requires root access and ` + `attempt to get root access on device failed with error: '${message}'`);
    }

    throw e;
  } finally {
    if (!wasAlreadyRooted) {
      await this.unroot();
    }
  }

  const timer = new _appiumSupport.timing.Timer().start();
  await (0, _asyncbox.retryInterval)(retries, 1000, async () => {
    if ((await this.getDeviceProperty('sys.boot_completed')) === '1') {
      return;
    }

    const msg = `Reboot is not completed after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`;

    _logger.default.debug(msg);

    throw new Error(msg);
  });
};

systemCallMethods.changeUserPrivileges = async function changeUserPrivileges(isElevated) {
  const cmd = isElevated ? 'root' : 'unroot';
  const isRoot = await this.isRoot();

  if (isRoot && isElevated || !isRoot && !isElevated) {
    return {
      isSuccessful: true,
      wasAlreadyRooted: isRoot
    };
  }

  let wasAlreadyRooted = isRoot;

  try {
    let {
      stdout
    } = await this.adbExec([cmd]);

    if (stdout) {
      if (stdout.includes('adbd cannot run as root')) {
        return {
          isSuccessful: false,
          wasAlreadyRooted
        };
      }

      if (stdout.includes('already running as root')) {
        wasAlreadyRooted = true;
      }
    }

    return {
      isSuccessful: true,
      wasAlreadyRooted
    };
  } catch (err) {
    const {
      stderr = '',
      message
    } = err;

    _logger.default.warn(`Unable to ${cmd} adb daemon. Original error: '${message}'. Stderr: '${stderr}'. Continuing.`);

    if (['closed', 'device offline', 'timeout expired'].some(x => stderr.toLowerCase().includes(x))) {
      _logger.default.warn(`Attempt to 'adb ${cmd}' caused device to go offline. Restarting adb.`);

      await this.restartAdb();
    }

    return {
      isSuccessful: false,
      wasAlreadyRooted
    };
  }
};

systemCallMethods.root = async function root() {
  return await this.changeUserPrivileges(true);
};

systemCallMethods.unroot = async function unroot() {
  return await this.changeUserPrivileges(false);
};

systemCallMethods.isRoot = async function isRoot() {
  return (await this.shell(['whoami'])).trim() === 'root';
};

systemCallMethods.fileExists = async function fileExists(remotePath) {
  const passFlag = '__PASS__';
  const checkCmd = `[ -e '${remotePath.replace(/'/g, `\\'`)}' ] && echo ${passFlag}`;

  try {
    return _lodash.default.includes(await this.shell([checkCmd]), passFlag);
  } catch (ign) {
    return false;
  }
};

systemCallMethods.ls = async function ls(remotePath, opts = []) {
  try {
    let args = ['ls', ...opts, remotePath];
    let stdout = await this.shell(args);
    let lines = stdout.split('\n');
    return lines.map(l => l.trim()).filter(Boolean).filter(l => l.indexOf('No such file') === -1);
  } catch (err) {
    if (err.message.indexOf('No such file or directory') === -1) {
      throw err;
    }

    return [];
  }
};

systemCallMethods.fileSize = async function fileSize(remotePath) {
  try {
    const files = await this.ls(remotePath, ['-la']);

    if (files.length !== 1) {
      throw new Error(`Remote path is not a file`);
    }

    const match = /[rwxsStT\-+]{10}[\s\d]*\s[^\s]+\s+[^\s]+\s+(\d+)/.exec(files[0]);

    if (!match || _lodash.default.isNaN(parseInt(match[1], 10))) {
      throw new Error(`Unable to parse size from list output: '${files[0]}'`);
    }

    return parseInt(match[1], 10);
  } catch (err) {
    throw new Error(`Unable to get file size for '${remotePath}': ${err.message}`);
  }
};

systemCallMethods.installMitmCertificate = async function installMitmCertificate(cert) {
  const openSsl = await (0, _helpers.getOpenSslForOs)();

  if (!_lodash.default.isBuffer(cert)) {
    cert = Buffer.from(cert, 'base64');
  }

  const tmpRoot = await _appiumSupport.tempDir.openDir();

  try {
    const srcCert = _path.default.resolve(tmpRoot, 'source.cer');

    await _appiumSupport.fs.writeFile(srcCert, cert);
    let {
      stdout
    } = await (0, _teen_process.exec)(openSsl, ['x509', '-noout', '-hash', '-in', srcCert]);
    const certHash = stdout.trim();

    _logger.default.debug(`Got certificate hash: ${certHash}`);

    _logger.default.debug('Preparing certificate content');

    ({
      stdout
    } = await (0, _teen_process.exec)(openSsl, ['x509', '-in', srcCert], {
      isBuffer: true
    }));
    let dstCertContent = stdout;
    ({
      stdout
    } = await (0, _teen_process.exec)(openSsl, ['x509', '-in', srcCert, '-text', '-fingerprint', '-noout'], {
      isBuffer: true
    }));
    dstCertContent = Buffer.concat([dstCertContent, stdout]);

    const dstCert = _path.default.resolve(tmpRoot, `${certHash}.0`);

    await _appiumSupport.fs.writeFile(dstCert, dstCertContent);

    _logger.default.debug('Remounting /system in rw mode');

    await (0, _asyncbox.retryInterval)(5, 2000, async () => await this.adbExec(['remount']));

    _logger.default.debug(`Uploading the generated certificate from '${dstCert}' to '${CERTS_ROOT}'`);

    await this.push(dstCert, CERTS_ROOT);

    _logger.default.debug('Remounting /system to confirm changes');

    await this.adbExec(['remount']);
  } catch (err) {
    throw new Error(`Cannot inject the custom certificate. ` + `Is the certificate properly encoded into base64-string? ` + `Do you have root permissions on the device? ` + `Original error: ${err.message}`);
  } finally {
    await _appiumSupport.fs.rimraf(tmpRoot);
  }
};

systemCallMethods.isMitmCertificateInstalled = async function isMitmCertificateInstalled(cert) {
  const openSsl = await (0, _helpers.getOpenSslForOs)();

  if (!_lodash.default.isBuffer(cert)) {
    cert = Buffer.from(cert, 'base64');
  }

  const tmpRoot = await _appiumSupport.tempDir.openDir();
  let certHash;

  try {
    const tmpCert = _path.default.resolve(tmpRoot, 'source.cer');

    await _appiumSupport.fs.writeFile(tmpCert, cert);
    const {
      stdout
    } = await (0, _teen_process.exec)(openSsl, ['x509', '-noout', '-hash', '-in', tmpCert]);
    certHash = stdout.trim();
  } catch (err) {
    throw new Error(`Cannot retrieve the certificate hash. ` + `Is the certificate properly encoded into base64-string? ` + `Original error: ${err.message}`);
  } finally {
    await _appiumSupport.fs.rimraf(tmpRoot);
  }

  const dstPath = _path.default.posix.resolve(CERTS_ROOT, `${certHash}.0`);

  _logger.default.debug(`Checking if the certificate is already installed at '${dstPath}'`);

  return await this.fileExists(dstPath);
};

var _default = systemCallMethods;
exports.default = _default;require('source-map-support').install();


//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/tools/system-calls.js"],"names":["systemCallMethods","DEFAULT_ADB_REBOOT_RETRIES","LINKER_WARNING_REGEXP","PROTOCOL_FAULT_ERROR_REGEXP","RegExp","DEVICE_NOT_FOUND_ERROR_REGEXP","DEVICE_CONNECTING_ERROR_REGEXP","CERTS_ROOT","getSdkBinaryPath","binaryName","sdkRoot","getBinaryFromSdkRoot","log","warn","getBinaryFromPath","getBinaryNameForOS","_","memoize","system","isWindows","includes","path","extname","binaries","fullBinaryName","binaryLocs","sep","map","x","resolve","buildToolsDirs","buildToolsVersion","filter","basename","isEmpty","info","push","flatten","dir","binaryLoc","loc","fs","exists","isNull","Error","JSON","stringify","which","e","getConnectedDevices","debug","stdout","executable","defaultArgs","message","listHeader","startingIndex","indexOf","slice","excludedLines","allowOfflineDevices","devices","split","trim","line","some","reduce","acc","udid","state","getDevicesWithRetry","timeoutMs","timer","timing","Timer","start","getDevices","getDuration","asMilliSeconds","toFixed","length","ign","restartAdb","suppressKillServer","killServer","error","adbPort","adbExec","exclusive","resetTelnetAuthToken","homeFolderPath","process","env","platform","dstPath","writeFile","adbExecEmu","cmd","verifyEmulatorConnected","isExecLocked","opts","cloneDeep","timeout","adbExecTimeout","DEFAULT_ADB_EXEC_TIMEOUT","timeoutCapName","isArray","adbRetried","execFunc","args","util","quote","replace","errText","stderr","protocolFaultError","test","deviceNotFoundError","deviceConnectingError","code","waitMs","Number","MAX_SAFE_INTEGER","intervalMs","shell","privileged","keepPrivileged","shouldRestoreUser","wasAlreadyRooted","isSuccessful","root","didCommandFail","err","unroot","createSubProcess","concat","SubProcess","getAdbPath","getAdbServerPort","getEmulatorPort","emulatorPort","port","getPortFromEmulatorString","emStr","portPattern","parseInt","exec","getConnectedEmulators","emulators","device","pluralize","setEmulatorPort","emPort","setDeviceId","deviceId","curDeviceId","argsHasDevice","splice","setDevice","deviceObj","getRunningAVD","avdName","emulator","runningAVDName","sendTelnetCommand","toLower","getRunningAVDWithRetry","runningAvd","killAllEmulators","killEmulator","hasValue","isEmulatorConnected","launchAVD","avdArgs","language","country","avdLaunchTimeout","avdReadyTimeout","retryTimes","emulatorBinaryPath","substr","checkAvdExist","launchArgs","isString","toLowerCase","toUpperCase","locale","proc","on","Boolean","signal","waitForEmulatorReady","getAdbVersion","adbVersion","parts","versionString","versionFloat","parseFloat","major","minor","patch","undefined","result","unknownOptionError","sdkVersion","existings","waitForDevice","appDeviceReadyTimeout","retries","ping","reboot","B","delay","setDeviceProperty","getDeviceProperty","msg","changeUserPrivileges","isElevated","isRoot","fileExists","remotePath","passFlag","checkCmd","ls","lines","l","fileSize","files","match","isNaN","installMitmCertificate","cert","openSsl","isBuffer","Buffer","from","tmpRoot","tempDir","openDir","srcCert","certHash","dstCertContent","dstCert","rimraf","isMitmCertificateInstalled","tmpCert","posix"],"mappings":";;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AAKA;;AACA;;AACA;;AAGA,IAAIA,iBAAiB,GAAG,EAAxB;AAEA,MAAMC,0BAA0B,GAAG,EAAnC;AAEA,MAAMC,qBAAqB,GAAG,sBAA9B;AACA,MAAMC,2BAA2B,GAAG,IAAIC,MAAJ,CAAW,gCAAX,EAA6C,GAA7C,CAApC;AACA,MAAMC,6BAA6B,GAAG,IAAID,MAAJ,CAAY,iCAAZ,EAA8C,GAA9C,CAAtC;AACA,MAAME,8BAA8B,GAAG,IAAIF,MAAJ,CAAW,gCAAX,EAA6C,GAA7C,CAAvC;AAEA,MAAMG,UAAU,GAAG,8BAAnB;;AAQAP,iBAAiB,CAACQ,gBAAlB,GAAqC,eAAeA,gBAAf,CAAiCC,UAAjC,EAA6C;AAChF,MAAI,KAAKC,OAAT,EAAkB;AAChB,WAAO,MAAM,KAAKC,oBAAL,CAA0BF,UAA1B,CAAb;AACD;;AACDG,kBAAIC,IAAJ,CAAU,sEAAD,GACN,kEADM,GAEN,yCAAwCJ,UAAW,GAFtD;;AAGA,SAAO,MAAM,KAAKK,iBAAL,CAAuBL,UAAvB,CAAb;AACD,CARD;;AAiBAT,iBAAiB,CAACe,kBAAlB,GAAuCC,gBAAEC,OAAF,CAAU,SAASF,kBAAT,CAA6BN,UAA7B,EAAyC;AACxF,MAAI,CAACS,sBAAOC,SAAP,EAAL,EAAyB;AACvB,WAAOV,UAAP;AACD;;AAED,MAAI,CAAC,SAAD,EAAY,WAAZ,EAAyB,aAAzB,EAAwCW,QAAxC,CAAiDX,UAAjD,CAAJ,EAAkE;AAChE,WAAQ,GAAEA,UAAW,MAArB;AACD;;AACD,MAAI,CAACY,cAAKC,OAAL,CAAab,UAAb,CAAL,EAA+B;AAC7B,WAAQ,GAAEA,UAAW,MAArB;AACD;;AACD,SAAOA,UAAP;AACD,CAZsC,CAAvC;;AA2BAT,iBAAiB,CAACW,oBAAlB,GAAyC,eAAeA,oBAAf,CAAqCF,UAArC,EAAiD;AACxF,MAAI,KAAKc,QAAL,CAAcd,UAAd,CAAJ,EAA+B;AAC7B,WAAO,KAAKc,QAAL,CAAcd,UAAd,CAAP;AACD;;AAED,QAAMe,cAAc,GAAG,KAAKT,kBAAL,CAAwBN,UAAxB,CAAvB;AACA,QAAMgB,UAAU,GAAG,CAAC,gBAAD,EAAmB,UAAnB,EAA+B,OAA/B,EAAyC,QAAOJ,cAAKK,GAAI,KAAzD,EAChBC,GADgB,CACXC,CAAD,IAAOP,cAAKQ,OAAL,CAAa,KAAKnB,OAAlB,EAA2BkB,CAA3B,EAA8BJ,cAA9B,CADK,CAAnB;AAGA,MAAIM,cAAc,GAAG,MAAM,gCAAkB,KAAKpB,OAAvB,CAA3B;;AACA,MAAI,KAAKqB,iBAAT,EAA4B;AAC1BD,IAAAA,cAAc,GAAGA,cAAc,CAC5BE,MADc,CACNJ,CAAD,IAAOP,cAAKY,QAAL,CAAcL,CAAd,MAAqB,KAAKG,iBAD1B,CAAjB;;AAEA,QAAIf,gBAAEkB,OAAF,CAAUJ,cAAV,CAAJ,EAA+B;AAC7BlB,sBAAIuB,IAAJ,CAAU,kDAAiD,KAAKJ,iBAAkB,GAAlF;AACD,KAFD,MAEO;AACLnB,sBAAIuB,IAAJ,CAAU,yBAAwBL,cAAe,GAAjD;AACD;AACF;;AACDL,EAAAA,UAAU,CAACW,IAAX,CAAgB,GAAIpB,gBAAEqB,OAAF,CAAUP,cAAc,CACzCH,GAD2B,CACtBW,GAAD,IAAS,CACZjB,cAAKQ,OAAL,CAAaS,GAAb,EAAkBd,cAAlB,CADY,EAEZH,cAAKQ,OAAL,CAAaS,GAAb,EAAkB,KAAlB,EAAyBd,cAAzB,CAFY,CADc,CAAV,CAApB;AAOA,MAAIe,SAAS,GAAG,IAAhB;;AACA,OAAK,MAAMC,GAAX,IAAkBf,UAAlB,EAA8B;AAC5B,QAAI,MAAMgB,kBAAGC,MAAH,CAAUF,GAAV,CAAV,EAA0B;AACxBD,MAAAA,SAAS,GAAGC,GAAZ;AACA;AACD;AACF;;AACD,MAAIxB,gBAAE2B,MAAF,CAASJ,SAAT,CAAJ,EAAyB;AACvB,UAAM,IAAIK,KAAJ,CAAW,mBAAkBpB,cAAe,QAAOqB,IAAI,CAACC,SAAL,CAAerB,UAAf,CAA2B,IAApE,GACb,mCAAkC,KAAKM,iBAAL,GAA0B,KAAI,KAAKA,iBAAkB,GAArD,GAA0D,EAAG,EADlF,GAEb,iBAAgB,KAAKrB,OAAQ,IAF1B,CAAN;AAGD;;AACDE,kBAAIuB,IAAJ,CAAU,UAASX,cAAe,WAAUe,SAAU,GAAtD;;AACA,OAAKhB,QAAL,CAAcd,UAAd,IAA4B8B,SAA5B;AACA,SAAOA,SAAP;AACD,CAzCD;;AAmDAvC,iBAAiB,CAACc,iBAAlB,GAAsC,eAAeA,iBAAf,CAAkCL,UAAlC,EAA8C;AAClF,MAAI,KAAKc,QAAL,CAAcd,UAAd,CAAJ,EAA+B;AAC7B,WAAO,KAAKc,QAAL,CAAcd,UAAd,CAAP;AACD;;AAED,QAAMe,cAAc,GAAG,KAAKT,kBAAL,CAAwBN,UAAxB,CAAvB;;AACA,MAAI;AACF,UAAM8B,SAAS,GAAG,MAAME,kBAAGM,KAAH,CAASvB,cAAT,CAAxB;;AACAZ,oBAAIuB,IAAJ,CAAU,UAASX,cAAe,WAAUe,SAAU,GAAtD;;AACA,SAAKhB,QAAL,CAAcd,UAAd,IAA4B8B,SAA5B;AACA,WAAOA,SAAP;AACD,GALD,CAKE,OAAOS,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,mBAAkBpB,cAAe,yCAAlC,GACb,2FADG,CAAN;AAED;AACF,CAfD;;AA+BAxB,iBAAiB,CAACiD,mBAAlB,GAAwC,eAAeA,mBAAf,GAAsC;AAC5ErC,kBAAIsC,KAAJ,CAAU,8BAAV;;AACA,MAAIC,MAAJ;;AACA,MAAI;AACF,KAAC;AAACA,MAAAA;AAAD,QAAW,MAAM,wBAAK,KAAKC,UAAL,CAAgB/B,IAArB,EAA2B,CAAC,GAAG,KAAK+B,UAAL,CAAgBC,WAApB,EAAiC,SAAjC,CAA3B,CAAlB;AACD,GAFD,CAEE,OAAOL,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,0DAAyDI,CAAC,CAACM,OAAQ,EAA9E,CAAN;AACD;;AACD,QAAMC,UAAU,GAAG,iBAAnB;AAIA,QAAMC,aAAa,GAAGL,MAAM,CAACM,OAAP,CAAeF,UAAf,CAAtB;;AACA,MAAIC,aAAa,GAAG,CAApB,EAAuB;AACrB,UAAM,IAAIZ,KAAJ,CAAW,kDAAiDO,MAAO,EAAnE,CAAN;AACD;;AAEDA,EAAAA,MAAM,GAAGA,MAAM,CAACO,KAAP,CAAaF,aAAb,CAAT;AACA,MAAIG,aAAa,GAAG,CAACJ,UAAD,EAAa,YAAb,EAA2B,UAA3B,CAApB;;AACA,MAAI,CAAC,KAAKK,mBAAV,EAA+B;AAC7BD,IAAAA,aAAa,CAACvB,IAAd,CAAmB,SAAnB;AACD;;AACD,QAAMyB,OAAO,GAAGV,MAAM,CAACW,KAAP,CAAa,IAAb,EACbnC,GADa,CACTX,gBAAE+C,IADO,EAEb/B,MAFa,CAELgC,IAAD,IAAUA,IAAI,IAAI,CAACL,aAAa,CAACM,IAAd,CAAoBrC,CAAD,IAAOoC,IAAI,CAAC5C,QAAL,CAAcQ,CAAd,CAA1B,CAFb,EAGbsC,MAHa,CAGN,CAACC,GAAD,EAAMH,IAAN,KAAe;AAErB,UAAM,CAACI,IAAD,EAAOC,KAAP,IAAgBL,IAAI,CAACF,KAAL,CAAW,KAAX,CAAtB;AACAK,IAAAA,GAAG,CAAC/B,IAAJ,CAAS;AAACgC,MAAAA,IAAD;AAAOC,MAAAA;AAAP,KAAT;AACA,WAAOF,GAAP;AACD,GARa,EAQX,EARW,CAAhB;;AASA,MAAInD,gBAAEkB,OAAF,CAAU2B,OAAV,CAAJ,EAAwB;AACtBjD,oBAAIsC,KAAJ,CAAU,yCAAV;AACD,GAFD,MAEO;AACLtC,oBAAIsC,KAAJ,CAAW,sBAAqBL,IAAI,CAACC,SAAL,CAAee,OAAf,CAAwB,EAAxD;AACD;;AACD,SAAOA,OAAP;AACD,CArCD;;AA+CA7D,iBAAiB,CAACsE,mBAAlB,GAAwC,eAAeA,mBAAf,CAAoCC,SAAS,GAAG,KAAhD,EAAuD;AAC7F,QAAMC,KAAK,GAAG,IAAIC,sBAAOC,KAAX,GAAmBC,KAAnB,EAAd;;AACA/D,kBAAIsC,KAAJ,CAAU,2CAAV;;AACA,QAAM0B,UAAU,GAAG,YAAY;AAC7B,QAAIJ,KAAK,CAACK,WAAN,GAAoBC,cAApB,GAAqCP,SAAzC,EAAoD;AAClD,YAAM,IAAI3B,KAAJ,CAAW,gDAA+C4B,KAAK,CAACK,WAAN,GAAoBC,cAApB,CAAmCC,OAAnC,CAA2C,CAA3C,CAA8C,KAAxG,CAAN;AACD;;AACD,QAAI;AACF,YAAMlB,OAAO,GAAG,MAAM,KAAKZ,mBAAL,EAAtB;;AACA,UAAIY,OAAO,CAACmB,MAAR,GAAiB,CAArB,EAAwB;AACtB,eAAOnB,OAAP;AACD;AACF,KALD,CAKE,OAAOoB,GAAP,EAAY,CAAE;;AAEhBrE,oBAAIsC,KAAJ,CAAU,kDAAV;;AACA,UAAM,KAAKgC,UAAL,EAAN;AAEA,UAAM,qBAAM,GAAN,CAAN;AACA,WAAO,MAAMN,UAAU,EAAvB;AACD,GAhBD;;AAiBA,SAAO,MAAMA,UAAU,EAAvB;AACD,CArBD;;AA0BA5E,iBAAiB,CAACkF,UAAlB,GAA+B,eAAeA,UAAf,GAA6B;AAC1D,MAAI,KAAKC,kBAAT,EAA6B;AAC3BvE,oBAAIsC,KAAJ,CAAW,qDAAX;;AACA;AACD;;AAEDtC,kBAAIsC,KAAJ,CAAU,gBAAV;;AACA,MAAI;AACF,UAAM,KAAKkC,UAAL,EAAN;AACD,GAFD,CAEE,OAAOpC,CAAP,EAAU;AACVpC,oBAAIyE,KAAJ,CAAW,8DAAX;AACD;AACF,CAZD;;AAiBArF,iBAAiB,CAACoF,UAAlB,GAA+B,eAAeA,UAAf,GAA6B;AAC1DxE,kBAAIsC,KAAJ,CAAW,+BAA8B,KAAKoC,OAAQ,GAAtD;;AACA,QAAM,KAAKC,OAAL,CAAa,CAAC,aAAD,CAAb,EAA8B;AAClCC,IAAAA,SAAS,EAAE;AADuB,GAA9B,CAAN;AAGD,CALD;;AAaAxF,iBAAiB,CAACyF,oBAAlB,GAAyCzE,gBAAEC,OAAF,CAAU,eAAewE,oBAAf,GAAuC;AAGxF,QAAMC,cAAc,GAAGC,OAAO,CAACC,GAAR,CAAaD,OAAO,CAACE,QAAR,KAAqB,OAAtB,GAAiC,aAAjC,GAAiD,MAA7D,CAAvB;;AACA,MAAI,CAACH,cAAL,EAAqB;AACnB9E,oBAAIC,IAAJ,CAAU,wGAAV;;AACA,WAAO,KAAP;AACD;;AACD,QAAMiF,OAAO,GAAGzE,cAAKQ,OAAL,CAAa6D,cAAb,EAA6B,8BAA7B,CAAhB;;AACA9E,kBAAIsC,KAAJ,CAAW,cAAa4C,OAAQ,4EAAhC;;AACA,MAAI;AACF,UAAMrD,kBAAGsD,SAAH,CAAaD,OAAb,EAAsB,EAAtB,CAAN;AACD,GAFD,CAEE,OAAO9C,CAAP,EAAU;AACVpC,oBAAIC,IAAJ,CAAU,SAAQmC,CAAC,CAACM,OAAQ,mCAAkCwC,OAAQ,gEAAtE;;AACA,WAAO,KAAP;AACD;;AACD,SAAO,IAAP;AACD,CAjBwC,CAAzC;;AAwBA9F,iBAAiB,CAACgG,UAAlB,GAA+B,eAAeA,UAAf,CAA2BC,GAA3B,EAAgC;AAC7D,QAAM,KAAKC,uBAAL,EAAN;AACA,QAAM,KAAKT,oBAAL,EAAN;AACA,QAAM,KAAKF,OAAL,CAAa,CAAC,KAAD,EAAQ,GAAGU,GAAX,CAAb,CAAN;AACD,CAJD;;AAMA,IAAIE,YAAY,GAAG,KAAnB;;AAgBAnG,iBAAiB,CAACuF,OAAlB,GAA4B,eAAeA,OAAf,CAAwBU,GAAxB,EAA6BG,IAAI,GAAG,EAApC,EAAwC;AAClE,MAAI,CAACH,GAAL,EAAU;AACR,UAAM,IAAIrD,KAAJ,CAAU,4CAAV,CAAN;AACD;;AAEDwD,EAAAA,IAAI,GAAGpF,gBAAEqF,SAAF,CAAYD,IAAZ,CAAP;AAEAA,EAAAA,IAAI,CAACE,OAAL,GAAeF,IAAI,CAACE,OAAL,IAAgB,KAAKC,cAArB,IAAuCC,iCAAtD;AACAJ,EAAAA,IAAI,CAACK,cAAL,GAAsBL,IAAI,CAACK,cAAL,IAAuB,gBAA7C;AAEAR,EAAAA,GAAG,GAAGjF,gBAAE0F,OAAF,CAAUT,GAAV,IAAiBA,GAAjB,GAAuB,CAACA,GAAD,CAA7B;AACA,MAAIU,UAAU,GAAG,KAAjB;;AACA,QAAMC,QAAQ,GAAG,YAAY;AAC3B,QAAI;AACF,YAAMC,IAAI,GAAG,CAAC,GAAG,KAAKzD,UAAL,CAAgBC,WAApB,EAAiC,GAAG4C,GAApC,CAAb;;AACArF,sBAAIsC,KAAJ,CAAW,YAAW,KAAKE,UAAL,CAAgB/B,IAAK,IAAGyF,oBAAKC,KAAL,CAAWF,IAAX,CAAiB,GAA/D;;AACA,UAAI;AAAC1D,QAAAA;AAAD,UAAW,MAAM,wBAAK,KAAKC,UAAL,CAAgB/B,IAArB,EAA2BwF,IAA3B,EAAiCT,IAAjC,CAArB;AAGAjD,MAAAA,MAAM,GAAGA,MAAM,CAAC6D,OAAP,CAAe9G,qBAAf,EAAsC,EAAtC,EAA0C6D,IAA1C,EAAT;AACA,aAAOZ,MAAP;AACD,KARD,CAQE,OAAOH,CAAP,EAAU;AACV,YAAMiE,OAAO,GAAI,GAAEjE,CAAC,CAACM,OAAQ,KAAIN,CAAC,CAACG,MAAO,KAAIH,CAAC,CAACkE,MAAO,EAAvD;AACA,YAAMC,kBAAkB,GAAGhH,2BAA2B,CAACiH,IAA5B,CAAiCH,OAAjC,CAA3B;AACA,YAAMI,mBAAmB,GAAGhH,6BAA6B,CAAC+G,IAA9B,CAAmCH,OAAnC,CAA5B;AACA,YAAMK,qBAAqB,GAAGhH,8BAA8B,CAAC8G,IAA/B,CAAoCH,OAApC,CAA9B;;AACA,UAAIE,kBAAkB,IAAIE,mBAAtB,IAA6CC,qBAAjD,EAAwE;AACtE1G,wBAAIuB,IAAJ,CAAU,4DAA2D8D,GAAI,EAAzE;;AACA,cAAM,qBAAM,IAAN,CAAN;AACA,cAAM,KAAK3B,mBAAL,EAAN;;AAGA,YAAIqC,UAAJ,EAAgB;AACdA,UAAAA,UAAU,GAAG,IAAb;AACA,iBAAO,MAAMC,QAAQ,EAArB;AACD;AACF;;AAED,UAAI5D,CAAC,CAACuE,IAAF,KAAW,CAAX,IAAgBvE,CAAC,CAACG,MAAtB,EAA8B;AAC5B,eAAOH,CAAC,CAACG,MAAF,CAAS6D,OAAT,CAAiB9G,qBAAjB,EAAwC,EAAxC,EAA4C6D,IAA5C,EAAP;AACD;;AAED,UAAI/C,gBAAE2B,MAAF,CAASK,CAAC,CAACuE,IAAX,CAAJ,EAAsB;AACpBvE,QAAAA,CAAC,CAACM,OAAF,GAAa,6CAA4CN,CAAC,CAACM,OAAQ,KAAvD,GACT,uBAAsB8C,IAAI,CAACE,OAAQ,4CAA2CF,IAAI,CAACK,cAAe,cADrG;AAED,OAHD,MAGO;AACLzD,QAAAA,CAAC,CAACM,OAAF,GAAa,6CAA4CN,CAAC,CAACM,OAAQ,KAAvD,GACT,YAAW,CAACN,CAAC,CAACkE,MAAF,IAAY,EAAb,EAAiBnD,IAAjB,EAAwB,aAAYf,CAAC,CAACuE,IAAK,GADzD;AAED;;AACD,YAAMvE,CAAN;AACD;AACF,GAvCD;;AAyCA,MAAImD,YAAJ,EAAkB;AAChBvF,oBAAIsC,KAAJ,CAAU,4DAAV;;AACA,UAAM,gCAAiB,MAAM,CAACiD,YAAxB,EAAsC;AAC1CqB,MAAAA,MAAM,EAAEC,MAAM,CAACC,gBAD2B;AAE1CC,MAAAA,UAAU,EAAE;AAF8B,KAAtC,CAAN;;AAIA/G,oBAAIsC,KAAJ,CAAU,yCAAV;AACD;;AACD,MAAIkD,IAAI,CAACZ,SAAT,EAAoB;AAClBW,IAAAA,YAAY,GAAG,IAAf;AACD;;AACD,MAAI;AACF,WAAO,MAAMS,QAAQ,EAArB;AACD,GAFD,SAEU;AACR,QAAIR,IAAI,CAACZ,SAAT,EAAoB;AAClBW,MAAAA,YAAY,GAAG,KAAf;AACD;AACF;AACF,CAvED;;AA8FAnG,iBAAiB,CAAC4H,KAAlB,GAA0B,eAAeA,KAAf,CAAsB3B,GAAtB,EAA2BG,IAAI,GAAG,EAAlC,EAAsC;AAC9D,QAAM;AACJyB,IAAAA,UADI;AAEJC,IAAAA;AAFI,MAGF1B,IAHJ;AAMA,MAAI2B,iBAAiB,GAAG,KAAxB;;AACA,MAAIF,UAAJ,EAAgB;AACdjH,oBAAIuB,IAAJ,CAAU,cAAa8D,GAAI,6DAA3B;;AACA,UAAM;AAAC+B,MAAAA,gBAAD;AAAmBC,MAAAA;AAAnB,QAAmC,MAAM,KAAKC,IAAL,EAA/C;AACAH,IAAAA,iBAAiB,GAAG,CAACC,gBAArB;;AACA,QAAIA,gBAAJ,EAAsB;AACpBpH,sBAAIuB,IAAJ,CAAS,gCAAT;AACD,KAFD,MAEO;AACLvB,sBAAIuB,IAAJ,CAAS8F,YAAY,GAAG,iCAAH,GAAuC,4BAA5D;AACD;AACF;;AACD,MAAIE,cAAc,GAAG,KAArB;;AACA,MAAI;AACF,QAAI;AACF,aAAO,MAAM,KAAK5C,OAAL,CAAavE,gBAAE0F,OAAF,CAAUT,GAAV,IAAiB,CAAC,OAAD,EAAU,GAAGA,GAAb,CAAjB,GAAqC,CAAC,OAAD,EAAUA,GAAV,CAAlD,EAAkEG,IAAlE,CAAb;AACD,KAFD,CAEE,OAAOgC,GAAP,EAAY;AACZD,MAAAA,cAAc,GAAG,IAAjB;AACA,YAAMC,GAAN;AACD;AACF,GAPD,SAOU;AAER,QAAIP,UAAU,IAAIE,iBAAd,KAAoC,CAACD,cAAD,IAAmBK,cAAvD,CAAJ,EAA4E;AAC1E,YAAM;AAACF,QAAAA;AAAD,UAAiB,MAAM,KAAKI,MAAL,EAA7B;;AACAzH,sBAAIsC,KAAJ,CAAU+E,YAAY,GAAG,mCAAH,GAAyC,2CAA/D;AACD;AACF;AACF,CAjCD;;AAmCAjI,iBAAiB,CAACsI,gBAAlB,GAAqC,SAASA,gBAAT,CAA2BzB,IAAI,GAAG,EAAlC,EAAsC;AAEzEA,EAAAA,IAAI,GAAG,KAAKzD,UAAL,CAAgBC,WAAhB,CAA4BkF,MAA5B,CAAmC1B,IAAnC,CAAP;;AACAjG,kBAAIsC,KAAJ,CAAW,sCAAqCL,IAAI,CAACC,SAAL,CAAe+D,IAAf,CAAqB,EAArE;;AACA,SAAO,IAAI2B,wBAAJ,CAAe,KAAKC,UAAL,EAAf,EAAkC5B,IAAlC,CAAP;AACD,CALD;;AAYA7G,iBAAiB,CAAC0I,gBAAlB,GAAqC,SAASA,gBAAT,GAA6B;AAChE,SAAO,KAAKpD,OAAZ;AACD,CAFD;;AAUAtF,iBAAiB,CAAC2I,eAAlB,GAAoC,eAAeA,eAAf,GAAkC;AACpE/H,kBAAIsC,KAAJ,CAAU,+BAAV;;AACA,MAAI,KAAK0F,YAAL,KAAsB,IAA1B,EAAgC;AAC9B,WAAO,KAAKA,YAAZ;AACD;;AACD,MAAI;AACF,QAAI/E,OAAO,GAAG,MAAM,KAAKZ,mBAAL,EAApB;AACA,QAAI4F,IAAI,GAAG,KAAKC,yBAAL,CAA+BjF,OAAO,CAAC,CAAD,CAAP,CAAWO,IAA1C,CAAX;;AACA,QAAIyE,IAAJ,EAAU;AACR,aAAOA,IAAP;AACD,KAFD,MAEO;AACL,YAAM,IAAIjG,KAAJ,CAAW,yBAAX,CAAN;AACD;AACF,GARD,CAQE,OAAOI,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,yCAAwCI,CAAC,CAACM,OAAQ,EAA7D,CAAN;AACD;AACF,CAhBD;;AAyBAtD,iBAAiB,CAAC8I,yBAAlB,GAA8C,SAASA,yBAAT,CAAoCC,KAApC,EAA2C;AACvF,MAAIC,WAAW,GAAG,gBAAlB;;AACA,MAAIA,WAAW,CAAC5B,IAAZ,CAAiB2B,KAAjB,CAAJ,EAA6B;AAC3B,WAAOE,QAAQ,CAACD,WAAW,CAACE,IAAZ,CAAiBH,KAAjB,EAAwB,CAAxB,CAAD,EAA6B,EAA7B,CAAf;AACD;;AACD,SAAO,KAAP;AACD,CAND;;AAaA/I,iBAAiB,CAACmJ,qBAAlB,GAA0C,eAAeA,qBAAf,GAAwC;AAChFvI,kBAAIsC,KAAJ,CAAU,6BAAV;;AACA,MAAI;AACF,QAAIW,OAAO,GAAG,MAAM,KAAKZ,mBAAL,EAApB;AACA,QAAImG,SAAS,GAAG,EAAhB;;AACA,SAAK,IAAIC,MAAT,IAAmBxF,OAAnB,EAA4B;AAC1B,UAAIgF,IAAI,GAAG,KAAKC,yBAAL,CAA+BO,MAAM,CAACjF,IAAtC,CAAX;;AACA,UAAIyE,IAAJ,EAAU;AACRQ,QAAAA,MAAM,CAACR,IAAP,GAAcA,IAAd;AACAO,QAAAA,SAAS,CAAChH,IAAV,CAAeiH,MAAf;AACD;AACF;;AACDzI,oBAAIsC,KAAJ,CAAW,GAAE4D,oBAAKwC,SAAL,CAAe,UAAf,EAA2BF,SAAS,CAACpE,MAArC,EAA6C,IAA7C,CAAmD,YAAhE;;AACA,WAAOoE,SAAP;AACD,GAZD,CAYE,OAAOpG,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,4CAA2CI,CAAC,CAACM,OAAQ,EAAhE,CAAN;AACD;AACF,CAjBD;;AAwBAtD,iBAAiB,CAACuJ,eAAlB,GAAoC,SAASA,eAAT,CAA0BC,MAA1B,EAAkC;AACpE,OAAKZ,YAAL,GAAoBY,MAApB;AACD,CAFD;;AASAxJ,iBAAiB,CAACyJ,WAAlB,GAAgC,SAASA,WAAT,CAAsBC,QAAtB,EAAgC;AAC9D9I,kBAAIsC,KAAJ,CAAW,wBAAuBwG,QAAS,EAA3C;;AACA,OAAKC,WAAL,GAAmBD,QAAnB;AACA,MAAIE,aAAa,GAAG,KAAKxG,UAAL,CAAgBC,WAAhB,CAA4BI,OAA5B,CAAoC,IAApC,CAApB;;AACA,MAAImG,aAAa,KAAK,CAAC,CAAvB,EAA0B;AAExB,SAAKxG,UAAL,CAAgBC,WAAhB,CAA4BwG,MAA5B,CAAmCD,aAAnC,EAAkD,CAAlD;AACD;;AACD,OAAKxG,UAAL,CAAgBC,WAAhB,CAA4BjB,IAA5B,CAAiC,IAAjC,EAAuCsH,QAAvC;AACD,CATD;;AAgBA1J,iBAAiB,CAAC8J,SAAlB,GAA8B,SAASA,SAAT,CAAoBC,SAApB,EAA+B;AAC3D,MAAIL,QAAQ,GAAGK,SAAS,CAAC3F,IAAzB;AACA,MAAIoF,MAAM,GAAG,KAAKV,yBAAL,CAA+BY,QAA/B,CAAb;AACA,OAAKH,eAAL,CAAqBC,MAArB;AACA,OAAKC,WAAL,CAAiBC,QAAjB;AACD,CALD;;AAaA1J,iBAAiB,CAACgK,aAAlB,GAAkC,eAAeA,aAAf,CAA8BC,OAA9B,EAAuC;AACvErJ,kBAAIsC,KAAJ,CAAW,mBAAkB+G,OAAQ,YAArC;;AACA,MAAI;AACF,UAAMb,SAAS,GAAG,MAAM,KAAKD,qBAAL,EAAxB;;AACA,SAAK,MAAMe,QAAX,IAAuBd,SAAvB,EAAkC;AAChC,WAAKG,eAAL,CAAqBW,QAAQ,CAACrB,IAA9B;AACA,YAAMsB,cAAc,GAAG,MAAM,KAAKC,iBAAL,CAAuB,UAAvB,CAA7B;;AACA,UAAIpJ,gBAAEqJ,OAAF,CAAUJ,OAAV,MAAuBjJ,gBAAEqJ,OAAF,CAAUF,cAAV,CAA3B,EAAsD;AACpDvJ,wBAAIsC,KAAJ,CAAW,mBAAkB+G,OAAQ,aAAYC,QAAQ,CAACrB,IAAK,EAA/D;;AACA,aAAKY,WAAL,CAAiBS,QAAQ,CAAC9F,IAA1B;AACA,eAAO8F,QAAP;AACD;AACF;;AACDtJ,oBAAIsC,KAAJ,CAAW,aAAY+G,OAAQ,eAA/B;;AACA,WAAO,IAAP;AACD,GAbD,CAaE,OAAOjH,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,sCAAqCI,CAAC,CAACM,OAAQ,EAA1D,CAAN;AACD;AACF,CAlBD;;AA8BAtD,iBAAiB,CAACsK,sBAAlB,GAA2C,eAAeA,sBAAf,CAAuCL,OAAvC,EAAgD1F,SAAS,GAAG,KAA5D,EAAmE;AAC5G,MAAIgG,UAAJ;;AACA,MAAI;AACF,UAAM,gCAAiB,YAAY;AACjC,UAAI;AACFA,QAAAA,UAAU,GAAG,MAAM,KAAKP,aAAL,CAAmBC,OAAO,CAACjD,OAAR,CAAgB,GAAhB,EAAqB,EAArB,CAAnB,CAAnB;AACA,eAAOuD,UAAP;AACD,OAHD,CAGE,OAAOvH,CAAP,EAAU;AACVpC,wBAAIsC,KAAJ,CAAUF,CAAC,CAACM,OAAZ;;AACA,eAAO,KAAP;AACD;AACF,KARK,EAQH;AACDkE,MAAAA,MAAM,EAAEjD,SADP;AAEDoD,MAAAA,UAAU,EAAE;AAFX,KARG,CAAN;AAYD,GAbD,CAaE,OAAO3E,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,iDAAgDI,CAAC,CAACM,OAAQ,EAArE,CAAN;AACD;;AACD,SAAOiH,UAAP;AACD,CAnBD;;AA0BAvK,iBAAiB,CAACwK,gBAAlB,GAAqC,eAAeA,gBAAf,GAAmC;AACtE,MAAIvE,GAAJ,EAASY,IAAT;;AACA,MAAI3F,sBAAOC,SAAP,EAAJ,EAAwB;AACtB8E,IAAAA,GAAG,GAAG,UAAN;AACAY,IAAAA,IAAI,GAAG,CAAC,UAAD,EAAa,KAAb,EAAoB,cAApB,CAAP;AACD,GAHD,MAGO;AACLZ,IAAAA,GAAG,GAAG,kBAAN;AACAY,IAAAA,IAAI,GAAG,CAAC,IAAD,EAAO,WAAP,CAAP;AACD;;AACD,MAAI;AACF,UAAM,wBAAKZ,GAAL,EAAUY,IAAV,CAAN;AACD,GAFD,CAEE,OAAO7D,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,4CAA2CI,CAAC,CAACM,OAAQ,EAAhE,CAAN;AACD;AACF,CAdD;;AA2BAtD,iBAAiB,CAACyK,YAAlB,GAAiC,eAAeA,YAAf,CAA6BR,OAAO,GAAG,IAAvC,EAA6C3D,OAAO,GAAG,KAAvD,EAA8D;AAC7F,MAAIQ,oBAAK4D,QAAL,CAAcT,OAAd,CAAJ,EAA4B;AAC1BrJ,oBAAIsC,KAAJ,CAAW,gBAAe+G,OAAQ,GAAlC;;AACA,UAAMZ,MAAM,GAAG,MAAM,KAAKW,aAAL,CAAmBC,OAAnB,CAArB;;AACA,QAAI,CAACZ,MAAL,EAAa;AACXzI,sBAAIuB,IAAJ,CAAU,qBAAoB8H,OAAQ,gCAAtC;;AACA,aAAO,KAAP;AACD;AACF,GAPD,MAOO;AAELrJ,oBAAIsC,KAAJ,CAAW,wBAAuB,KAAKyG,WAAY,GAAnD;;AACA,QAAI,EAAC,MAAM,KAAKgB,mBAAL,EAAP,CAAJ,EAAuC;AACrC/J,sBAAIsC,KAAJ,CAAW,qBAAoB,KAAKyG,WAAY,qCAAhD;;AACA,aAAO,KAAP;AACD;AACF;;AACD,QAAM,KAAKpE,OAAL,CAAa,CAAC,KAAD,EAAQ,MAAR,CAAb,CAAN;;AACA3E,kBAAIsC,KAAJ,CAAW,iBAAgBoD,OAAQ,0BAAyB2D,OAAO,GAAGA,OAAH,GAAa,KAAKN,WAAY,aAAjG;;AACA,MAAI;AACF,UAAM,gCAAiB,YAAY;AACjC,UAAI;AACF,eAAO7C,oBAAK4D,QAAL,CAAcT,OAAd,IACH,EAAC,MAAM,KAAKD,aAAL,CAAmBC,OAAnB,CAAP,CADG,GAEH,EAAC,MAAM,KAAKU,mBAAL,EAAP,CAFJ;AAGD,OAJD,CAIE,OAAO1F,GAAP,EAAY,CAAE;;AAChB,aAAO,KAAP;AACD,KAPK,EAOH;AACDuC,MAAAA,MAAM,EAAElB,OADP;AAEDqB,MAAAA,UAAU,EAAE;AAFX,KAPG,CAAN;AAWD,GAZD,CAYE,OAAO3E,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,iBAAgBqH,OAAO,GAAGA,OAAH,GAAa,KAAKN,WAAY,yCAAwCrD,OAAQ,QAAhH,CAAN;AACD;;AACD1F,kBAAIuB,IAAJ,CAAU,4BAA2B8H,OAAO,GAAGA,OAAH,GAAa,KAAKN,WAAY,YAA1E;;AACA,SAAO,IAAP;AACD,CAnCD;;AAgDA3J,iBAAiB,CAAC4K,SAAlB,GAA8B,eAAeA,SAAf,CAA0BX,OAA1B,EAAmCY,OAAnC,EAA4CC,QAA5C,EAAsDC,OAAtD,EAC5BC,gBAAgB,GAAG,KADS,EACFC,eAAe,GAAG,KADhB,EACuBC,UAAU,GAAG,CADpC,EACuC;AACnEtK,kBAAIsC,KAAJ,CAAW,+BAA8B+G,OAAQ,kBAAvC,GACC,GAAEe,gBAAiB,uBAAsBC,eAAgB,IADpE;;AAEA,MAAIE,kBAAkB,GAAG,MAAM,KAAK3K,gBAAL,CAAsB,UAAtB,CAA/B;;AACA,MAAIyJ,OAAO,CAAC,CAAD,CAAP,KAAe,GAAnB,EAAwB;AACtBA,IAAAA,OAAO,GAAGA,OAAO,CAACmB,MAAR,CAAe,CAAf,CAAV;AACD;;AACD,QAAM,KAAKC,aAAL,CAAmBpB,OAAnB,CAAN;AACA,MAAIqB,UAAU,GAAG,CAAC,MAAD,EAASrB,OAAT,CAAjB;;AACA,MAAIjJ,gBAAEuK,QAAF,CAAWT,QAAX,CAAJ,EAA0B;AACxBlK,oBAAIsC,KAAJ,CAAW,sCAAqC4H,QAAS,EAAzD;;AACAQ,IAAAA,UAAU,CAAClJ,IAAX,CAAgB,OAAhB,EAA0B,wBAAuB0I,QAAQ,CAACU,WAAT,EAAuB,EAAxE;AACD;;AACD,MAAIxK,gBAAEuK,QAAF,CAAWR,OAAX,CAAJ,EAAyB;AACvBnK,oBAAIsC,KAAJ,CAAW,qCAAoC6H,OAAQ,EAAvD;;AACAO,IAAAA,UAAU,CAAClJ,IAAX,CAAgB,OAAhB,EAA0B,uBAAsB2I,OAAO,CAACU,WAAR,EAAsB,EAAtE;AACD;;AACD,MAAIC,MAAJ;;AACA,MAAI1K,gBAAEuK,QAAF,CAAWT,QAAX,KAAwB9J,gBAAEuK,QAAF,CAAWR,OAAX,CAA5B,EAAiD;AAC/CW,IAAAA,MAAM,GAAGZ,QAAQ,CAACU,WAAT,KAAyB,GAAzB,GAA+BT,OAAO,CAACU,WAAR,EAAxC;AACD,GAFD,MAEO,IAAIzK,gBAAEuK,QAAF,CAAWT,QAAX,CAAJ,EAA0B;AAC/BY,IAAAA,MAAM,GAAGZ,QAAQ,CAACU,WAAT,EAAT;AACD,GAFM,MAEA,IAAIxK,gBAAEuK,QAAF,CAAWR,OAAX,CAAJ,EAAyB;AAC9BW,IAAAA,MAAM,GAAGX,OAAT;AACD;;AACD,MAAI/J,gBAAEuK,QAAF,CAAWG,MAAX,CAAJ,EAAwB;AACtB9K,oBAAIsC,KAAJ,CAAW,oCAAmCwI,MAAO,EAArD;;AACAJ,IAAAA,UAAU,CAAClJ,IAAX,CAAgB,OAAhB,EAA0B,sBAAqBsJ,MAAO,EAAtD;AACD;;AACD,MAAI,CAAC1K,gBAAEkB,OAAF,CAAU2I,OAAV,CAAL,EAAyB;AACvBS,IAAAA,UAAU,CAAClJ,IAAX,CAAgB,IAAIpB,gBAAE0F,OAAF,CAAUmE,OAAV,IAAqBA,OAArB,GAA+BA,OAAO,CAAC/G,KAAR,CAAc,GAAd,CAAnC,CAAhB;AACD;;AACDlD,kBAAIsC,KAAJ,CAAW,YAAWiI,kBAAmB,gBAAetI,IAAI,CAACC,SAAL,CAAewI,UAAf,CAA2B,EAAnF;;AACA,MAAIK,IAAI,GAAG,IAAInD,wBAAJ,CAAe2C,kBAAf,EAAmCG,UAAnC,CAAX;AACA,QAAMK,IAAI,CAAChH,KAAL,CAAW,CAAX,CAAN;AACAgH,EAAAA,IAAI,CAACC,EAAL,CAAQ,QAAR,EAAkB,CAACzI,MAAD,EAAS+D,MAAT,KAAoB;AACpC,SAAK,IAAIlD,IAAT,IAAiB,CAACb,MAAM,IAAI+D,MAAV,IAAoB,EAArB,EAAyBpD,KAAzB,CAA+B,IAA/B,EAAqC9B,MAArC,CAA4C6J,OAA5C,CAAjB,EAAuE;AACrEjL,sBAAIuB,IAAJ,CAAU,gBAAe6B,IAAK,EAA9B;AACD;AACF,GAJD;AAKA2H,EAAAA,IAAI,CAACC,EAAL,CAAQ,KAAR,EAAe,CAACrE,IAAD,EAAOuE,MAAP,KAAkB;AAC/BlL,oBAAIC,IAAJ,CAAU,gBAAeoJ,OAAQ,qBAAoB1C,IAAK,GAAEuE,MAAM,GAAI,YAAWA,MAAO,EAAtB,GAA0B,EAAG,EAA/F;AACD,GAFD;AAGA,QAAM,qBAAMZ,UAAN,EAAkB,YAAY,MAAM,KAAKZ,sBAAL,CAA4BL,OAA5B,EAAqCe,gBAArC,CAApC,CAAN;AACA,QAAM,KAAKe,oBAAL,CAA0Bd,eAA1B,CAAN;AACA,SAAOU,IAAP;AACD,CA/CD;;AAgEA3L,iBAAiB,CAACgM,aAAlB,GAAkChL,gBAAEC,OAAF,CAAU,eAAe+K,aAAf,GAAgC;AAC1E,MAAI;AACF,QAAIC,UAAU,GAAG,CAAC,MAAM,KAAK1G,OAAL,CAAa,SAAb,CAAP,EACdyB,OADc,CACN,mDADM,EAC+C,IAD/C,CAAjB;AAEA,QAAIkF,KAAK,GAAGD,UAAU,CAACnI,KAAX,CAAiB,GAAjB,CAAZ;AACA,WAAO;AACLqI,MAAAA,aAAa,EAAEF,UADV;AAELG,MAAAA,YAAY,EAAEC,UAAU,CAACJ,UAAD,CAFnB;AAGLK,MAAAA,KAAK,EAAErD,QAAQ,CAACiD,KAAK,CAAC,CAAD,CAAN,EAAW,EAAX,CAHV;AAILK,MAAAA,KAAK,EAAEtD,QAAQ,CAACiD,KAAK,CAAC,CAAD,CAAN,EAAW,EAAX,CAJV;AAKLM,MAAAA,KAAK,EAAEN,KAAK,CAAC,CAAD,CAAL,GAAWjD,QAAQ,CAACiD,KAAK,CAAC,CAAD,CAAN,EAAW,EAAX,CAAnB,GAAoCO;AALtC,KAAP;AAOD,GAXD,CAWE,OAAOzJ,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,+CAA8CI,CAAC,CAACM,OAAQ,KAAzD,GACK,YAAW,CAACN,CAAC,CAACkE,MAAF,IAAY,EAAb,EAAiBnD,IAAjB,EAAwB,aAAYf,CAAC,CAACuE,IAAK,GADrE,CAAN;AAED;AACF,CAhBiC,CAAlC;;AAwBAvH,iBAAiB,CAACqL,aAAlB,GAAkC,eAAeA,aAAf,CAA8BpB,OAA9B,EAAuC;AACvE,MAAIhE,GAAJ,EAASyG,MAAT;;AACA,MAAI;AACFzG,IAAAA,GAAG,GAAG,MAAM,KAAKzF,gBAAL,CAAsB,UAAtB,CAAZ;AACAkM,IAAAA,MAAM,GAAG,MAAM,wBAAKzG,GAAL,EAAU,CAAC,YAAD,CAAV,CAAf;AACD,GAHD,CAGE,OAAOjD,CAAP,EAAU;AACV,QAAI2J,kBAAkB,GAAG,IAAIvM,MAAJ,CAAW,4BAAX,EAAyC,GAAzC,EAA8CgH,IAA9C,CAAmDpE,CAAC,CAACkE,MAArD,CAAzB;;AACA,QAAI,CAACyF,kBAAL,EAAyB;AACvB,YAAM,IAAI/J,KAAJ,CAAW,mDAAkDI,CAAC,CAACM,OAAQ,KAA7D,GACC,YAAW,CAACN,CAAC,CAACkE,MAAF,IAAY,EAAb,EAAiBnD,IAAjB,EAAwB,aAAYf,CAAC,CAACuE,IAAK,GADjE,CAAN;AAGD;;AACD,UAAMqF,UAAU,GAAG,MAAM,kCAAzB;AACA,QAAInM,UAAU,GAAG,SAAjB;;AACA,QAAImM,UAAJ,EAAgB;AACd,UAAIA,UAAU,CAACN,KAAX,IAAoB,EAAxB,EAA4B;AAC1B7L,QAAAA,UAAU,GAAG,YAAb;AACD;AACF,KAJD,MAIO;AACLG,sBAAIC,IAAJ,CAAU,8BAA6BJ,UAAW,yCAAlD;AACD;;AAEDwF,IAAAA,GAAG,GAAG,MAAM,KAAKzF,gBAAL,CAAsBC,UAAtB,CAAZ;AACAiM,IAAAA,MAAM,GAAG,MAAM,wBAAKzG,GAAL,EAAU,CAAC,MAAD,EAAS,KAAT,EAAgB,IAAhB,CAAV,CAAf;AACD;;AACD,MAAIyG,MAAM,CAACvJ,MAAP,CAAcM,OAAd,CAAsBwG,OAAtB,MAAmC,CAAC,CAAxC,EAA2C;AACzC,QAAI4C,SAAS,GAAI,IAAGH,MAAM,CAACvJ,MAAP,CAAcY,IAAd,GAAqBiD,OAArB,CAA6B,OAA7B,EAAsC,MAAtC,CAA8C,GAAlE;AACA,UAAM,IAAIpE,KAAJ,CAAW,QAAOqH,OAAQ,uEAAsE4C,SAAU,GAA1G,CAAN;AACD;AACF,CA7BD;;AAqCA7M,iBAAiB,CAAC+L,oBAAlB,GAAyC,eAAeA,oBAAf,CAAqCxH,SAAS,GAAG,KAAjD,EAAwD;AAC/F,MAAI;AACF,UAAM,gCAAiB,YAAY;AACjC,UAAI;AACF,YAAI,CAAC,CAAC,MAAM,KAAKqD,KAAL,CAAW,CAAC,SAAD,EAAY,mBAAZ,CAAX,CAAP,EAAqDxG,QAArD,CAA8D,SAA9D,CAAL,EAA+E;AAC7E,iBAAO,KAAP;AACD;;AAID,eAAO,aAAagG,IAAb,CAAkB,MAAM,KAAKQ,KAAL,CAAW,CAAC,IAAD,EAAO,sBAAP,CAAX,CAAxB,CAAP;AACD,OARD,CAQE,OAAOQ,GAAP,EAAY;AACZxH,wBAAIsC,KAAJ,CAAW,qDAAoDkF,GAAG,CAAC9E,OAAQ,EAA3E;;AACA,eAAO,KAAP;AACD;AACF,KAbK,EAaH;AACDkE,MAAAA,MAAM,EAAEjD,SADP;AAEDoD,MAAAA,UAAU,EAAE;AAFX,KAbG,CAAN;AAiBD,GAlBD,CAkBE,OAAO3E,CAAP,EAAU;AACV,UAAM,IAAIJ,KAAJ,CAAW,gCAA+B2B,SAAU,IAApD,CAAN;AACD;AACF,CAtBD;;AA8BAvE,iBAAiB,CAAC8M,aAAlB,GAAkC,eAAeA,aAAf,CAA8BC,qBAAqB,GAAG,EAAtD,EAA0D;AAC1F,OAAKA,qBAAL,GAA6BA,qBAA7B;AACA,QAAMC,OAAO,GAAG,CAAhB;AACA,QAAM1G,OAAO,GAAG2C,QAAQ,CAAC,KAAK8D,qBAAN,EAA6B,EAA7B,CAAR,GAA2CC,OAA3C,GAAqD,IAArE;AACA,QAAM,qBAAMA,OAAN,EAAe,YAAY;AAC/B,QAAI;AACF,YAAM,KAAKzH,OAAL,CAAa,iBAAb,EAAgC;AAACe,QAAAA;AAAD,OAAhC,CAAN;AACA,YAAM,KAAK2G,IAAL,EAAN;AACD,KAHD,CAGE,OAAOjK,CAAP,EAAU;AACV,YAAM,KAAKkC,UAAL,EAAN;AACA,YAAM,KAAKjC,mBAAL,EAAN;AACA,YAAM,IAAIL,KAAJ,CAAW,kEAAiEI,CAAC,CAACM,OAAQ,GAAtF,CAAN;AACD;AACF,GATK,CAAN;AAUD,CAdD;;AAsBAtD,iBAAiB,CAACkN,MAAlB,GAA2B,eAAeA,MAAf,CAAuBF,OAAO,GAAG/M,0BAAjC,EAA6D;AAEtF,QAAM;AAAE+H,IAAAA;AAAF,MAAuB,MAAM,KAAKE,IAAL,EAAnC;;AACA,MAAI;AAEF,UAAM,KAAKN,KAAL,CAAW,CAAC,MAAD,CAAX,CAAN;AACA,UAAMuF,kBAAEC,KAAF,CAAQ,IAAR,CAAN;AACA,UAAM,KAAKC,iBAAL,CAAuB,oBAAvB,EAA6C,CAA7C,EAAgD;AACpDxF,MAAAA,UAAU,EAAE;AADwC,KAAhD,CAAN;AAGA,UAAM,KAAKD,KAAL,CAAW,CAAC,OAAD,CAAX,CAAN;AACD,GARD,CAQE,OAAO5E,CAAP,EAAU;AACV,UAAM;AAACM,MAAAA;AAAD,QAAYN,CAAlB;;AAGA,QAAIM,OAAO,CAAClC,QAAR,CAAiB,cAAjB,CAAJ,EAAsC;AACpC,YAAM,IAAIwB,KAAJ,CAAW,8DAAD,GACb,4DAA2DU,OAAQ,GADhE,CAAN;AAED;;AACD,UAAMN,CAAN;AACD,GAjBD,SAiBU;AAER,QAAI,CAACgF,gBAAL,EAAuB;AACrB,YAAM,KAAKK,MAAL,EAAN;AACD;AACF;;AACD,QAAM7D,KAAK,GAAG,IAAIC,sBAAOC,KAAX,GAAmBC,KAAnB,EAAd;AACA,QAAM,6BAAcqI,OAAd,EAAuB,IAAvB,EAA6B,YAAY;AAC7C,QAAI,CAAC,MAAM,KAAKM,iBAAL,CAAuB,oBAAvB,CAAP,MAAyD,GAA7D,EAAkE;AAChE;AACD;;AAED,UAAMC,GAAG,GAAI,iCAAgC/I,KAAK,CAACK,WAAN,GAAoBC,cAApB,CAAmCC,OAAnC,CAA2C,CAA3C,CAA8C,IAA3F;;AACAnE,oBAAIsC,KAAJ,CAAUqK,GAAV;;AACA,UAAM,IAAI3K,KAAJ,CAAU2K,GAAV,CAAN;AACD,GARK,CAAN;AASD,CApCD;;AAiDAvN,iBAAiB,CAACwN,oBAAlB,GAAyC,eAAeA,oBAAf,CAAqCC,UAArC,EAAiD;AACxF,QAAMxH,GAAG,GAAGwH,UAAU,GAAG,MAAH,GAAY,QAAlC;AAGA,QAAMC,MAAM,GAAG,MAAM,KAAKA,MAAL,EAArB;;AACA,MAAKA,MAAM,IAAID,UAAX,IAA2B,CAACC,MAAD,IAAW,CAACD,UAA3C,EAAwD;AACtD,WAAO;AAACxF,MAAAA,YAAY,EAAE,IAAf;AAAqBD,MAAAA,gBAAgB,EAAE0F;AAAvC,KAAP;AACD;;AAED,MAAI1F,gBAAgB,GAAG0F,MAAvB;;AACA,MAAI;AACF,QAAI;AAACvK,MAAAA;AAAD,QAAW,MAAM,KAAKoC,OAAL,CAAa,CAACU,GAAD,CAAb,CAArB;;AAGA,QAAI9C,MAAJ,EAAY;AACV,UAAIA,MAAM,CAAC/B,QAAP,CAAgB,yBAAhB,CAAJ,EAAgD;AAC9C,eAAO;AAAC6G,UAAAA,YAAY,EAAE,KAAf;AAAsBD,UAAAA;AAAtB,SAAP;AACD;;AAED,UAAI7E,MAAM,CAAC/B,QAAP,CAAgB,yBAAhB,CAAJ,EAAgD;AAC9C4G,QAAAA,gBAAgB,GAAG,IAAnB;AACD;AACF;;AACD,WAAO;AAACC,MAAAA,YAAY,EAAE,IAAf;AAAqBD,MAAAA;AAArB,KAAP;AACD,GAdD,CAcE,OAAOI,GAAP,EAAY;AACZ,UAAM;AAAClB,MAAAA,MAAM,GAAG,EAAV;AAAc5D,MAAAA;AAAd,QAAyB8E,GAA/B;;AACAxH,oBAAIC,IAAJ,CAAU,aAAYoF,GAAI,iCAAgC3C,OAAQ,eAAc4D,MAAO,gBAAvF;;AAIA,QAAI,CAAC,QAAD,EAAW,gBAAX,EAA6B,iBAA7B,EAAgDjD,IAAhD,CAAsDrC,CAAD,IAAOsF,MAAM,CAACsE,WAAP,GAAqBpK,QAArB,CAA8BQ,CAA9B,CAA5D,CAAJ,EAAmG;AACjGhB,sBAAIC,IAAJ,CAAU,mBAAkBoF,GAAI,gDAAhC;;AACA,YAAM,KAAKf,UAAL,EAAN;AACD;;AAED,WAAO;AAAC+C,MAAAA,YAAY,EAAE,KAAf;AAAsBD,MAAAA;AAAtB,KAAP;AACD;AACF,CArCD;;AA2CAhI,iBAAiB,CAACkI,IAAlB,GAAyB,eAAeA,IAAf,GAAuB;AAC9C,SAAO,MAAM,KAAKsF,oBAAL,CAA0B,IAA1B,CAAb;AACD,CAFD;;AASAxN,iBAAiB,CAACqI,MAAlB,GAA2B,eAAeA,MAAf,GAAyB;AAClD,SAAO,MAAM,KAAKmF,oBAAL,CAA0B,KAA1B,CAAb;AACD,CAFD;;AAWAxN,iBAAiB,CAAC0N,MAAlB,GAA2B,eAAeA,MAAf,GAAyB;AAClD,SAAO,CAAC,MAAM,KAAK9F,KAAL,CAAW,CAAC,QAAD,CAAX,CAAP,EAA+B7D,IAA/B,OAA0C,MAAjD;AACD,CAFD;;AAUA/D,iBAAiB,CAAC2N,UAAlB,GAA+B,eAAeA,UAAf,CAA2BC,UAA3B,EAAuC;AACpE,QAAMC,QAAQ,GAAG,UAAjB;AACA,QAAMC,QAAQ,GAAI,SAAQF,UAAU,CAAC5G,OAAX,CAAmB,IAAnB,EAA0B,KAA1B,CAAgC,eAAc6G,QAAS,EAAjF;;AACA,MAAI;AACF,WAAO7M,gBAAEI,QAAF,CAAW,MAAM,KAAKwG,KAAL,CAAW,CAACkG,QAAD,CAAX,CAAjB,EAAyCD,QAAzC,CAAP;AACD,GAFD,CAEE,OAAO5I,GAAP,EAAY;AACZ,WAAO,KAAP;AACD;AACF,CARD;;AAmBAjF,iBAAiB,CAAC+N,EAAlB,GAAuB,eAAeA,EAAf,CAAmBH,UAAnB,EAA+BxH,IAAI,GAAG,EAAtC,EAA0C;AAC/D,MAAI;AACF,QAAIS,IAAI,GAAG,CAAC,IAAD,EAAO,GAAGT,IAAV,EAAgBwH,UAAhB,CAAX;AACA,QAAIzK,MAAM,GAAG,MAAM,KAAKyE,KAAL,CAAWf,IAAX,CAAnB;AACA,QAAImH,KAAK,GAAG7K,MAAM,CAACW,KAAP,CAAa,IAAb,CAAZ;AACA,WAAOkK,KAAK,CAACrM,GAAN,CAAWsM,CAAD,IAAOA,CAAC,CAAClK,IAAF,EAAjB,EACJ/B,MADI,CACG6J,OADH,EAEJ7J,MAFI,CAEIiM,CAAD,IAAOA,CAAC,CAACxK,OAAF,CAAU,cAAV,MAA8B,CAAC,CAFzC,CAAP;AAGD,GAPD,CAOE,OAAO2E,GAAP,EAAY;AACZ,QAAIA,GAAG,CAAC9E,OAAJ,CAAYG,OAAZ,CAAoB,2BAApB,MAAqD,CAAC,CAA1D,EAA6D;AAC3D,YAAM2E,GAAN;AACD;;AACD,WAAO,EAAP;AACD;AACF,CAdD;;AAuBApI,iBAAiB,CAACkO,QAAlB,GAA6B,eAAeA,QAAf,CAAyBN,UAAzB,EAAqC;AAChE,MAAI;AACF,UAAMO,KAAK,GAAG,MAAM,KAAKJ,EAAL,CAAQH,UAAR,EAAoB,CAAC,KAAD,CAApB,CAApB;;AACA,QAAIO,KAAK,CAACnJ,MAAN,KAAiB,CAArB,EAAwB;AACtB,YAAM,IAAIpC,KAAJ,CAAW,2BAAX,CAAN;AACD;;AAED,UAAMwL,KAAK,GAAG,mDAAmDlF,IAAnD,CAAwDiF,KAAK,CAAC,CAAD,CAA7D,CAAd;;AACA,QAAI,CAACC,KAAD,IAAUpN,gBAAEqN,KAAF,CAAQpF,QAAQ,CAACmF,KAAK,CAAC,CAAD,CAAN,EAAW,EAAX,CAAhB,CAAd,EAA+C;AAC7C,YAAM,IAAIxL,KAAJ,CAAW,2CAA0CuL,KAAK,CAAC,CAAD,CAAI,GAA9D,CAAN;AACD;;AACD,WAAOlF,QAAQ,CAACmF,KAAK,CAAC,CAAD,CAAN,EAAW,EAAX,CAAf;AACD,GAXD,CAWE,OAAOhG,GAAP,EAAY;AACZ,UAAM,IAAIxF,KAAJ,CAAW,gCAA+BgL,UAAW,MAAKxF,GAAG,CAAC9E,OAAQ,EAAtE,CAAN;AACD;AACF,CAfD;;AA+BAtD,iBAAiB,CAACsO,sBAAlB,GAA2C,eAAeA,sBAAf,CAAuCC,IAAvC,EAA6C;AACtF,QAAMC,OAAO,GAAG,MAAM,+BAAtB;;AAEA,MAAI,CAACxN,gBAAEyN,QAAF,CAAWF,IAAX,CAAL,EAAuB;AACrBA,IAAAA,IAAI,GAAGG,MAAM,CAACC,IAAP,CAAYJ,IAAZ,EAAkB,QAAlB,CAAP;AACD;;AAED,QAAMK,OAAO,GAAG,MAAMC,uBAAQC,OAAR,EAAtB;;AACA,MAAI;AACF,UAAMC,OAAO,GAAG1N,cAAKQ,OAAL,CAAa+M,OAAb,EAAsB,YAAtB,CAAhB;;AACA,UAAMnM,kBAAGsD,SAAH,CAAagJ,OAAb,EAAsBR,IAAtB,CAAN;AACA,QAAI;AAACpL,MAAAA;AAAD,QAAW,MAAM,wBAAKqL,OAAL,EAAc,CAAC,MAAD,EAAS,QAAT,EAAmB,OAAnB,EAA4B,KAA5B,EAAmCO,OAAnC,CAAd,CAArB;AACA,UAAMC,QAAQ,GAAG7L,MAAM,CAACY,IAAP,EAAjB;;AACAnD,oBAAIsC,KAAJ,CAAW,yBAAwB8L,QAAS,EAA5C;;AACApO,oBAAIsC,KAAJ,CAAU,+BAAV;;AACA,KAAC;AAACC,MAAAA;AAAD,QAAW,MAAM,wBAAKqL,OAAL,EAAc,CAAC,MAAD,EAAS,KAAT,EAAgBO,OAAhB,CAAd,EAAwC;AAACN,MAAAA,QAAQ,EAAE;AAAX,KAAxC,CAAlB;AACA,QAAIQ,cAAc,GAAG9L,MAArB;AACA,KAAC;AAACA,MAAAA;AAAD,QAAW,MAAM,wBAAKqL,OAAL,EAAc,CAAC,MAAD,EAC9B,KAD8B,EACvBO,OADuB,EAE9B,OAF8B,EAG9B,cAH8B,EAI9B,QAJ8B,CAAd,EAIL;AAACN,MAAAA,QAAQ,EAAE;AAAX,KAJK,CAAlB;AAKAQ,IAAAA,cAAc,GAAGP,MAAM,CAACnG,MAAP,CAAc,CAAC0G,cAAD,EAAiB9L,MAAjB,CAAd,CAAjB;;AACA,UAAM+L,OAAO,GAAG7N,cAAKQ,OAAL,CAAa+M,OAAb,EAAuB,GAAEI,QAAS,IAAlC,CAAhB;;AACA,UAAMvM,kBAAGsD,SAAH,CAAamJ,OAAb,EAAsBD,cAAtB,CAAN;;AACArO,oBAAIsC,KAAJ,CAAU,+BAAV;;AAEA,UAAM,6BAAc,CAAd,EAAiB,IAAjB,EAAuB,YAAY,MAAM,KAAKqC,OAAL,CAAa,CAAC,SAAD,CAAb,CAAzC,CAAN;;AACA3E,oBAAIsC,KAAJ,CAAW,6CAA4CgM,OAAQ,SAAQ3O,UAAW,GAAlF;;AACA,UAAM,KAAK6B,IAAL,CAAU8M,OAAV,EAAmB3O,UAAnB,CAAN;;AACAK,oBAAIsC,KAAJ,CAAU,uCAAV;;AACA,UAAM,KAAKqC,OAAL,CAAa,CAAC,SAAD,CAAb,CAAN;AACD,GAxBD,CAwBE,OAAO6C,GAAP,EAAY;AACZ,UAAM,IAAIxF,KAAJ,CAAW,wCAAD,GACC,0DADD,GAEC,8CAFD,GAGC,mBAAkBwF,GAAG,CAAC9E,OAAQ,EAHzC,CAAN;AAID,GA7BD,SA6BU;AACR,UAAMb,kBAAG0M,MAAH,CAAUP,OAAV,CAAN;AACD;AACF,CAxCD;;AAmDA5O,iBAAiB,CAACoP,0BAAlB,GAA+C,eAAeA,0BAAf,CAA2Cb,IAA3C,EAAiD;AAC9F,QAAMC,OAAO,GAAG,MAAM,+BAAtB;;AAEA,MAAI,CAACxN,gBAAEyN,QAAF,CAAWF,IAAX,CAAL,EAAuB;AACrBA,IAAAA,IAAI,GAAGG,MAAM,CAACC,IAAP,CAAYJ,IAAZ,EAAkB,QAAlB,CAAP;AACD;;AAED,QAAMK,OAAO,GAAG,MAAMC,uBAAQC,OAAR,EAAtB;AACA,MAAIE,QAAJ;;AACA,MAAI;AACF,UAAMK,OAAO,GAAGhO,cAAKQ,OAAL,CAAa+M,OAAb,EAAsB,YAAtB,CAAhB;;AACA,UAAMnM,kBAAGsD,SAAH,CAAasJ,OAAb,EAAsBd,IAAtB,CAAN;AACA,UAAM;AAACpL,MAAAA;AAAD,QAAW,MAAM,wBAAKqL,OAAL,EAAc,CAAC,MAAD,EAAS,QAAT,EAAmB,OAAnB,EAA4B,KAA5B,EAAmCa,OAAnC,CAAd,CAAvB;AACAL,IAAAA,QAAQ,GAAG7L,MAAM,CAACY,IAAP,EAAX;AACD,GALD,CAKE,OAAOqE,GAAP,EAAY;AACZ,UAAM,IAAIxF,KAAJ,CAAW,wCAAD,GACC,0DADD,GAEC,mBAAkBwF,GAAG,CAAC9E,OAAQ,EAFzC,CAAN;AAGD,GATD,SASU;AACR,UAAMb,kBAAG0M,MAAH,CAAUP,OAAV,CAAN;AACD;;AACD,QAAM9I,OAAO,GAAGzE,cAAKiO,KAAL,CAAWzN,OAAX,CAAmBtB,UAAnB,EAAgC,GAAEyO,QAAS,IAA3C,CAAhB;;AACApO,kBAAIsC,KAAJ,CAAW,wDAAuD4C,OAAQ,GAA1E;;AACA,SAAO,MAAM,KAAK6H,UAAL,CAAgB7H,OAAhB,CAAb;AACD,CAxBD;;eA0Be9F,iB","sourcesContent":["import path from 'path';\nimport log from '../logger.js';\nimport B from 'bluebird';\nimport { system, fs, util, tempDir, timing } from 'appium-support';\nimport {\n  getSdkToolsVersion,\n  getBuildToolsDirs,\n  getOpenSslForOs,\n  DEFAULT_ADB_EXEC_TIMEOUT } from '../helpers';\nimport { exec, SubProcess } from 'teen_process';\nimport { sleep, retry, retryInterval, waitForCondition } from 'asyncbox';\nimport _ from 'lodash';\n\n\nlet systemCallMethods = {};\n\nconst DEFAULT_ADB_REBOOT_RETRIES = 90;\n\nconst LINKER_WARNING_REGEXP = /^WARNING: linker.+$/m;\nconst PROTOCOL_FAULT_ERROR_REGEXP = new RegExp('protocol fault \\\\(no status\\\\)', 'i');\nconst DEVICE_NOT_FOUND_ERROR_REGEXP = new RegExp(`error: device ('.+' )?not found`, 'i');\nconst DEVICE_CONNECTING_ERROR_REGEXP = new RegExp('error: device still connecting', 'i');\n\nconst CERTS_ROOT = '/system/etc/security/cacerts';\n\n/**\n * Retrieve full path to the given binary.\n *\n * @param {string} binaryName - The name of the binary.\n * @return {string} Full path to the given binary including current SDK root.\n */\nsystemCallMethods.getSdkBinaryPath = async function getSdkBinaryPath (binaryName) {\n  if (this.sdkRoot) {\n    return await this.getBinaryFromSdkRoot(binaryName);\n  }\n  log.warn(`The ANDROID_HOME environment variable is not set to the Android SDK ` +\n    `root directory path. ANDROID_HOME is required for compatibility ` +\n    `with SDK 23+. Checking along PATH for ${binaryName}.`);\n  return await this.getBinaryFromPath(binaryName);\n};\n\n/**\n * Retrieve full binary name for the current operating system.\n *\n * @param {string} binaryName - simple binary name, for example 'android'.\n * @return {string} Formatted binary name depending on the current platform,\n *                  for example, 'android.bat' on Windows.\n */\nsystemCallMethods.getBinaryNameForOS = _.memoize(function getBinaryNameForOS (binaryName) {\n  if (!system.isWindows()) {\n    return binaryName;\n  }\n\n  if (['android', 'apksigner', 'apkanalyzer'].includes(binaryName)) {\n    return `${binaryName}.bat`;\n  }\n  if (!path.extname(binaryName)) {\n    return `${binaryName}.exe`;\n  }\n  return binaryName;\n});\n\n/**\n * Retrieve full path to the given binary and caches it into `binaries`\n * property of the current ADB instance.\n *\n * @param {string} binaryName - Simple name of a binary file.\n * @return {string} Full path to the given binary. The method tries\n *                  to enumerate all the known locations where the binary\n *                  might be located and stops the search as soon as the first\n *                  match is found on the local file system.\n * @throws {Error} If the binary with given name is not present at any\n *                 of known locations or Android SDK is not installed on the\n *                 local file system.\n */\nsystemCallMethods.getBinaryFromSdkRoot = async function getBinaryFromSdkRoot (binaryName) {\n  if (this.binaries[binaryName]) {\n    return this.binaries[binaryName];\n  }\n\n  const fullBinaryName = this.getBinaryNameForOS(binaryName);\n  const binaryLocs = ['platform-tools', 'emulator', 'tools', `tools${path.sep}bin`]\n    .map((x) => path.resolve(this.sdkRoot, x, fullBinaryName));\n  // get subpaths for currently installed build tool directories\n  let buildToolsDirs = await getBuildToolsDirs(this.sdkRoot);\n  if (this.buildToolsVersion) {\n    buildToolsDirs = buildToolsDirs\n      .filter((x) => path.basename(x) === this.buildToolsVersion);\n    if (_.isEmpty(buildToolsDirs)) {\n      log.info(`Found no build tools whose version matches to '${this.buildToolsVersion}'`);\n    } else {\n      log.info(`Using build tools at '${buildToolsDirs}'`);\n    }\n  }\n  binaryLocs.push(...(_.flatten(buildToolsDirs\n    .map((dir) => [\n      path.resolve(dir, fullBinaryName),\n      path.resolve(dir, 'lib', fullBinaryName),\n    ]))\n  ));\n\n  let binaryLoc = null;\n  for (const loc of binaryLocs) {\n    if (await fs.exists(loc)) {\n      binaryLoc = loc;\n      break;\n    }\n  }\n  if (_.isNull(binaryLoc)) {\n    throw new Error(`Could not find '${fullBinaryName}' in ${JSON.stringify(binaryLocs)}. ` +\n      `Do you have Android Build Tools ${this.buildToolsVersion ? `v ${this.buildToolsVersion} ` : ''}` +\n      `installed at '${this.sdkRoot}'?`);\n  }\n  log.info(`Using '${fullBinaryName}' from '${binaryLoc}'`);\n  this.binaries[binaryName] = binaryLoc;\n  return binaryLoc;\n};\n\n/**\n * Retrieve full path to a binary file using the standard system lookup tool.\n *\n * @param {string} binaryName - The name of the binary.\n * @return {string} Full path to the binary received from 'which'/'where'\n *                  output.\n * @throws {Error} If lookup tool returns non-zero return code.\n */\nsystemCallMethods.getBinaryFromPath = async function getBinaryFromPath (binaryName) {\n  if (this.binaries[binaryName]) {\n    return this.binaries[binaryName];\n  }\n\n  const fullBinaryName = this.getBinaryNameForOS(binaryName);\n  try {\n    const binaryLoc = await fs.which(fullBinaryName);\n    log.info(`Using '${fullBinaryName}' from '${binaryLoc}'`);\n    this.binaries[binaryName] = binaryLoc;\n    return binaryLoc;\n  } catch (e) {\n    throw new Error(`Could not find '${fullBinaryName}' in PATH. Please set the ANDROID_HOME ` +\n      `or ANDROID_SDK_ROOT environment variables to the correct Android SDK root directory path.`);\n  }\n};\n\n/**\n * @typedef {Object} Device\n * @property {string} udid - The device udid.\n * @property {string} state - Current device state, as it is visible in\n *                            _adb devices -l_ output.\n */\n\n/**\n * Retrieve the list of devices visible to adb.\n *\n * @return {Array.<Device>} The list of devices or an empty list if\n *                          no devices are connected.\n * @throws {Error} If there was an error while listing devices.\n */\nsystemCallMethods.getConnectedDevices = async function getConnectedDevices () {\n  log.debug('Getting connected devices...');\n  let stdout;\n  try {\n    ({stdout} = await exec(this.executable.path, [...this.executable.defaultArgs, 'devices']));\n  } catch (e) {\n    throw new Error(`Error while getting connected devices. Original error: ${e.message}`);\n  }\n  const listHeader = 'List of devices';\n  // expecting adb devices to return output as\n  // List of devices attached\n  // emulator-5554\tdevice\n  const startingIndex = stdout.indexOf(listHeader);\n  if (startingIndex < 0) {\n    throw new Error(`Unexpected output while trying to get devices: ${stdout}`);\n  }\n  // slicing output we care about\n  stdout = stdout.slice(startingIndex);\n  let excludedLines = [listHeader, 'adb server', '* daemon'];\n  if (!this.allowOfflineDevices) {\n    excludedLines.push('offline');\n  }\n  const devices = stdout.split('\\n')\n    .map(_.trim)\n    .filter((line) => line && !excludedLines.some((x) => line.includes(x)))\n    .reduce((acc, line) => {\n      // state is \"device\", afaic\n      const [udid, state] = line.split(/\\s+/);\n      acc.push({udid, state});\n      return acc;\n    }, []);\n  if (_.isEmpty(devices)) {\n    log.debug('No connected devices have been detected');\n  } else {\n    log.debug(`Connected devices: ${JSON.stringify(devices)}`);\n  }\n  return devices;\n};\n\n/**\n * Retrieve the list of devices visible to adb within the given timeout.\n *\n * @param {number} timeoutMs - The maximum number of milliseconds to get at least\n *                             one list item.\n * @return {Array.<Device>} The list of connected devices.\n * @throws {Error} If no connected devices can be detected within the given timeout.\n */\nsystemCallMethods.getDevicesWithRetry = async function getDevicesWithRetry (timeoutMs = 20000) {\n  const timer = new timing.Timer().start();\n  log.debug('Trying to find a connected android device');\n  const getDevices = async () => {\n    if (timer.getDuration().asMilliSeconds > timeoutMs) {\n      throw new Error(`Could not find a connected Android device in ${timer.getDuration().asMilliSeconds.toFixed(0)}ms.`);\n    }\n    try {\n      const devices = await this.getConnectedDevices();\n      if (devices.length > 0) {\n        return devices;\n      }\n    } catch (ign) {}\n\n    log.debug('Could not find devices, restarting adb server...');\n    await this.restartAdb();\n    // cool down\n    await sleep(200);\n    return await getDevices();\n  };\n  return await getDevices();\n};\n\n/**\n * Restart adb server, unless _this.suppressKillServer_ property is true.\n */\nsystemCallMethods.restartAdb = async function restartAdb () {\n  if (this.suppressKillServer) {\n    log.debug(`Not restarting abd since 'suppressKillServer' is on`);\n    return;\n  }\n\n  log.debug('Restarting adb');\n  try {\n    await this.killServer();\n  } catch (e) {\n    log.error(`Error killing ADB server, going to see if it's online anyway`);\n  }\n};\n\n/**\n * Kill adb server.\n */\nsystemCallMethods.killServer = async function killServer () {\n  log.debug(`Killing adb server on port '${this.adbPort}'`);\n  await this.adbExec(['kill-server'], {\n    exclusive: true,\n  });\n};\n\n/**\n * Reset Telnet authentication token.\n * @see {@link http://tools.android.com/recent/emulator2516releasenotes} for more details.\n *\n * @returns {boolean} If token reset was successful.\n */\nsystemCallMethods.resetTelnetAuthToken = _.memoize(async function resetTelnetAuthToken () {\n  // The methods is used to remove telnet auth token\n  //\n  const homeFolderPath = process.env[(process.platform === 'win32') ? 'USERPROFILE' : 'HOME'];\n  if (!homeFolderPath) {\n    log.warn(`Cannot find the path to user home folder. Ignoring resetting of emulator's telnet authentication token`);\n    return false;\n  }\n  const dstPath = path.resolve(homeFolderPath, '.emulator_console_auth_token');\n  log.debug(`Overriding ${dstPath} with an empty string to avoid telnet authentication for emulator commands`);\n  try {\n    await fs.writeFile(dstPath, '');\n  } catch (e) {\n    log.warn(`Error ${e.message} while resetting the content of ${dstPath}. Ignoring resetting of emulator's telnet authentication token`);\n    return false;\n  }\n  return true;\n});\n\n/**\n * Execute the given emulator command using _adb emu_ tool.\n *\n * @param {Array.<string>} cmd - The array of rest command line parameters.\n */\nsystemCallMethods.adbExecEmu = async function adbExecEmu (cmd) {\n  await this.verifyEmulatorConnected();\n  await this.resetTelnetAuthToken();\n  await this.adbExec(['emu', ...cmd]);\n};\n\nlet isExecLocked = false;\n\n/**\n * Execute the given adb command.\n *\n * @param {Array.<string>} cmd - The array of rest command line parameters\n *                      or a single string parameter.\n * @param {Object} opts - Additional options mapping. See\n *                        {@link https://github.com/appium/node-teen_process}\n *                        for more details.\n *                        You can also set the additional `exclusive` param\n *                        to `true` that assures no other parallel adb commands\n *                        are going to be executed while the current one is running\n * @return {string} - Command's stdout.\n * @throws {Error} If the command returned non-zero exit code.\n */\nsystemCallMethods.adbExec = async function adbExec (cmd, opts = {}) {\n  if (!cmd) {\n    throw new Error('You need to pass in a command to adbExec()');\n  }\n\n  opts = _.cloneDeep(opts);\n  // setting default timeout for each command to prevent infinite wait.\n  opts.timeout = opts.timeout || this.adbExecTimeout || DEFAULT_ADB_EXEC_TIMEOUT;\n  opts.timeoutCapName = opts.timeoutCapName || 'adbExecTimeout'; // For error message\n\n  cmd = _.isArray(cmd) ? cmd : [cmd];\n  let adbRetried = false;\n  const execFunc = async () => {\n    try {\n      const args = [...this.executable.defaultArgs, ...cmd];\n      log.debug(`Running '${this.executable.path} ${util.quote(args)}'`);\n      let {stdout} = await exec(this.executable.path, args, opts);\n      // sometimes ADB prints out weird stdout warnings that we don't want\n      // to include in any of the response data, so let's strip it out\n      stdout = stdout.replace(LINKER_WARNING_REGEXP, '').trim();\n      return stdout;\n    } catch (e) {\n      const errText = `${e.message}, ${e.stdout}, ${e.stderr}`;\n      const protocolFaultError = PROTOCOL_FAULT_ERROR_REGEXP.test(errText);\n      const deviceNotFoundError = DEVICE_NOT_FOUND_ERROR_REGEXP.test(errText);\n      const deviceConnectingError = DEVICE_CONNECTING_ERROR_REGEXP.test(errText);\n      if (protocolFaultError || deviceNotFoundError || deviceConnectingError) {\n        log.info(`Error sending command, reconnecting device and retrying: ${cmd}`);\n        await sleep(1000);\n        await this.getDevicesWithRetry();\n\n        // try again one time\n        if (adbRetried) {\n          adbRetried = true;\n          return await execFunc();\n        }\n      }\n\n      if (e.code === 0 && e.stdout) {\n        return e.stdout.replace(LINKER_WARNING_REGEXP, '').trim();\n      }\n\n      if (_.isNull(e.code)) {\n        e.message = `Error executing adbExec. Original error: '${e.message}'. ` +\n          `Try to increase the ${opts.timeout}ms adb execution timeout represented by '${opts.timeoutCapName}' capability`;\n      } else {\n        e.message = `Error executing adbExec. Original error: '${e.message}'; ` +\n          `Stderr: '${(e.stderr || '').trim()}'; Code: '${e.code}'`;\n      }\n      throw e;\n    }\n  };\n\n  if (isExecLocked) {\n    log.debug('Waiting until the other exclusive ADB command is completed');\n    await waitForCondition(() => !isExecLocked, {\n      waitMs: Number.MAX_SAFE_INTEGER,\n      intervalMs: 10,\n    });\n    log.debug('Continuing with the current ADB command');\n  }\n  if (opts.exclusive) {\n    isExecLocked = true;\n  }\n  try {\n    return await execFunc();\n  } finally {\n    if (opts.exclusive) {\n      isExecLocked = false;\n    }\n  }\n};\n\n/**\n * @typedef {Object} ShellExecOptions\n * @property {?string} timeoutCapName [adbExecTimeout] - the name of the corresponding Appium's timeout capability\n * (used in the error messages).\n * @property {?number} timeout [adbExecTimeout] - command execution timeout.\n * @property {?boolean} privileged [falsy] - Whether to run the given command as root.\n * @property {?boolean} keepPrivileged [falsy] - Whether to keep root mode after command execution is completed.\n *\n * All other properties are the same as for `exec` call from {@link https://github.com/appium/node-teen_process}\n * module\n */\n\n/**\n * Execute the given command using _adb shell_ prefix.\n *\n * @param {!Array.<string>|string} cmd - The array of rest command line parameters or a single\n *                                      string parameter.\n * @param {?ShellExecOptions} opts [{}] - Additional options mapping.\n * @return {string} - Command's stdout.\n * @throws {Error} If the command returned non-zero exit code.\n */\nsystemCallMethods.shell = async function shell (cmd, opts = {}) {\n  const {\n    privileged,\n    keepPrivileged,\n  } = opts;\n\n  // If the command requires privileges, root this device\n  let shouldRestoreUser = false;\n  if (privileged) {\n    log.info(`'adb shell ${cmd}' requires root access. Attempting to gain root access now.`);\n    const {wasAlreadyRooted, isSuccessful} = await this.root();\n    shouldRestoreUser = !wasAlreadyRooted;\n    if (wasAlreadyRooted) {\n      log.info('Device already had root access');\n    } else {\n      log.info(isSuccessful ? 'Root access successfully gained' : 'Could not gain root access');\n    }\n  }\n  let didCommandFail = false;\n  try {\n    try {\n      return await this.adbExec(_.isArray(cmd) ? ['shell', ...cmd] : ['shell', cmd], opts);\n    } catch (err) {\n      didCommandFail = true;\n      throw err;\n    }\n  } finally {\n    // Return the 'root' state to what it was before 'shell' was called\n    if (privileged && shouldRestoreUser && (!keepPrivileged || didCommandFail)) {\n      const {isSuccessful} = await this.unroot();\n      log.debug(isSuccessful ? 'Returned device to unrooted state' : 'Could not return device to unrooted state');\n    }\n  }\n};\n\nsystemCallMethods.createSubProcess = function createSubProcess (args = []) {\n  // add the default arguments\n  args = this.executable.defaultArgs.concat(args);\n  log.debug(`Creating ADB subprocess with args: ${JSON.stringify(args)}`);\n  return new SubProcess(this.getAdbPath(), args);\n};\n\n/**\n * Retrieve the current adb port.\n * @todo can probably deprecate this now that the logic is just to read this.adbPort\n * @return {number} The current adb port number.\n */\nsystemCallMethods.getAdbServerPort = function getAdbServerPort () {\n  return this.adbPort;\n};\n\n/**\n * Retrieve the current emulator port from _adb devives_ output.\n *\n * @return {number} The current emulator port.\n * @throws {Error} If there are no connected devices.\n */\nsystemCallMethods.getEmulatorPort = async function getEmulatorPort () {\n  log.debug('Getting running emulator port');\n  if (this.emulatorPort !== null) {\n    return this.emulatorPort;\n  }\n  try {\n    let devices = await this.getConnectedDevices();\n    let port = this.getPortFromEmulatorString(devices[0].udid);\n    if (port) {\n      return port;\n    } else {\n      throw new Error(`Emulator port not found`);\n    }\n  } catch (e) {\n    throw new Error(`No devices connected. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Retrieve the current emulator port by parsing emulator name string.\n *\n * @param {string} emStr - Emulator name string.\n * @return {number|boolean} Either the current emulator port or\n *                          _false_ if port number cannot be parsed.\n */\nsystemCallMethods.getPortFromEmulatorString = function getPortFromEmulatorString (emStr) {\n  let portPattern = /emulator-(\\d+)/;\n  if (portPattern.test(emStr)) {\n    return parseInt(portPattern.exec(emStr)[1], 10);\n  }\n  return false;\n};\n\n/**\n * Retrieve the list of currently connected emulators.\n *\n * @return {Array.<Device>} The list of connected devices.\n */\nsystemCallMethods.getConnectedEmulators = async function getConnectedEmulators () {\n  log.debug('Getting connected emulators');\n  try {\n    let devices = await this.getConnectedDevices();\n    let emulators = [];\n    for (let device of devices) {\n      let port = this.getPortFromEmulatorString(device.udid);\n      if (port) {\n        device.port = port;\n        emulators.push(device);\n      }\n    }\n    log.debug(`${util.pluralize('emulator', emulators.length, true)} connected`);\n    return emulators;\n  } catch (e) {\n    throw new Error(`Error getting emulators. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Set _emulatorPort_ property of the current class.\n *\n * @param {number} emPort - The emulator port to be set.\n */\nsystemCallMethods.setEmulatorPort = function setEmulatorPort (emPort) {\n  this.emulatorPort = emPort;\n};\n\n/**\n * Set the identifier of the current device (_this.curDeviceId_).\n *\n * @param {string} - The device identifier.\n */\nsystemCallMethods.setDeviceId = function setDeviceId (deviceId) {\n  log.debug(`Setting device id to ${deviceId}`);\n  this.curDeviceId = deviceId;\n  let argsHasDevice = this.executable.defaultArgs.indexOf('-s');\n  if (argsHasDevice !== -1) {\n    // remove the old device id from the arguments\n    this.executable.defaultArgs.splice(argsHasDevice, 2);\n  }\n  this.executable.defaultArgs.push('-s', deviceId);\n};\n\n/**\n * Set the the current device object.\n *\n * @param {Device} deviceObj - The device object to be set.\n */\nsystemCallMethods.setDevice = function setDevice (deviceObj) {\n  let deviceId = deviceObj.udid;\n  let emPort = this.getPortFromEmulatorString(deviceId);\n  this.setEmulatorPort(emPort);\n  this.setDeviceId(deviceId);\n};\n\n/**\n * Get the object for the currently running emulator.\n *\n * @param {string} avdName - Emulator name.\n * @return {?Device} Currently running emulator or _null_.\n */\nsystemCallMethods.getRunningAVD = async function getRunningAVD (avdName) {\n  log.debug(`Trying to find '${avdName}' emulator`);\n  try {\n    const emulators = await this.getConnectedEmulators();\n    for (const emulator of emulators) {\n      this.setEmulatorPort(emulator.port);\n      const runningAVDName = await this.sendTelnetCommand('avd name');\n      if (_.toLower(avdName) === _.toLower(runningAVDName)) {\n        log.debug(`Found emulator '${avdName}' on port ${emulator.port}`);\n        this.setDeviceId(emulator.udid);\n        return emulator;\n      }\n    }\n    log.debug(`Emulator '${avdName}' not running`);\n    return null;\n  } catch (e) {\n    throw new Error(`Error getting AVD. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Get the object for the currently running emulator.\n *\n * @param {string} avdName - Emulator name.\n * @param {number} timeoutMs [20000] - The maximum number of milliseconds\n *                                     to wait until at least one running AVD object\n *                                     is detected.\n * @return {?Device} Currently running emulator or _null_.\n * @throws {Error} If no device has been detected within the timeout.\n */\nsystemCallMethods.getRunningAVDWithRetry = async function getRunningAVDWithRetry (avdName, timeoutMs = 20000) {\n  let runningAvd;\n  try {\n    await waitForCondition(async () => {\n      try {\n        runningAvd = await this.getRunningAVD(avdName.replace('@', ''));\n        return runningAvd;\n      } catch (e) {\n        log.debug(e.message);\n        return false;\n      }\n    }, {\n      waitMs: timeoutMs,\n      intervalMs: 1000,\n    });\n  } catch (e) {\n    throw new Error(`Error getting AVD with retry. Original error: ${e.message}`);\n  }\n  return runningAvd;\n};\n\n/**\n * Shutdown all running emulators by killing their processes.\n *\n * @throws {Error} If killing tool returned non-zero return code.\n */\nsystemCallMethods.killAllEmulators = async function killAllEmulators () {\n  let cmd, args;\n  if (system.isWindows()) {\n    cmd = 'TASKKILL';\n    args = ['TASKKILL', '/IM', 'emulator.exe'];\n  } else {\n    cmd = '/usr/bin/killall';\n    args = ['-m', 'emulator*'];\n  }\n  try {\n    await exec(cmd, args);\n  } catch (e) {\n    throw new Error(`Error killing emulators. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Kill emulator with the given name. No error\n * is thrown is given avd does not exist/is not running.\n *\n * @param {?string} avdName - The name of the emulator to be killed. If empty,\n *                            the current emulator will be killed.\n * @param {?number} timeout [60000] - The amount of time to wait before throwing\n *                                    an exception about unsuccessful killing\n * @return {boolean} - True if the emulator was killed, false otherwise.\n * @throws {Error} if there was a failure by killing the emulator\n */\nsystemCallMethods.killEmulator = async function killEmulator (avdName = null, timeout = 60000) {\n  if (util.hasValue(avdName)) {\n    log.debug(`Killing avd '${avdName}'`);\n    const device = await this.getRunningAVD(avdName);\n    if (!device) {\n      log.info(`No avd with name '${avdName}' running. Skipping kill step.`);\n      return false;\n    }\n  } else {\n    // killing the current avd\n    log.debug(`Killing avd with id '${this.curDeviceId}'`);\n    if (!await this.isEmulatorConnected()) {\n      log.debug(`Emulator with id '${this.curDeviceId}' not connected. Skipping kill step`);\n      return false;\n    }\n  }\n  await this.adbExec(['emu', 'kill']);\n  log.debug(`Waiting up to ${timeout}ms until the emulator '${avdName ? avdName : this.curDeviceId}' is killed`);\n  try {\n    await waitForCondition(async () => {\n      try {\n        return util.hasValue(avdName)\n          ? !await this.getRunningAVD(avdName)\n          : !await this.isEmulatorConnected();\n      } catch (ign) {}\n      return false;\n    }, {\n      waitMs: timeout,\n      intervalMs: 2000,\n    });\n  } catch (e) {\n    throw new Error(`The emulator '${avdName ? avdName : this.curDeviceId}' is still running after being killed ${timeout}ms ago`);\n  }\n  log.info(`Successfully killed the '${avdName ? avdName : this.curDeviceId}' emulator`);\n  return true;\n};\n\n/**\n * Start an emulator with given parameters and wait until it is full started.\n *\n * @param {string} avdName - The name of an existing emulator.\n * @param {Array.<string>|string} avdArgs - Additional emulator command line argument.\n * @param {?string} language - Emulator system language.\n * @param {?country} country - Emulator system country.\n * @param {number} avdLaunchTimeout [60000] - Emulator startup timeout in milliseconds.\n * @param {number} retryTimes [1] - The maximum number of startup retries.\n * @throws {Error} If the emulator fails to start within the given timeout.\n */\nsystemCallMethods.launchAVD = async function launchAVD (avdName, avdArgs, language, country,\n  avdLaunchTimeout = 60000, avdReadyTimeout = 60000, retryTimes = 1) {\n  log.debug(`Launching Emulator with AVD ${avdName}, launchTimeout ` +\n            `${avdLaunchTimeout}ms and readyTimeout ${avdReadyTimeout}ms`);\n  let emulatorBinaryPath = await this.getSdkBinaryPath('emulator');\n  if (avdName[0] === '@') {\n    avdName = avdName.substr(1);\n  }\n  await this.checkAvdExist(avdName);\n  let launchArgs = ['-avd', avdName];\n  if (_.isString(language)) {\n    log.debug(`Setting Android Device Language to ${language}`);\n    launchArgs.push('-prop', `persist.sys.language=${language.toLowerCase()}`);\n  }\n  if (_.isString(country)) {\n    log.debug(`Setting Android Device Country to ${country}`);\n    launchArgs.push('-prop', `persist.sys.country=${country.toUpperCase()}`);\n  }\n  let locale;\n  if (_.isString(language) && _.isString(country)) {\n    locale = language.toLowerCase() + '-' + country.toUpperCase();\n  } else if (_.isString(language)) {\n    locale = language.toLowerCase();\n  } else if (_.isString(country)) {\n    locale = country;\n  }\n  if (_.isString(locale)) {\n    log.debug(`Setting Android Device Locale to ${locale}`);\n    launchArgs.push('-prop', `persist.sys.locale=${locale}`);\n  }\n  if (!_.isEmpty(avdArgs)) {\n    launchArgs.push(...(_.isArray(avdArgs) ? avdArgs : avdArgs.split(' ')));\n  }\n  log.debug(`Running '${emulatorBinaryPath}' with args: ${JSON.stringify(launchArgs)}`);\n  let proc = new SubProcess(emulatorBinaryPath, launchArgs);\n  await proc.start(0);\n  proc.on('output', (stdout, stderr) => {\n    for (let line of (stdout || stderr || '').split('\\n').filter(Boolean)) {\n      log.info(`[AVD OUTPUT] ${line}`);\n    }\n  });\n  proc.on('die', (code, signal) => {\n    log.warn(`Emulator avd ${avdName} exited with code ${code}${signal ? `, signal ${signal}` : ''}`);\n  });\n  await retry(retryTimes, async () => await this.getRunningAVDWithRetry(avdName, avdLaunchTimeout));\n  await this.waitForEmulatorReady(avdReadyTimeout);\n  return proc;\n};\n\n/**\n * @typedef {Object} ADBVersion\n * @property {string} versionString - ADB version as a string.\n * @property {float} versionFloat - Version number as float value (useful for comparison).\n * @property {number} major - Major version number.\n * @property {number} minor - Minor version number.\n * @property {number} patch - Patch version number.\n */\n\n/**\n * Get the adb version. The result of this method is cached.\n *\n * @return {ADBVersion} The current adb version.\n * @throws {Error} If it is not possible to parse adb version.\n */\nsystemCallMethods.getAdbVersion = _.memoize(async function getAdbVersion () {\n  try {\n    let adbVersion = (await this.adbExec('version'))\n      .replace(/Android\\sDebug\\sBridge\\sversion\\s([\\d.]*)[\\s\\w-]*/, '$1');\n    let parts = adbVersion.split('.');\n    return {\n      versionString: adbVersion,\n      versionFloat: parseFloat(adbVersion),\n      major: parseInt(parts[0], 10),\n      minor: parseInt(parts[1], 10),\n      patch: parts[2] ? parseInt(parts[2], 10) : undefined,\n    };\n  } catch (e) {\n    throw new Error(`Error getting adb version. Original error: '${e.message}'; ` +\n                        `Stderr: '${(e.stderr || '').trim()}'; Code: '${e.code}'`);\n  }\n});\n\n/**\n * Check if given emulator exists in the list of available avds.\n *\n * @param {string} avdName - The name of emulator to verify for existence.\n * @throws {Error} If the emulator with given name does not exist.\n */\nsystemCallMethods.checkAvdExist = async function checkAvdExist (avdName) {\n  let cmd, result;\n  try {\n    cmd = await this.getSdkBinaryPath('emulator');\n    result = await exec(cmd, ['-list-avds']);\n  } catch (e) {\n    let unknownOptionError = new RegExp('unknown option: -list-avds', 'i').test(e.stderr);\n    if (!unknownOptionError) {\n      throw new Error(`Error executing checkAvdExist. Original error: '${e.message}'; ` +\n                      `Stderr: '${(e.stderr || '').trim()}'; Code: '${e.code}'`);\n\n    }\n    const sdkVersion = await getSdkToolsVersion();\n    let binaryName = 'android';\n    if (sdkVersion) {\n      if (sdkVersion.major >= 25) {\n        binaryName = 'avdmanager';\n      }\n    } else {\n      log.warn(`Defaulting binary name to '${binaryName}', because SDK version cannot be parsed`);\n    }\n    // If -list-avds option is not available, use android command as an alternative\n    cmd = await this.getSdkBinaryPath(binaryName);\n    result = await exec(cmd, ['list', 'avd', '-c']);\n  }\n  if (result.stdout.indexOf(avdName) === -1) {\n    let existings = `(${result.stdout.trim().replace(/[\\n]/g, '), (')})`;\n    throw new Error(`Avd '${avdName}' is not available. please select your avd name from one of these: '${existings}'`);\n  }\n};\n\n/**\n * Check if the current emulator is ready to accept further commands (booting completed).\n *\n * @param {number} timeoutMs [20000] - The maximum number of milliseconds to wait.\n * @throws {Error} If the emulator is not ready within the given timeout.\n */\nsystemCallMethods.waitForEmulatorReady = async function waitForEmulatorReady (timeoutMs = 20000) {\n  try {\n    await waitForCondition(async () => {\n      try {\n        if (!(await this.shell(['getprop', 'init.svc.bootanim'])).includes('stopped')) {\n          return false;\n        }\n        // Sometimes the package manager service might still being initialized\n        // on slow systems even after emulator booting is completed.\n        // The usual output of `pm get-install-location` command looks like `0[auto]`\n        return /\\d+\\[\\w+\\]/.test(await this.shell(['pm', 'get-install-location']));\n      } catch (err) {\n        log.debug(`Waiting for emulator startup. Intermediate error: ${err.message}`);\n        return false;\n      }\n    }, {\n      waitMs: timeoutMs,\n      intervalMs: 3000,\n    });\n  } catch (e) {\n    throw new Error(`Emulator is not ready within ${timeoutMs}ms`);\n  }\n};\n\n/**\n * Check if the current device is ready to accept further commands (booting completed).\n *\n * @param {number} appDeviceReadyTimeout [30] - The maximum number of seconds to wait.\n * @throws {Error} If the device is not ready within the given timeout.\n */\nsystemCallMethods.waitForDevice = async function waitForDevice (appDeviceReadyTimeout = 30) {\n  this.appDeviceReadyTimeout = appDeviceReadyTimeout;\n  const retries = 3;\n  const timeout = parseInt(this.appDeviceReadyTimeout, 10) / retries * 1000;\n  await retry(retries, async () => {\n    try {\n      await this.adbExec('wait-for-device', {timeout});\n      await this.ping();\n    } catch (e) {\n      await this.restartAdb();\n      await this.getConnectedDevices();\n      throw new Error(`Error waiting for the device to be available. Original error: '${e.message}'`);\n    }\n  });\n};\n\n/**\n * Reboot the current device and wait until it is completed.\n *\n * @param {number} retries [DEFAULT_ADB_REBOOT_RETRIES] - The maximum number of reboot retries.\n * @throws {Error} If the device failed to reboot and number of retries is exceeded.\n */\nsystemCallMethods.reboot = async function reboot (retries = DEFAULT_ADB_REBOOT_RETRIES) {\n  // Get root access so we can run the next shell commands which require root access\n  const { wasAlreadyRooted } = await this.root();\n  try {\n    // Stop and re-start the device\n    await this.shell(['stop']);\n    await B.delay(2000); // let the emu finish stopping;\n    await this.setDeviceProperty('sys.boot_completed', 0, {\n      privileged: false // no need to set privileged true because device already rooted\n    });\n    await this.shell(['start']);\n  } catch (e) {\n    const {message} = e;\n\n    // provide a helpful error message if the reason reboot failed was because ADB couldn't gain root access\n    if (message.includes('must be root')) {\n      throw new Error(`Could not reboot device. Rebooting requires root access and ` +\n        `attempt to get root access on device failed with error: '${message}'`);\n    }\n    throw e;\n  } finally {\n    // Return root state to what it was before\n    if (!wasAlreadyRooted) {\n      await this.unroot();\n    }\n  }\n  const timer = new timing.Timer().start();\n  await retryInterval(retries, 1000, async () => {\n    if ((await this.getDeviceProperty('sys.boot_completed')) === '1') {\n      return;\n    }\n    // we don't want the stack trace, so no log.errorAndThrow\n    const msg = `Reboot is not completed after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`;\n    log.debug(msg);\n    throw new Error(msg);\n  });\n};\n\n/**\n * @typedef {Object} rootResult\n * @property {boolean} isSuccessful True if the call to root/unroot was successful\n * @property {boolean} wasAlreadyRooted True if the device was already rooted\n */\n\n/**\n * Switch adb server root privileges.\n * @param {boolean} isElevated - Should we elevate to to root or unroot? (default true)\n * @return {rootResult}\n */\nsystemCallMethods.changeUserPrivileges = async function changeUserPrivileges (isElevated) {\n  const cmd = isElevated ? 'root' : 'unroot';\n\n  // If it's already rooted, our job is done. No need to root it again.\n  const isRoot = await this.isRoot();\n  if ((isRoot && isElevated) || (!isRoot && !isElevated)) {\n    return {isSuccessful: true, wasAlreadyRooted: isRoot};\n  }\n\n  let wasAlreadyRooted = isRoot;\n  try {\n    let {stdout} = await this.adbExec([cmd]);\n\n    // on real devices in some situations we get an error in the stdout\n    if (stdout) {\n      if (stdout.includes('adbd cannot run as root')) {\n        return {isSuccessful: false, wasAlreadyRooted};\n      }\n      // if the device was already rooted, return that in the result\n      if (stdout.includes('already running as root')) {\n        wasAlreadyRooted = true;\n      }\n    }\n    return {isSuccessful: true, wasAlreadyRooted};\n  } catch (err) {\n    const {stderr = '', message} = err;\n    log.warn(`Unable to ${cmd} adb daemon. Original error: '${message}'. Stderr: '${stderr}'. Continuing.`);\n\n    // Check the output of the stdErr to see if there's any clues that show that the device went offline\n    // and if it did go offline, restart ADB\n    if (['closed', 'device offline', 'timeout expired'].some((x) => stderr.toLowerCase().includes(x))) {\n      log.warn(`Attempt to 'adb ${cmd}' caused device to go offline. Restarting adb.`);\n      await this.restartAdb();\n    }\n\n    return {isSuccessful: false, wasAlreadyRooted};\n  }\n};\n\n/**\n * Switch adb server to root mode\n * @return {rootResult}\n */\nsystemCallMethods.root = async function root () {\n  return await this.changeUserPrivileges(true);\n};\n\n/**\n * Switch adb server to non-root mode.\n *\n * @return {rootResult}\n */\nsystemCallMethods.unroot = async function unroot () {\n  return await this.changeUserPrivileges(false);\n};\n\n/**\n * Checks whether the current user is root\n *\n * @return {boolean} True if the user is root\n * @throws {Error} if there was an error while identifying\n * the user.\n */\nsystemCallMethods.isRoot = async function isRoot () {\n  return (await this.shell(['whoami'])).trim() === 'root';\n};\n\n/**\n * Verify whether a remote path exists on the device under test.\n *\n * @param {string} remotePath - The remote path to verify.\n * @return {boolean} True if the given path exists on the device.\n */\nsystemCallMethods.fileExists = async function fileExists (remotePath) {\n  const passFlag = '__PASS__';\n  const checkCmd = `[ -e '${remotePath.replace(/'/g, `\\\\'`)}' ] && echo ${passFlag}`;\n  try {\n    return _.includes(await this.shell([checkCmd]), passFlag);\n  } catch (ign) {\n    return false;\n  }\n};\n\n/**\n * Get the output of _ls_ command on the device under test.\n *\n * @param {string} remotePath - The remote path (the first argument to the _ls_ command).\n * @param {Array.<String>} opts [[]] - Additional _ls_ options.\n * @return {Array.<String>} The _ls_ output as an array of split lines.\n *                          An empty array is returned of the given _remotePath_\n *                          does not exist.\n */\nsystemCallMethods.ls = async function ls (remotePath, opts = []) {\n  try {\n    let args = ['ls', ...opts, remotePath];\n    let stdout = await this.shell(args);\n    let lines = stdout.split('\\n');\n    return lines.map((l) => l.trim())\n      .filter(Boolean)\n      .filter((l) => l.indexOf('No such file') === -1);\n  } catch (err) {\n    if (err.message.indexOf('No such file or directory') === -1) {\n      throw err;\n    }\n    return [];\n  }\n};\n\n/**\n * Get the size of the particular file located on the device under test.\n *\n * @param {string} remotePath - The remote path to the file.\n * @return {number} File size in bytes.\n * @throws {Error} If there was an error while getting the size of the given file.\n */\nsystemCallMethods.fileSize = async function fileSize (remotePath) {\n  try {\n    const files = await this.ls(remotePath, ['-la']);\n    if (files.length !== 1) {\n      throw new Error(`Remote path is not a file`);\n    }\n    // https://regex101.com/r/fOs4P4/8\n    const match = /[rwxsStT\\-+]{10}[\\s\\d]*\\s[^\\s]+\\s+[^\\s]+\\s+(\\d+)/.exec(files[0]);\n    if (!match || _.isNaN(parseInt(match[1], 10))) {\n      throw new Error(`Unable to parse size from list output: '${files[0]}'`);\n    }\n    return parseInt(match[1], 10);\n  } catch (err) {\n    throw new Error(`Unable to get file size for '${remotePath}': ${err.message}`);\n  }\n};\n\n/**\n * Installs the given certificate on a rooted real device or\n * an emulator. The emulator must be executed with `-writable-system`\n * command line option and adb daemon should be running in root\n * mode for this method to work properly. The method also requires\n * openssl tool to be available on the destination system.\n * Read https://github.com/appium/appium/issues/10964\n * for more details on this topic\n *\n * @param {Buffer|string} cert - base64-decoded content of the actual certificate\n * represented as a string or a buffer\n * @throws {Error} If openssl tool is not available on the destination system\n * or if there was an error while installing the certificate\n */\nsystemCallMethods.installMitmCertificate = async function installMitmCertificate (cert) {\n  const openSsl = await getOpenSslForOs();\n\n  if (!_.isBuffer(cert)) {\n    cert = Buffer.from(cert, 'base64');\n  }\n\n  const tmpRoot = await tempDir.openDir();\n  try {\n    const srcCert = path.resolve(tmpRoot, 'source.cer');\n    await fs.writeFile(srcCert, cert);\n    let {stdout} = await exec(openSsl, ['x509', '-noout', '-hash', '-in', srcCert]);\n    const certHash = stdout.trim();\n    log.debug(`Got certificate hash: ${certHash}`);\n    log.debug('Preparing certificate content');\n    ({stdout} = await exec(openSsl, ['x509', '-in', srcCert], {isBuffer: true}));\n    let dstCertContent = stdout;\n    ({stdout} = await exec(openSsl, ['x509',\n      '-in', srcCert,\n      '-text',\n      '-fingerprint',\n      '-noout'], {isBuffer: true}));\n    dstCertContent = Buffer.concat([dstCertContent, stdout]);\n    const dstCert = path.resolve(tmpRoot, `${certHash}.0`);\n    await fs.writeFile(dstCert, dstCertContent);\n    log.debug('Remounting /system in rw mode');\n    // Sometimes emulator reboot is still not fully finished on this stage, so retry\n    await retryInterval(5, 2000, async () => await this.adbExec(['remount']));\n    log.debug(`Uploading the generated certificate from '${dstCert}' to '${CERTS_ROOT}'`);\n    await this.push(dstCert, CERTS_ROOT);\n    log.debug('Remounting /system to confirm changes');\n    await this.adbExec(['remount']);\n  } catch (err) {\n    throw new Error(`Cannot inject the custom certificate. ` +\n                    `Is the certificate properly encoded into base64-string? ` +\n                    `Do you have root permissions on the device? ` +\n                    `Original error: ${err.message}`);\n  } finally {\n    await fs.rimraf(tmpRoot);\n  }\n};\n\n/**\n * Verifies if the given root certificate is already installed on the device.\n *\n * @param {Buffer|string} cert - base64-decoded content of the actual certificate\n * represented as a string or a buffer\n * @throws {Error} If openssl tool is not available on the destination system\n * or if there was an error while checking the certificate\n * @returns {boolean} true if the given certificate is already installed\n */\nsystemCallMethods.isMitmCertificateInstalled = async function isMitmCertificateInstalled (cert) {\n  const openSsl = await getOpenSslForOs();\n\n  if (!_.isBuffer(cert)) {\n    cert = Buffer.from(cert, 'base64');\n  }\n\n  const tmpRoot = await tempDir.openDir();\n  let certHash;\n  try {\n    const tmpCert = path.resolve(tmpRoot, 'source.cer');\n    await fs.writeFile(tmpCert, cert);\n    const {stdout} = await exec(openSsl, ['x509', '-noout', '-hash', '-in', tmpCert]);\n    certHash = stdout.trim();\n  } catch (err) {\n    throw new Error(`Cannot retrieve the certificate hash. ` +\n                    `Is the certificate properly encoded into base64-string? ` +\n                    `Original error: ${err.message}`);\n  } finally {\n    await fs.rimraf(tmpRoot);\n  }\n  const dstPath = path.posix.resolve(CERTS_ROOT, `${certHash}.0`);\n  log.debug(`Checking if the certificate is already installed at '${dstPath}'`);\n  return await this.fileExists(dstPath);\n};\n\nexport default systemCallMethods;\nexport { DEFAULT_ADB_EXEC_TIMEOUT };\n"],"file":"lib/tools/system-calls.js","sourceRoot":"../../.."}