appium-android-driver 5.13.1 → 5.13.2

package/build/lib/commands/general.js

@@ -1,274 +1,333 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.helpers = exports.default = exports.commands = void 0;
-require("source-map-support/register");
-var _lodash = _interopRequireDefault(require("lodash"));
-var _androidHelpers = _interopRequireDefault(require("../android-helpers"));
-var _support = require("@appium/support");
-var _moment = _interopRequireDefault(require("moment"));
-var _asyncbox = require("asyncbox");
-var _driver = require("appium/driver");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpers = exports.commands = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const android_helpers_1 = __importDefault(require("../android-helpers"));
+const support_1 = require("@appium/support");
+const moment_1 = __importDefault(require("moment"));
+const asyncbox_1 = require("asyncbox");
+const driver_1 = require("appium/driver");
 const MOMENT_FORMAT_ISO8601 = 'YYYY-MM-DDTHH:mm:ssZ';
-let commands = {},
-  helpers = {},
-  extensions = {};
-exports.helpers = helpers;
+let commands = {}, helpers = {}, extensions = {};
 exports.commands = commands;
+exports.helpers = helpers;
 commands.keys = async function keys(keys) {
-  keys = _lodash.default.isArray(keys) ? keys.join('') : keys;
-  let params = {
-    text: keys,
-    replace: false
-  };
-  if (this.opts.unicodeKeyboard) {
-    params.unicodeKeyboard = true;
-  }
-  await this.doSendKeys(params);
+    // Protocol sends an array; rethink approach
+    keys = lodash_1.default.isArray(keys) ? keys.join('') : keys;
+    let params = {
+        text: keys,
+        replace: false
+    };
+    if (this.opts.unicodeKeyboard) {
+        params.unicodeKeyboard = true;
+    }
+    await this.doSendKeys(params);
 };
 commands.doSendKeys = async function doSendKeys(params) {
-  return await this.bootstrap.sendAction('setText', params);
+    return await this.bootstrap.sendAction('setText', params);
 };
+/**
+ * Retrieves the current device's timestamp.
+ *
+ * @param {string} format - The set of format specifiers. Read
+ *                          https://momentjs.com/docs/ to get the full list of supported
+ *                          datetime format specifiers. The default format is
+ *                          `YYYY-MM-DDTHH:mm:ssZ`, which complies to ISO-8601
+ * @return {string} Formatted datetime string or the raw command output if formatting fails
+ */
 commands.getDeviceTime = async function getDeviceTime(format = MOMENT_FORMAT_ISO8601) {
-  this.log.debug('Attempting to capture android device date and time. ' + `The format specifier is '${format}'`);
-  const deviceTimestamp = (await this.adb.shell(['date', '+%Y-%m-%dT%T%z'])).trim();
-  this.log.debug(`Got device timestamp: ${deviceTimestamp}`);
-  const parsedTimestamp = _moment.default.utc(deviceTimestamp, 'YYYY-MM-DDTHH:mm:ssZZ');
-  if (!parsedTimestamp.isValid()) {
-    this.log.warn('Cannot parse the returned timestamp. Returning as is');
-    return deviceTimestamp;
-  }
-  return parsedTimestamp.utcOffset(parsedTimestamp._tzm || 0).format(format);
+    this.log.debug('Attempting to capture android device date and time. ' +
+        `The format specifier is '${format}'`);
+    const deviceTimestamp = (await this.adb.shell(['date', '+%Y-%m-%dT%T%z'])).trim();
+    this.log.debug(`Got device timestamp: ${deviceTimestamp}`);
+    const parsedTimestamp = moment_1.default.utc(deviceTimestamp, 'YYYY-MM-DDTHH:mm:ssZZ');
+    if (!parsedTimestamp.isValid()) {
+        this.log.warn('Cannot parse the returned timestamp. Returning as is');
+        return deviceTimestamp;
+    }
+    return parsedTimestamp.utcOffset(parsedTimestamp._tzm || 0).format(format);
 };
+/**
+ * @typedef {Object} DeviceTimeOptions
+ * @property {string} format [YYYY-MM-DDTHH:mm:ssZ] - See getDeviceTime#format
+ */
+/**
+ * Retrieves the current device time
+ *
+ * @param {DeviceTimeOptions} opts
+ * @return {string} Formatted datetime string or the raw command output if formatting fails
+ */
 commands.mobileGetDeviceTime = async function mobileGetDeviceTime(opts = {}) {
-  return await this.getDeviceTime(opts.format);
+    return await this.getDeviceTime(opts.format);
 };
 commands.getPageSource = async function getPageSource() {
-  return await this.bootstrap.sendAction('source');
+    return await this.bootstrap.sendAction('source');
 };
 commands.back = async function back() {
-  return await this.bootstrap.sendAction('pressBack');
+    return await this.bootstrap.sendAction('pressBack');
 };
 commands.openSettingsActivity = async function openSettingsActivity(setting) {
-  let {
-    appPackage,
-    appActivity
-  } = await this.adb.getFocusedPackageAndActivity();
-  await this.adb.shell(['am', 'start', '-a', `android.settings.${setting}`]);
-  await this.adb.waitForNotActivity(appPackage, appActivity, 5000);
+    let { appPackage, appActivity } = await this.adb.getFocusedPackageAndActivity();
+    await this.adb.shell(['am', 'start', '-a', `android.settings.${setting}`]);
+    await this.adb.waitForNotActivity(appPackage, appActivity, 5000);
 };
 commands.getWindowSize = async function getWindowSize() {
-  return await this.bootstrap.sendAction('getDeviceSize');
+    return await this.bootstrap.sendAction('getDeviceSize');
 };
+// For W3C
 commands.getWindowRect = async function getWindowRect() {
-  const {
-    width,
-    height
-  } = await this.getWindowSize();
-  return {
-    width,
-    height,
-    x: 0,
-    y: 0
-  };
+    const { width, height } = await this.getWindowSize();
+    return {
+        width,
+        height,
+        x: 0,
+        y: 0
+    };
 };
 commands.getCurrentActivity = async function getCurrentActivity() {
-  return (await this.adb.getFocusedPackageAndActivity()).appActivity;
+    return (await this.adb.getFocusedPackageAndActivity()).appActivity;
 };
 commands.getCurrentPackage = async function getCurrentPackage() {
-  return (await this.adb.getFocusedPackageAndActivity()).appPackage;
+    return (await this.adb.getFocusedPackageAndActivity()).appPackage;
 };
 commands.background = async function background(seconds) {
-  if (seconds < 0) {
+    if (seconds < 0) {
+        // if user passes in a negative seconds value, interpret that as the instruction
+        // to not bring the app back at all
+        await this.adb.goToHome();
+        return true;
+    }
+    let { appPackage, appActivity } = await this.adb.getFocusedPackageAndActivity();
     await this.adb.goToHome();
-    return true;
-  }
-  let {
-    appPackage,
-    appActivity
-  } = await this.adb.getFocusedPackageAndActivity();
-  await this.adb.goToHome();
-  const sleepMs = seconds * 1000;
-  const thresholdMs = 30 * 1000;
-  const intervalMs = _lodash.default.min([30 * 1000, parseInt(sleepMs / 100, 10)]);
-  const progressCb = ({
-    elapsedMs,
-    progress
-  }) => {
-    const waitSecs = (elapsedMs / 1000).toFixed(0);
-    const progressPct = (progress * 100).toFixed(2);
-    this.log.debug(`Waited ${waitSecs}s so far (${progressPct}%)`);
-  };
-  await (0, _asyncbox.longSleep)(sleepMs, {
-    thresholdMs,
-    intervalMs,
-    progressCb
-  });
-  let args;
-  if (this._cachedActivityArgs && this._cachedActivityArgs[`${appPackage}/${appActivity}`]) {
-    args = this._cachedActivityArgs[`${appPackage}/${appActivity}`];
-  } else {
-    try {
-      this.log.debug(`Activating app '${appPackage}' in order to restore it`);
-      await this.activateApp(appPackage);
-      return true;
-    } catch (ign) {}
-    args = appPackage === this.opts.appPackage && appActivity === this.opts.appActivity || appPackage === this.opts.appWaitPackage && (this.opts.appWaitActivity || '').split(',').includes(appActivity) ? {
-      pkg: this.opts.appPackage,
-      activity: this.opts.appActivity,
-      action: this.opts.intentAction,
-      category: this.opts.intentCategory,
-      flags: this.opts.intentFlags,
-      waitPkg: this.opts.appWaitPackage,
-      waitActivity: this.opts.appWaitActivity,
-      waitForLaunch: this.opts.appWaitForLaunch,
-      waitDuration: this.opts.appWaitDuration,
-      optionalIntentArguments: this.opts.optionalIntentArguments,
-      stopApp: false,
-      user: this.opts.userProfile
-    } : {
-      pkg: appPackage,
-      activity: appActivity,
-      waitPkg: appPackage,
-      waitActivity: appActivity,
-      stopApp: false
+    // people can wait for a long time, so to be safe let's use the longSleep function and log
+    // progress periodically.
+    const sleepMs = seconds * 1000;
+    const thresholdMs = 30 * 1000; // use the spin-wait for anything over this threshold
+    // for our spin interval, use 1% of the total wait time, but nothing bigger than 30s
+    const intervalMs = lodash_1.default.min([30 * 1000, parseInt(sleepMs / 100, 10)]);
+    const progressCb = ({ elapsedMs, progress }) => {
+        const waitSecs = (elapsedMs / 1000).toFixed(0);
+        const progressPct = (progress * 100).toFixed(2);
+        this.log.debug(`Waited ${waitSecs}s so far (${progressPct}%)`);
     };
-  }
-  args = await _support.util.filterObject(args);
-  this.log.debug(`Bringing application back to foreground with arguments: ${JSON.stringify(args)}`);
-  return await this.adb.startApp(args);
+    await (0, asyncbox_1.longSleep)(sleepMs, { thresholdMs, intervalMs, progressCb });
+    let args;
+    if (this._cachedActivityArgs && this._cachedActivityArgs[`${appPackage}/${appActivity}`]) {
+        // the activity was started with `startActivity`, so use those args to restart
+        args = this._cachedActivityArgs[`${appPackage}/${appActivity}`];
+    }
+    else {
+        try {
+            this.log.debug(`Activating app '${appPackage}' in order to restore it`);
+            await this.activateApp(appPackage);
+            return true;
+        }
+        catch (ign) { }
+        args = ((appPackage === this.opts.appPackage && appActivity === this.opts.appActivity) ||
+            (appPackage === this.opts.appWaitPackage && (this.opts.appWaitActivity || '').split(',').includes(appActivity)))
+            ? {
+                pkg: this.opts.appPackage,
+                activity: this.opts.appActivity,
+                action: this.opts.intentAction,
+                category: this.opts.intentCategory,
+                flags: this.opts.intentFlags,
+                waitPkg: this.opts.appWaitPackage,
+                waitActivity: this.opts.appWaitActivity,
+                waitForLaunch: this.opts.appWaitForLaunch,
+                waitDuration: this.opts.appWaitDuration,
+                optionalIntentArguments: this.opts.optionalIntentArguments,
+                stopApp: false,
+                user: this.opts.userProfile
+            }
+            : {
+                pkg: appPackage,
+                activity: appActivity,
+                waitPkg: appPackage,
+                waitActivity: appActivity,
+                stopApp: false
+            };
+    }
+    args = await support_1.util.filterObject(args);
+    this.log.debug(`Bringing application back to foreground with arguments: ${JSON.stringify(args)}`);
+    return await this.adb.startApp(args);
 };
 commands.getStrings = async function getStrings(language) {
-  if (!language) {
-    language = await this.adb.getDeviceLanguage();
-    this.log.info(`No language specified, returning strings for: ${language}`);
-  }
-  const preprocessStringsMap = mapping => {
-    const result = {};
-    for (const [key, value] of _lodash.default.toPairs(mapping)) {
-      result[key] = _lodash.default.isString(value) ? value : JSON.stringify(value);
+    if (!language) {
+        language = await this.adb.getDeviceLanguage();
+        this.log.info(`No language specified, returning strings for: ${language}`);
+    }
+    // Clients require the resulting mapping to have both keys
+    // and values of type string
+    const preprocessStringsMap = (mapping) => {
+        const result = {};
+        for (const [key, value] of lodash_1.default.toPairs(mapping)) {
+            result[key] = lodash_1.default.isString(value) ? value : JSON.stringify(value);
+        }
+        return result;
+    };
+    if (this.apkStrings[language]) {
+        // Return cached strings
+        return preprocessStringsMap(this.apkStrings[language]);
+    }
+    this.apkStrings[language] = await android_helpers_1.default.pushStrings(language, this.adb, this.opts);
+    if (this.bootstrap) {
+        // TODO: This is mutating the current language, but it's how appium currently works
+        await this.bootstrap.sendAction('updateStrings');
     }
-    return result;
-  };
-  if (this.apkStrings[language]) {
     return preprocessStringsMap(this.apkStrings[language]);
-  }
-  this.apkStrings[language] = await _androidHelpers.default.pushStrings(language, this.adb, this.opts);
-  if (this.bootstrap) {
-    await this.bootstrap.sendAction('updateStrings');
-  }
-  return preprocessStringsMap(this.apkStrings[language]);
 };
 commands.launchApp = async function launchApp() {
-  await this.initAUT();
-  await this.startAUT();
+    await this.initAUT();
+    await this.startAUT();
 };
 commands.startActivity = async function startActivity(appPackage, appActivity, appWaitPackage, appWaitActivity, intentAction, intentCategory, intentFlags, optionalIntentArguments, dontStopAppOnReset) {
-  this.log.debug(`Starting package '${appPackage}' and activity '${appActivity}'`);
-  if (!_support.util.hasValue(dontStopAppOnReset)) {
-    dontStopAppOnReset = !!this.opts.dontStopAppOnReset;
-  }
-  let args = {
-    pkg: appPackage,
-    activity: appActivity,
-    waitPkg: appWaitPackage || appPackage,
-    waitActivity: appWaitActivity || appActivity,
-    action: intentAction,
-    category: intentCategory,
-    flags: intentFlags,
-    optionalIntentArguments,
-    stopApp: !dontStopAppOnReset
-  };
-  this._cachedActivityArgs = this._cachedActivityArgs || {};
-  this._cachedActivityArgs[`${args.waitPkg}/${args.waitActivity}`] = args;
-  await this.adb.startApp(args);
+    this.log.debug(`Starting package '${appPackage}' and activity '${appActivity}'`);
+    // dontStopAppOnReset is both an argument here, and a desired capability
+    // if the argument is set, use it, otherwise use the cap
+    if (!support_1.util.hasValue(dontStopAppOnReset)) {
+        dontStopAppOnReset = !!this.opts.dontStopAppOnReset;
+    }
+    let args = {
+        pkg: appPackage,
+        activity: appActivity,
+        waitPkg: appWaitPackage || appPackage,
+        waitActivity: appWaitActivity || appActivity,
+        action: intentAction,
+        category: intentCategory,
+        flags: intentFlags,
+        optionalIntentArguments,
+        stopApp: !dontStopAppOnReset
+    };
+    this._cachedActivityArgs = this._cachedActivityArgs || {};
+    this._cachedActivityArgs[`${args.waitPkg}/${args.waitActivity}`] = args;
+    await this.adb.startApp(args);
 };
 commands.reset = async function reset() {
-  await _androidHelpers.default.resetApp(this.adb, Object.assign({}, this.opts, {
-    fastReset: true
-  }));
-  await this.setContext();
-  return (await this.isChromeSession) ? this.startChromeSession() : this.startAUT();
+    await android_helpers_1.default.resetApp(this.adb, Object.assign({}, this.opts, { fastReset: true }));
+    // reset context since we don't know what kind on context we will end up after app launch.
+    await this.setContext();
+    return await this.isChromeSession ? this.startChromeSession() : this.startAUT();
 };
 commands.startAUT = async function startAUT() {
-  await this.adb.startApp({
-    pkg: this.opts.appPackage,
-    activity: this.opts.appActivity,
-    action: this.opts.intentAction,
-    category: this.opts.intentCategory,
-    flags: this.opts.intentFlags,
-    waitPkg: this.opts.appWaitPackage,
-    waitActivity: this.opts.appWaitActivity,
-    waitForLaunch: this.opts.appWaitForLaunch,
-    waitDuration: this.opts.appWaitDuration,
-    optionalIntentArguments: this.opts.optionalIntentArguments,
-    stopApp: !this.opts.dontStopAppOnReset,
-    user: this.opts.userProfile
-  });
+    await this.adb.startApp({
+        pkg: this.opts.appPackage,
+        activity: this.opts.appActivity,
+        action: this.opts.intentAction,
+        category: this.opts.intentCategory,
+        flags: this.opts.intentFlags,
+        waitPkg: this.opts.appWaitPackage,
+        waitActivity: this.opts.appWaitActivity,
+        waitForLaunch: this.opts.appWaitForLaunch,
+        waitDuration: this.opts.appWaitDuration,
+        optionalIntentArguments: this.opts.optionalIntentArguments,
+        stopApp: !this.opts.dontStopAppOnReset,
+        user: this.opts.userProfile,
+    });
 };
+// we override setUrl to take an android URI which can be used for deep-linking
+// inside an app, similar to starting an intent
 commands.setUrl = async function setUrl(uri) {
-  await this.adb.startUri(uri, this.opts.appPackage);
+    await this.adb.startUri(uri, this.opts.appPackage);
 };
+// closing app using force stop
 commands.closeApp = async function closeApp() {
-  await this.adb.forceStop(this.opts.appPackage);
-  await this.setContext();
+    await this.adb.forceStop(this.opts.appPackage);
+    // reset context since we don't know what kind on context we will end up after app launch.
+    await this.setContext();
 };
 commands.getDisplayDensity = async function getDisplayDensity() {
-  let out = await this.adb.shell(['getprop', 'ro.sf.lcd_density']);
-  if (out) {
-    let val = parseInt(out, 10);
-    if (!isNaN(val)) {
-      return val;
+    // first try the property for devices
+    let out = await this.adb.shell(['getprop', 'ro.sf.lcd_density']);
+    if (out) {
+        let val = parseInt(out, 10);
+        // if the value is NaN, try getting the emulator property
+        if (!isNaN(val)) {
+            return val;
+        }
+        this.log.debug(`Parsed density value was NaN: "${out}"`);
     }
-    this.log.debug(`Parsed density value was NaN: "${out}"`);
-  }
-  out = await this.adb.shell(['getprop', 'qemu.sf.lcd_density']);
-  if (out) {
-    let val = parseInt(out, 10);
-    if (!isNaN(val)) {
-      return val;
+    // fallback to trying property for emulators
+    out = await this.adb.shell(['getprop', 'qemu.sf.lcd_density']);
+    if (out) {
+        let val = parseInt(out, 10);
+        if (!isNaN(val)) {
+            return val;
+        }
+        this.log.debug(`Parsed density value was NaN: "${out}"`);
     }
-    this.log.debug(`Parsed density value was NaN: "${out}"`);
-  }
-  this.log.errorAndThrow('Failed to get display density property.');
+    // couldn't get anything, so error out
+    this.log.errorAndThrow('Failed to get display density property.');
 };
 commands.mobilePerformEditorAction = async function mobilePerformEditorAction(opts = {}) {
-  const {
-    action
-  } = opts;
-  if (!_support.util.hasValue(action)) {
-    throw new _driver.errors.InvalidArgumentError(`'action' argument is required`);
-  }
-  await this.adb.performEditorAction(action);
+    const { action } = opts;
+    if (!support_1.util.hasValue(action)) {
+        throw new driver_1.errors.InvalidArgumentError(`'action' argument is required`);
+    }
+    await this.adb.performEditorAction(action);
 };
+/**
+ * Retrieves the list of recent system notifications.
+ *
+ * @returns {Object} See the documentation on `adb.getNotifications` for
+ * more details
+ */
 commands.mobileGetNotifications = async function mobileGetNotifications() {
-  return await this.adb.getNotifications();
+    return await this.adb.getNotifications();
 };
+/**
+ * @typedef {Object} SmsListOptions
+ * @property {number} max [100] - The maximum count of recent SMS messages
+ * to retrieve
+ */
+/**
+ * Retrieves the list of recent SMS messages with their properties.
+ *
+ * @param {SmsListOptions} opts
+ * @returns {Object} See the documentation on `adb.getSmsList` for
+ * more details
+ */
 commands.mobileListSms = async function mobileListSms(opts = {}) {
-  return await this.adb.getSmsList(opts);
+    return await this.adb.getSmsList(opts);
 };
+/**
+ * @typedef {Object} UnlockOptions
+ * @property {string?} key The unlock key. The value of this key depends
+ * on the actual unlock type and could be a pin/password/pattern value or
+ * a biometric finger id.
+ * If not provided then the corresponding value from session capabilities is used.
+ * @property {string?} type The unlock type. The following unlock types
+ * are supported: `pin`, `pinWithKeyEvent`, `password`, `pattern` and `fingerprint`.
+ * If not provided then the corresponding value from session capabilities is used.
+ * @property {string?} strategy Either 'locksettings' (default) or 'uiautomator'.
+ * Setting it to 'uiautomator' will enforce the driver to avoid using special
+ * ADB shortcuts in order to speed up the unlock procedure.
+ * @property {number?} timeoutMs [2000] The maximum time in milliseconds
+ * to wait until the screen gets unlocked
+ */
+/**
+ * Unlocks the device if it is locked. Noop if the device's screen is not locked.
+ *
+ * @param {UnlockOptions} opts
+ * @throws {Error} if unlock operation fails or the provided
+ * arguments are not valid
+ */
 commands.mobileUnlock = async function mobileUnlock(opts = {}) {
-  const {
-    key,
-    type,
-    strategy,
-    timeoutMs
-  } = opts;
-  if (!key && !type) {
-    await this.unlock();
-  } else {
-    await _androidHelpers.default.unlock(this, this.adb, {
-      unlockKey: key,
-      unlockType: type,
-      unlockStrategy: strategy,
-      unlockSuccessTimeout: timeoutMs
-    });
-  }
+    const { key, type, strategy, timeoutMs } = opts;
+    if (!key && !type) {
+        await this.unlock();
+    }
+    else {
+        await android_helpers_1.default.unlock(this, this.adb, {
+            unlockKey: key,
+            unlockType: type,
+            unlockStrategy: strategy,
+            unlockSuccessTimeout: timeoutMs,
+        });
+    }
 };
 Object.assign(extensions, commands, helpers);
-var _default = extensions;
-exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_androidHelpers","_support","_moment","_asyncbox","_driver","MOMENT_FORMAT_ISO8601","commands","helpers","extensions","exports","keys","_","isArray","join","params","text","replace","opts","unicodeKeyboard","doSendKeys","bootstrap","sendAction","getDeviceTime","format","log","debug","deviceTimestamp","adb","shell","trim","parsedTimestamp","moment","utc","isValid","warn","utcOffset","_tzm","mobileGetDeviceTime","getPageSource","back","openSettingsActivity","setting","appPackage","appActivity","getFocusedPackageAndActivity","waitForNotActivity","getWindowSize","getWindowRect","width","height","x","y","getCurrentActivity","getCurrentPackage","background","seconds","goToHome","sleepMs","thresholdMs","intervalMs","min","parseInt","progressCb","elapsedMs","progress","waitSecs","toFixed","progressPct","longSleep","args","_cachedActivityArgs","activateApp","ign","appWaitPackage","appWaitActivity","split","includes","pkg","activity","action","intentAction","category","intentCategory","flags","intentFlags","waitPkg","waitActivity","waitForLaunch","appWaitForLaunch","waitDuration","appWaitDuration","optionalIntentArguments","stopApp","user","userProfile","util","filterObject","JSON","stringify","startApp","getStrings","language","getDeviceLanguage","info","preprocessStringsMap","mapping","result","key","value","toPairs","isString","apkStrings","androidHelpers","pushStrings","launchApp","initAUT","startAUT","startActivity","dontStopAppOnReset","hasValue","reset","resetApp","Object","assign","fastReset","setContext","isChromeSession","startChromeSession","setUrl","uri","startUri","closeApp","forceStop","getDisplayDensity","out","val","isNaN","errorAndThrow","mobilePerformEditorAction","errors","InvalidArgumentError","performEditorAction","mobileGetNotifications","getNotifications","mobileListSms","getSmsList","mobileUnlock","type","strategy","timeoutMs","unlock","unlockKey","unlockType","unlockStrategy","unlockSuccessTimeout","_default","default"],"sources":["../../../lib/commands/general.js"],"sourcesContent":["import _ from 'lodash';\nimport androidHelpers from '../android-helpers';\nimport { util } from '@appium/support';\nimport moment from 'moment';\nimport { longSleep } from 'asyncbox';\nimport { errors } from 'appium/driver';\n\nconst MOMENT_FORMAT_ISO8601 = 'YYYY-MM-DDTHH:mm:ssZ';\n\nlet commands = {}, helpers = {}, extensions = {};\n\ncommands.keys = async function keys (keys) {\n  // Protocol sends an array; rethink approach\n  keys = _.isArray(keys) ? keys.join('') : keys;\n  let params = {\n    text: keys,\n    replace: false\n  };\n  if (this.opts.unicodeKeyboard) {\n    params.unicodeKeyboard = true;\n  }\n  await this.doSendKeys(params);\n};\n\ncommands.doSendKeys = async function doSendKeys (params) {\n  return await this.bootstrap.sendAction('setText', params);\n};\n\n/**\n * Retrieves the current device's timestamp.\n *\n * @param {string} format - The set of format specifiers. Read\n *                          https://momentjs.com/docs/ to get the full list of supported\n *                          datetime format specifiers. The default format is\n *                          `YYYY-MM-DDTHH:mm:ssZ`, which complies to ISO-8601\n * @return {string} Formatted datetime string or the raw command output if formatting fails\n */\ncommands.getDeviceTime = async function getDeviceTime (format = MOMENT_FORMAT_ISO8601) {\n  this.log.debug('Attempting to capture android device date and time. ' +\n    `The format specifier is '${format}'`);\n  const deviceTimestamp = (await this.adb.shell(['date', '+%Y-%m-%dT%T%z'])).trim();\n  this.log.debug(`Got device timestamp: ${deviceTimestamp}`);\n  const parsedTimestamp = moment.utc(deviceTimestamp, 'YYYY-MM-DDTHH:mm:ssZZ');\n  if (!parsedTimestamp.isValid()) {\n    this.log.warn('Cannot parse the returned timestamp. Returning as is');\n    return deviceTimestamp;\n  }\n  return parsedTimestamp.utcOffset(parsedTimestamp._tzm || 0).format(format);\n};\n\n/**\n * @typedef {Object} DeviceTimeOptions\n * @property {string} format [YYYY-MM-DDTHH:mm:ssZ] - See getDeviceTime#format\n */\n\n/**\n * Retrieves the current device time\n *\n * @param {DeviceTimeOptions} opts\n * @return {string} Formatted datetime string or the raw command output if formatting fails\n */\ncommands.mobileGetDeviceTime = async function mobileGetDeviceTime (opts = {}) {\n  return await this.getDeviceTime(opts.format);\n};\n\ncommands.getPageSource = async function getPageSource () {\n  return await this.bootstrap.sendAction('source');\n};\n\ncommands.back = async function back () {\n  return await this.bootstrap.sendAction('pressBack');\n};\n\ncommands.openSettingsActivity = async function openSettingsActivity (setting) {\n  let {appPackage, appActivity} = await this.adb.getFocusedPackageAndActivity();\n  await this.adb.shell(['am', 'start', '-a', `android.settings.${setting}`]);\n  await this.adb.waitForNotActivity(appPackage, appActivity, 5000);\n};\n\ncommands.getWindowSize = async function getWindowSize () {\n  return await this.bootstrap.sendAction('getDeviceSize');\n};\n\n// For W3C\ncommands.getWindowRect = async function getWindowRect () {\n  const { width, height } = await this.getWindowSize();\n  return {\n    width,\n    height,\n    x: 0,\n    y: 0\n  };\n};\n\ncommands.getCurrentActivity = async function getCurrentActivity () {\n  return (await this.adb.getFocusedPackageAndActivity()).appActivity;\n};\n\ncommands.getCurrentPackage = async function getCurrentPackage () {\n  return (await this.adb.getFocusedPackageAndActivity()).appPackage;\n};\n\ncommands.background = async function background (seconds) {\n  if (seconds < 0) {\n    // if user passes in a negative seconds value, interpret that as the instruction\n    // to not bring the app back at all\n    await this.adb.goToHome();\n    return true;\n  }\n  let {appPackage, appActivity} = await this.adb.getFocusedPackageAndActivity();\n  await this.adb.goToHome();\n\n  // people can wait for a long time, so to be safe let's use the longSleep function and log\n  // progress periodically.\n  const sleepMs = seconds * 1000;\n  const thresholdMs = 30 * 1000; // use the spin-wait for anything over this threshold\n  // for our spin interval, use 1% of the total wait time, but nothing bigger than 30s\n  const intervalMs = _.min([30 * 1000, parseInt(sleepMs / 100, 10)]);\n  const progressCb = ({elapsedMs, progress}) => {\n    const waitSecs = (elapsedMs / 1000).toFixed(0);\n    const progressPct = (progress * 100).toFixed(2);\n    this.log.debug(`Waited ${waitSecs}s so far (${progressPct}%)`);\n  };\n  await longSleep(sleepMs, {thresholdMs, intervalMs, progressCb});\n\n  let args;\n  if (this._cachedActivityArgs && this._cachedActivityArgs[`${appPackage}/${appActivity}`]) {\n    // the activity was started with `startActivity`, so use those args to restart\n    args = this._cachedActivityArgs[`${appPackage}/${appActivity}`];\n  } else {\n    try {\n      this.log.debug(`Activating app '${appPackage}' in order to restore it`);\n      await this.activateApp(appPackage);\n      return true;\n    } catch (ign) {}\n    args = ((appPackage === this.opts.appPackage && appActivity === this.opts.appActivity) ||\n            (appPackage === this.opts.appWaitPackage && (this.opts.appWaitActivity || '').split(',').includes(appActivity)))\n      ? {// the activity is the original session activity, so use the original args\n        pkg: this.opts.appPackage,\n        activity: this.opts.appActivity,\n        action: this.opts.intentAction,\n        category: this.opts.intentCategory,\n        flags: this.opts.intentFlags,\n        waitPkg: this.opts.appWaitPackage,\n        waitActivity: this.opts.appWaitActivity,\n        waitForLaunch: this.opts.appWaitForLaunch,\n        waitDuration: this.opts.appWaitDuration,\n        optionalIntentArguments: this.opts.optionalIntentArguments,\n        stopApp: false,\n        user: this.opts.userProfile}\n      : {// the activity was started some other way, so use defaults\n        pkg: appPackage,\n        activity: appActivity,\n        waitPkg: appPackage,\n        waitActivity: appActivity,\n        stopApp: false};\n  }\n  args = await util.filterObject(args);\n  this.log.debug(`Bringing application back to foreground with arguments: ${JSON.stringify(args)}`);\n  return await this.adb.startApp(args);\n};\n\ncommands.getStrings = async function getStrings (language) {\n  if (!language) {\n    language = await this.adb.getDeviceLanguage();\n    this.log.info(`No language specified, returning strings for: ${language}`);\n  }\n\n  // Clients require the resulting mapping to have both keys\n  // and values of type string\n  const preprocessStringsMap = (mapping) => {\n    const result = {};\n    for (const [key, value] of _.toPairs(mapping)) {\n      result[key] = _.isString(value) ? value : JSON.stringify(value);\n    }\n    return result;\n  };\n\n  if (this.apkStrings[language]) {\n    // Return cached strings\n    return preprocessStringsMap(this.apkStrings[language]);\n  }\n\n  this.apkStrings[language] = await androidHelpers.pushStrings(language, this.adb, this.opts);\n  if (this.bootstrap) {\n    // TODO: This is mutating the current language, but it's how appium currently works\n    await this.bootstrap.sendAction('updateStrings');\n  }\n\n  return preprocessStringsMap(this.apkStrings[language]);\n};\n\ncommands.launchApp = async function launchApp () {\n  await this.initAUT();\n  await this.startAUT();\n};\n\ncommands.startActivity = async function startActivity (appPackage, appActivity,\n  appWaitPackage, appWaitActivity, intentAction, intentCategory, intentFlags,\n  optionalIntentArguments, dontStopAppOnReset) {\n  this.log.debug(`Starting package '${appPackage}' and activity '${appActivity}'`);\n\n  // dontStopAppOnReset is both an argument here, and a desired capability\n  // if the argument is set, use it, otherwise use the cap\n  if (!util.hasValue(dontStopAppOnReset)) {\n    dontStopAppOnReset = !!this.opts.dontStopAppOnReset;\n  }\n\n  let args = {\n    pkg: appPackage,\n    activity: appActivity,\n    waitPkg: appWaitPackage || appPackage,\n    waitActivity: appWaitActivity || appActivity,\n    action: intentAction,\n    category: intentCategory,\n    flags: intentFlags,\n    optionalIntentArguments,\n    stopApp: !dontStopAppOnReset\n  };\n  this._cachedActivityArgs = this._cachedActivityArgs || {};\n  this._cachedActivityArgs[`${args.waitPkg}/${args.waitActivity}`] = args;\n  await this.adb.startApp(args);\n};\n\ncommands.reset = async function reset () {\n  await androidHelpers.resetApp(this.adb, Object.assign({}, this.opts, {fastReset: true}));\n  // reset context since we don't know what kind on context we will end up after app launch.\n  await this.setContext();\n  return await this.isChromeSession ? this.startChromeSession() : this.startAUT();\n};\n\ncommands.startAUT = async function startAUT () {\n  await this.adb.startApp({\n    pkg: this.opts.appPackage,\n    activity: this.opts.appActivity,\n    action: this.opts.intentAction,\n    category: this.opts.intentCategory,\n    flags: this.opts.intentFlags,\n    waitPkg: this.opts.appWaitPackage,\n    waitActivity: this.opts.appWaitActivity,\n    waitForLaunch: this.opts.appWaitForLaunch,\n    waitDuration: this.opts.appWaitDuration,\n    optionalIntentArguments: this.opts.optionalIntentArguments,\n    stopApp: !this.opts.dontStopAppOnReset,\n    user: this.opts.userProfile,\n  });\n};\n\n// we override setUrl to take an android URI which can be used for deep-linking\n// inside an app, similar to starting an intent\ncommands.setUrl = async function setUrl (uri) {\n  await this.adb.startUri(uri, this.opts.appPackage);\n};\n\n// closing app using force stop\ncommands.closeApp = async function closeApp () {\n  await this.adb.forceStop(this.opts.appPackage);\n  // reset context since we don't know what kind on context we will end up after app launch.\n  await this.setContext();\n};\n\ncommands.getDisplayDensity = async function getDisplayDensity () {\n  // first try the property for devices\n  let out = await this.adb.shell(['getprop', 'ro.sf.lcd_density']);\n  if (out) {\n    let val = parseInt(out, 10);\n    // if the value is NaN, try getting the emulator property\n    if (!isNaN(val)) {\n      return val;\n    }\n    this.log.debug(`Parsed density value was NaN: \"${out}\"`);\n  }\n  // fallback to trying property for emulators\n  out = await this.adb.shell(['getprop', 'qemu.sf.lcd_density']);\n  if (out) {\n    let val = parseInt(out, 10);\n    if (!isNaN(val)) {\n      return val;\n    }\n    this.log.debug(`Parsed density value was NaN: \"${out}\"`);\n  }\n  // couldn't get anything, so error out\n  this.log.errorAndThrow('Failed to get display density property.');\n};\n\ncommands.mobilePerformEditorAction = async function mobilePerformEditorAction (opts = {}) {\n  const {action} = opts;\n  if (!util.hasValue(action)) {\n    throw new errors.InvalidArgumentError(`'action' argument is required`);\n  }\n\n  await this.adb.performEditorAction(action);\n};\n\n/**\n * Retrieves the list of recent system notifications.\n *\n * @returns {Object} See the documentation on `adb.getNotifications` for\n * more details\n */\ncommands.mobileGetNotifications = async function mobileGetNotifications () {\n  return await this.adb.getNotifications();\n};\n\n/**\n * @typedef {Object} SmsListOptions\n * @property {number} max [100] - The maximum count of recent SMS messages\n * to retrieve\n */\n\n/**\n * Retrieves the list of recent SMS messages with their properties.\n *\n * @param {SmsListOptions} opts\n * @returns {Object} See the documentation on `adb.getSmsList` for\n * more details\n */\ncommands.mobileListSms = async function mobileListSms (opts = {}) {\n  return await this.adb.getSmsList(opts);\n};\n\n/**\n * @typedef {Object} UnlockOptions\n * @property {string?} key The unlock key. The value of this key depends\n * on the actual unlock type and could be a pin/password/pattern value or\n * a biometric finger id.\n * If not provided then the corresponding value from session capabilities is used.\n * @property {string?} type The unlock type. The following unlock types\n * are supported: `pin`, `pinWithKeyEvent`, `password`, `pattern` and `fingerprint`.\n * If not provided then the corresponding value from session capabilities is used.\n * @property {string?} strategy Either 'locksettings' (default) or 'uiautomator'.\n * Setting it to 'uiautomator' will enforce the driver to avoid using special\n * ADB shortcuts in order to speed up the unlock procedure.\n * @property {number?} timeoutMs [2000] The maximum time in milliseconds\n * to wait until the screen gets unlocked\n */\n\n/**\n * Unlocks the device if it is locked. Noop if the device's screen is not locked.\n *\n * @param {UnlockOptions} opts\n * @throws {Error} if unlock operation fails or the provided\n * arguments are not valid\n */\ncommands.mobileUnlock = async function mobileUnlock (opts = {}) {\n  const { key, type, strategy, timeoutMs } = opts;\n  if (!key && !type) {\n    await this.unlock();\n  } else {\n    await androidHelpers.unlock(this, this.adb, {\n      unlockKey: key,\n      unlockType: type,\n      unlockStrategy: strategy,\n      unlockSuccessTimeout: timeoutMs,\n    });\n  }\n};\n\nObject.assign(extensions, commands, helpers);\nexport { commands, helpers };\nexport default extensions;\n"],"mappings":";;;;;;;;AAAA,IAAAA,OAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,eAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AACA,IAAAG,OAAA,GAAAJ,sBAAA,CAAAC,OAAA;AACA,IAAAI,SAAA,GAAAJ,OAAA;AACA,IAAAK,OAAA,GAAAL,OAAA;AAEA,MAAMM,qBAAqB,GAAG,sBAAsB;AAEpD,IAAIC,QAAQ,GAAG,CAAC,CAAC;EAAEC,OAAO,GAAG,CAAC,CAAC;EAAEC,UAAU,GAAG,CAAC,CAAC;AAACC,OAAA,CAAAF,OAAA,GAAAA,OAAA;AAAAE,OAAA,CAAAH,QAAA,GAAAA,QAAA;AAEjDA,QAAQ,CAACI,IAAI,GAAG,eAAeA,IAAIA,CAAEA,IAAI,EAAE;EAEzCA,IAAI,GAAGC,eAAC,CAACC,OAAO,CAACF,IAAI,CAAC,GAAGA,IAAI,CAACG,IAAI,CAAC,EAAE,CAAC,GAAGH,IAAI;EAC7C,IAAII,MAAM,GAAG;IACXC,IAAI,EAAEL,IAAI;IACVM,OAAO,EAAE;EACX,CAAC;EACD,IAAI,IAAI,CAACC,IAAI,CAACC,eAAe,EAAE;IAC7BJ,MAAM,CAACI,eAAe,GAAG,IAAI;EAC/B;EACA,MAAM,IAAI,CAACC,UAAU,CAACL,MAAM,CAAC;AAC/B,CAAC;AAEDR,QAAQ,CAACa,UAAU,GAAG,eAAeA,UAAUA,CAAEL,MAAM,EAAE;EACvD,OAAO,MAAM,IAAI,CAACM,SAAS,CAACC,UAAU,CAAC,SAAS,EAAEP,MAAM,CAAC;AAC3D,CAAC;AAWDR,QAAQ,CAACgB,aAAa,GAAG,eAAeA,aAAaA,CAAEC,MAAM,GAAGlB,qBAAqB,EAAE;EACrF,IAAI,CAACmB,GAAG,CAACC,KAAK,CAAC,sDAAsD,GAClE,4BAA2BF,MAAO,GAAE,CAAC;EACxC,MAAMG,eAAe,GAAG,CAAC,MAAM,IAAI,CAACC,GAAG,CAACC,KAAK,CAAC,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,EAAEC,IAAI,CAAC,CAAC;EACjF,IAAI,CAACL,GAAG,CAACC,KAAK,CAAE,yBAAwBC,eAAgB,EAAC,CAAC;EAC1D,MAAMI,eAAe,GAAGC,eAAM,CAACC,GAAG,CAACN,eAAe,EAAE,uBAAuB,CAAC;EAC5E,IAAI,CAACI,eAAe,CAACG,OAAO,CAAC,CAAC,EAAE;IAC9B,IAAI,CAACT,GAAG,CAACU,IAAI,CAAC,sDAAsD,CAAC;IACrE,OAAOR,eAAe;EACxB;EACA,OAAOI,eAAe,CAACK,SAAS,CAACL,eAAe,CAACM,IAAI,IAAI,CAAC,CAAC,CAACb,MAAM,CAACA,MAAM,CAAC;AAC5E,CAAC;AAaDjB,QAAQ,CAAC+B,mBAAmB,GAAG,eAAeA,mBAAmBA,CAAEpB,IAAI,GAAG,CAAC,CAAC,EAAE;EAC5E,OAAO,MAAM,IAAI,CAACK,aAAa,CAACL,IAAI,CAACM,MAAM,CAAC;AAC9C,CAAC;AAEDjB,QAAQ,CAACgC,aAAa,GAAG,eAAeA,aAAaA,CAAA,EAAI;EACvD,OAAO,MAAM,IAAI,CAAClB,SAAS,CAACC,UAAU,CAAC,QAAQ,CAAC;AAClD,CAAC;AAEDf,QAAQ,CAACiC,IAAI,GAAG,eAAeA,IAAIA,CAAA,EAAI;EACrC,OAAO,MAAM,IAAI,CAACnB,SAAS,CAACC,UAAU,CAAC,WAAW,CAAC;AACrD,CAAC;AAEDf,QAAQ,CAACkC,oBAAoB,GAAG,eAAeA,oBAAoBA,CAAEC,OAAO,EAAE;EAC5E,IAAI;IAACC,UAAU;IAAEC;EAAW,CAAC,GAAG,MAAM,IAAI,CAAChB,GAAG,CAACiB,4BAA4B,CAAC,CAAC;EAC7E,MAAM,IAAI,CAACjB,GAAG,CAACC,KAAK,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAG,oBAAmBa,OAAQ,EAAC,CAAC,CAAC;EAC1E,MAAM,IAAI,CAACd,GAAG,CAACkB,kBAAkB,CAACH,UAAU,EAAEC,WAAW,EAAE,IAAI,CAAC;AAClE,CAAC;AAEDrC,QAAQ,CAACwC,aAAa,GAAG,eAAeA,aAAaA,CAAA,EAAI;EACvD,OAAO,MAAM,IAAI,CAAC1B,SAAS,CAACC,UAAU,CAAC,eAAe,CAAC;AACzD,CAAC;AAGDf,QAAQ,CAACyC,aAAa,GAAG,eAAeA,aAAaA,CAAA,EAAI;EACvD,MAAM;IAAEC,KAAK;IAAEC;EAAO,CAAC,GAAG,MAAM,IAAI,CAACH,aAAa,CAAC,CAAC;EACpD,OAAO;IACLE,KAAK;IACLC,MAAM;IACNC,CAAC,EAAE,CAAC;IACJC,CAAC,EAAE;EACL,CAAC;AACH,CAAC;AAED7C,QAAQ,CAAC8C,kBAAkB,GAAG,eAAeA,kBAAkBA,CAAA,EAAI;EACjE,OAAO,CAAC,MAAM,IAAI,CAACzB,GAAG,CAACiB,4BAA4B,CAAC,CAAC,EAAED,WAAW;AACpE,CAAC;AAEDrC,QAAQ,CAAC+C,iBAAiB,GAAG,eAAeA,iBAAiBA,CAAA,EAAI;EAC/D,OAAO,CAAC,MAAM,IAAI,CAAC1B,GAAG,CAACiB,4BAA4B,CAAC,CAAC,EAAEF,UAAU;AACnE,CAAC;AAEDpC,QAAQ,CAACgD,UAAU,GAAG,eAAeA,UAAUA,CAAEC,OAAO,EAAE;EACxD,IAAIA,OAAO,GAAG,CAAC,EAAE;IAGf,MAAM,IAAI,CAAC5B,GAAG,CAAC6B,QAAQ,CAAC,CAAC;IACzB,OAAO,IAAI;EACb;EACA,IAAI;IAACd,UAAU;IAAEC;EAAW,CAAC,GAAG,MAAM,IAAI,CAAChB,GAAG,CAACiB,4BAA4B,CAAC,CAAC;EAC7E,MAAM,IAAI,CAACjB,GAAG,CAAC6B,QAAQ,CAAC,CAAC;EAIzB,MAAMC,OAAO,GAAGF,OAAO,GAAG,IAAI;EAC9B,MAAMG,WAAW,GAAG,EAAE,GAAG,IAAI;EAE7B,MAAMC,UAAU,GAAGhD,eAAC,CAACiD,GAAG,CAAC,CAAC,EAAE,GAAG,IAAI,EAAEC,QAAQ,CAACJ,OAAO,GAAG,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;EAClE,MAAMK,UAAU,GAAGA,CAAC;IAACC,SAAS;IAAEC;EAAQ,CAAC,KAAK;IAC5C,MAAMC,QAAQ,GAAG,CAACF,SAAS,GAAG,IAAI,EAAEG,OAAO,CAAC,CAAC,CAAC;IAC9C,MAAMC,WAAW,GAAG,CAACH,QAAQ,GAAG,GAAG,EAAEE,OAAO,CAAC,CAAC,CAAC;IAC/C,IAAI,CAAC1C,GAAG,CAACC,KAAK,CAAE,UAASwC,QAAS,aAAYE,WAAY,IAAG,CAAC;EAChE,CAAC;EACD,MAAM,IAAAC,mBAAS,EAACX,OAAO,EAAE;IAACC,WAAW;IAAEC,UAAU;IAAEG;EAAU,CAAC,CAAC;EAE/D,IAAIO,IAAI;EACR,IAAI,IAAI,CAACC,mBAAmB,IAAI,IAAI,CAACA,mBAAmB,CAAE,GAAE5B,UAAW,IAAGC,WAAY,EAAC,CAAC,EAAE;IAExF0B,IAAI,GAAG,IAAI,CAACC,mBAAmB,CAAE,GAAE5B,UAAW,IAAGC,WAAY,EAAC,CAAC;EACjE,CAAC,MAAM;IACL,IAAI;MACF,IAAI,CAACnB,GAAG,CAACC,KAAK,CAAE,mBAAkBiB,UAAW,0BAAyB,CAAC;MACvE,MAAM,IAAI,CAAC6B,WAAW,CAAC7B,UAAU,CAAC;MAClC,OAAO,IAAI;IACb,CAAC,CAAC,OAAO8B,GAAG,EAAE,CAAC;IACfH,IAAI,GAAK3B,UAAU,KAAK,IAAI,CAACzB,IAAI,CAACyB,UAAU,IAAIC,WAAW,KAAK,IAAI,CAAC1B,IAAI,CAAC0B,WAAW,IAC5ED,UAAU,KAAK,IAAI,CAACzB,IAAI,CAACwD,cAAc,IAAI,CAAC,IAAI,CAACxD,IAAI,CAACyD,eAAe,IAAI,EAAE,EAAEC,KAAK,CAAC,GAAG,CAAC,CAACC,QAAQ,CAACjC,WAAW,CAAE,GACnH;MACAkC,GAAG,EAAE,IAAI,CAAC5D,IAAI,CAACyB,UAAU;MACzBoC,QAAQ,EAAE,IAAI,CAAC7D,IAAI,CAAC0B,WAAW;MAC/BoC,MAAM,EAAE,IAAI,CAAC9D,IAAI,CAAC+D,YAAY;MAC9BC,QAAQ,EAAE,IAAI,CAAChE,IAAI,CAACiE,cAAc;MAClCC,KAAK,EAAE,IAAI,CAAClE,IAAI,CAACmE,WAAW;MAC5BC,OAAO,EAAE,IAAI,CAACpE,IAAI,CAACwD,cAAc;MACjCa,YAAY,EAAE,IAAI,CAACrE,IAAI,CAACyD,eAAe;MACvCa,aAAa,EAAE,IAAI,CAACtE,IAAI,CAACuE,gBAAgB;MACzCC,YAAY,EAAE,IAAI,CAACxE,IAAI,CAACyE,eAAe;MACvCC,uBAAuB,EAAE,IAAI,CAAC1E,IAAI,CAAC0E,uBAAuB;MAC1DC,OAAO,EAAE,KAAK;MACdC,IAAI,EAAE,IAAI,CAAC5E,IAAI,CAAC6E;IAAW,CAAC,GAC5B;MACAjB,GAAG,EAAEnC,UAAU;MACfoC,QAAQ,EAAEnC,WAAW;MACrB0C,OAAO,EAAE3C,UAAU;MACnB4C,YAAY,EAAE3C,WAAW;MACzBiD,OAAO,EAAE;IAAK,CAAC;EACrB;EACAvB,IAAI,GAAG,MAAM0B,aAAI,CAACC,YAAY,CAAC3B,IAAI,CAAC;EACpC,IAAI,CAAC7C,GAAG,CAACC,KAAK,CAAE,2DAA0DwE,IAAI,CAACC,SAAS,CAAC7B,IAAI,CAAE,EAAC,CAAC;EACjG,OAAO,MAAM,IAAI,CAAC1C,GAAG,CAACwE,QAAQ,CAAC9B,IAAI,CAAC;AACtC,CAAC;AAED/D,QAAQ,CAAC8F,UAAU,GAAG,eAAeA,UAAUA,CAAEC,QAAQ,EAAE;EACzD,IAAI,CAACA,QAAQ,EAAE;IACbA,QAAQ,GAAG,MAAM,IAAI,CAAC1E,GAAG,CAAC2E,iBAAiB,CAAC,CAAC;IAC7C,IAAI,CAAC9E,GAAG,CAAC+E,IAAI,CAAE,iDAAgDF,QAAS,EAAC,CAAC;EAC5E;EAIA,MAAMG,oBAAoB,GAAIC,OAAO,IAAK;IACxC,MAAMC,MAAM,GAAG,CAAC,CAAC;IACjB,KAAK,MAAM,CAACC,GAAG,EAAEC,KAAK,CAAC,IAAIjG,eAAC,CAACkG,OAAO,CAACJ,OAAO,CAAC,EAAE;MAC7CC,MAAM,CAACC,GAAG,CAAC,GAAGhG,eAAC,CAACmG,QAAQ,CAACF,KAAK,CAAC,GAAGA,KAAK,GAAGX,IAAI,CAACC,SAAS,CAACU,KAAK,CAAC;IACjE;IACA,OAAOF,MAAM;EACf,CAAC;EAED,IAAI,IAAI,CAACK,UAAU,CAACV,QAAQ,CAAC,EAAE;IAE7B,OAAOG,oBAAoB,CAAC,IAAI,CAACO,UAAU,CAACV,QAAQ,CAAC,CAAC;EACxD;EAEA,IAAI,CAACU,UAAU,CAACV,QAAQ,CAAC,GAAG,MAAMW,uBAAc,CAACC,WAAW,CAACZ,QAAQ,EAAE,IAAI,CAAC1E,GAAG,EAAE,IAAI,CAACV,IAAI,CAAC;EAC3F,IAAI,IAAI,CAACG,SAAS,EAAE;IAElB,MAAM,IAAI,CAACA,SAAS,CAACC,UAAU,CAAC,eAAe,CAAC;EAClD;EAEA,OAAOmF,oBAAoB,CAAC,IAAI,CAACO,UAAU,CAACV,QAAQ,CAAC,CAAC;AACxD,CAAC;AAED/F,QAAQ,CAAC4G,SAAS,GAAG,eAAeA,SAASA,CAAA,EAAI;EAC/C,MAAM,IAAI,CAACC,OAAO,CAAC,CAAC;EACpB,MAAM,IAAI,CAACC,QAAQ,CAAC,CAAC;AACvB,CAAC;AAED9G,QAAQ,CAAC+G,aAAa,GAAG,eAAeA,aAAaA,CAAE3E,UAAU,EAAEC,WAAW,EAC5E8B,cAAc,EAAEC,eAAe,EAAEM,YAAY,EAAEE,cAAc,EAAEE,WAAW,EAC1EO,uBAAuB,EAAE2B,kBAAkB,EAAE;EAC7C,IAAI,CAAC9F,GAAG,CAACC,KAAK,CAAE,qBAAoBiB,UAAW,mBAAkBC,WAAY,GAAE,CAAC;EAIhF,IAAI,CAACoD,aAAI,CAACwB,QAAQ,CAACD,kBAAkB,CAAC,EAAE;IACtCA,kBAAkB,GAAG,CAAC,CAAC,IAAI,CAACrG,IAAI,CAACqG,kBAAkB;EACrD;EAEA,IAAIjD,IAAI,GAAG;IACTQ,GAAG,EAAEnC,UAAU;IACfoC,QAAQ,EAAEnC,WAAW;IACrB0C,OAAO,EAAEZ,cAAc,IAAI/B,UAAU;IACrC4C,YAAY,EAAEZ,eAAe,IAAI/B,WAAW;IAC5CoC,MAAM,EAAEC,YAAY;IACpBC,QAAQ,EAAEC,cAAc;IACxBC,KAAK,EAAEC,WAAW;IAClBO,uBAAuB;IACvBC,OAAO,EAAE,CAAC0B;EACZ,CAAC;EACD,IAAI,CAAChD,mBAAmB,GAAG,IAAI,CAACA,mBAAmB,IAAI,CAAC,CAAC;EACzD,IAAI,CAACA,mBAAmB,CAAE,GAAED,IAAI,CAACgB,OAAQ,IAAGhB,IAAI,CAACiB,YAAa,EAAC,CAAC,GAAGjB,IAAI;EACvE,MAAM,IAAI,CAAC1C,GAAG,CAACwE,QAAQ,CAAC9B,IAAI,CAAC;AAC/B,CAAC;AAED/D,QAAQ,CAACkH,KAAK,GAAG,eAAeA,KAAKA,CAAA,EAAI;EACvC,MAAMR,uBAAc,CAACS,QAAQ,CAAC,IAAI,CAAC9F,GAAG,EAAE+F,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC1G,IAAI,EAAE;IAAC2G,SAAS,EAAE;EAAI,CAAC,CAAC,CAAC;EAExF,MAAM,IAAI,CAACC,UAAU,CAAC,CAAC;EACvB,OAAO,OAAM,IAAI,CAACC,eAAe,IAAG,IAAI,CAACC,kBAAkB,CAAC,CAAC,GAAG,IAAI,CAACX,QAAQ,CAAC,CAAC;AACjF,CAAC;AAED9G,QAAQ,CAAC8G,QAAQ,GAAG,eAAeA,QAAQA,CAAA,EAAI;EAC7C,MAAM,IAAI,CAACzF,GAAG,CAACwE,QAAQ,CAAC;IACtBtB,GAAG,EAAE,IAAI,CAAC5D,IAAI,CAACyB,UAAU;IACzBoC,QAAQ,EAAE,IAAI,CAAC7D,IAAI,CAAC0B,WAAW;IAC/BoC,MAAM,EAAE,IAAI,CAAC9D,IAAI,CAAC+D,YAAY;IAC9BC,QAAQ,EAAE,IAAI,CAAChE,IAAI,CAACiE,cAAc;IAClCC,KAAK,EAAE,IAAI,CAAClE,IAAI,CAACmE,WAAW;IAC5BC,OAAO,EAAE,IAAI,CAACpE,IAAI,CAACwD,cAAc;IACjCa,YAAY,EAAE,IAAI,CAACrE,IAAI,CAACyD,eAAe;IACvCa,aAAa,EAAE,IAAI,CAACtE,IAAI,CAACuE,gBAAgB;IACzCC,YAAY,EAAE,IAAI,CAACxE,IAAI,CAACyE,eAAe;IACvCC,uBAAuB,EAAE,IAAI,CAAC1E,IAAI,CAAC0E,uBAAuB;IAC1DC,OAAO,EAAE,CAAC,IAAI,CAAC3E,IAAI,CAACqG,kBAAkB;IACtCzB,IAAI,EAAE,IAAI,CAAC5E,IAAI,CAAC6E;EAClB,CAAC,CAAC;AACJ,CAAC;AAIDxF,QAAQ,CAAC0H,MAAM,GAAG,eAAeA,MAAMA,CAAEC,GAAG,EAAE;EAC5C,MAAM,IAAI,CAACtG,GAAG,CAACuG,QAAQ,CAACD,GAAG,EAAE,IAAI,CAAChH,IAAI,CAACyB,UAAU,CAAC;AACpD,CAAC;AAGDpC,QAAQ,CAAC6H,QAAQ,GAAG,eAAeA,QAAQA,CAAA,EAAI;EAC7C,MAAM,IAAI,CAACxG,GAAG,CAACyG,SAAS,CAAC,IAAI,CAACnH,IAAI,CAACyB,UAAU,CAAC;EAE9C,MAAM,IAAI,CAACmF,UAAU,CAAC,CAAC;AACzB,CAAC;AAEDvH,QAAQ,CAAC+H,iBAAiB,GAAG,eAAeA,iBAAiBA,CAAA,EAAI;EAE/D,IAAIC,GAAG,GAAG,MAAM,IAAI,CAAC3G,GAAG,CAACC,KAAK,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;EAChE,IAAI0G,GAAG,EAAE;IACP,IAAIC,GAAG,GAAG1E,QAAQ,CAACyE,GAAG,EAAE,EAAE,CAAC;IAE3B,IAAI,CAACE,KAAK,CAACD,GAAG,CAAC,EAAE;MACf,OAAOA,GAAG;IACZ;IACA,IAAI,CAAC/G,GAAG,CAACC,KAAK,CAAE,kCAAiC6G,GAAI,GAAE,CAAC;EAC1D;EAEAA,GAAG,GAAG,MAAM,IAAI,CAAC3G,GAAG,CAACC,KAAK,CAAC,CAAC,SAAS,EAAE,qBAAqB,CAAC,CAAC;EAC9D,IAAI0G,GAAG,EAAE;IACP,IAAIC,GAAG,GAAG1E,QAAQ,CAACyE,GAAG,EAAE,EAAE,CAAC;IAC3B,IAAI,CAACE,KAAK,CAACD,GAAG,CAAC,EAAE;MACf,OAAOA,GAAG;IACZ;IACA,IAAI,CAAC/G,GAAG,CAACC,KAAK,CAAE,kCAAiC6G,GAAI,GAAE,CAAC;EAC1D;EAEA,IAAI,CAAC9G,GAAG,CAACiH,aAAa,CAAC,yCAAyC,CAAC;AACnE,CAAC;AAEDnI,QAAQ,CAACoI,yBAAyB,GAAG,eAAeA,yBAAyBA,CAAEzH,IAAI,GAAG,CAAC,CAAC,EAAE;EACxF,MAAM;IAAC8D;EAAM,CAAC,GAAG9D,IAAI;EACrB,IAAI,CAAC8E,aAAI,CAACwB,QAAQ,CAACxC,MAAM,CAAC,EAAE;IAC1B,MAAM,IAAI4D,cAAM,CAACC,oBAAoB,CAAE,+BAA8B,CAAC;EACxE;EAEA,MAAM,IAAI,CAACjH,GAAG,CAACkH,mBAAmB,CAAC9D,MAAM,CAAC;AAC5C,CAAC;AAQDzE,QAAQ,CAACwI,sBAAsB,GAAG,eAAeA,sBAAsBA,CAAA,EAAI;EACzE,OAAO,MAAM,IAAI,CAACnH,GAAG,CAACoH,gBAAgB,CAAC,CAAC;AAC1C,CAAC;AAeDzI,QAAQ,CAAC0I,aAAa,GAAG,eAAeA,aAAaA,CAAE/H,IAAI,GAAG,CAAC,CAAC,EAAE;EAChE,OAAO,MAAM,IAAI,CAACU,GAAG,CAACsH,UAAU,CAAChI,IAAI,CAAC;AACxC,CAAC;AAyBDX,QAAQ,CAAC4I,YAAY,GAAG,eAAeA,YAAYA,CAAEjI,IAAI,GAAG,CAAC,CAAC,EAAE;EAC9D,MAAM;IAAE0F,GAAG;IAAEwC,IAAI;IAAEC,QAAQ;IAAEC;EAAU,CAAC,GAAGpI,IAAI;EAC/C,IAAI,CAAC0F,GAAG,IAAI,CAACwC,IAAI,EAAE;IACjB,MAAM,IAAI,CAACG,MAAM,CAAC,CAAC;EACrB,CAAC,MAAM;IACL,MAAMtC,uBAAc,CAACsC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC3H,GAAG,EAAE;MAC1C4H,SAAS,EAAE5C,GAAG;MACd6C,UAAU,EAAEL,IAAI;MAChBM,cAAc,EAAEL,QAAQ;MACxBM,oBAAoB,EAAEL;IACxB,CAAC,CAAC;EACJ;AACF,CAAC;AAED3B,MAAM,CAACC,MAAM,CAACnH,UAAU,EAAEF,QAAQ,EAAEC,OAAO,CAAC;AAAC,IAAAoJ,QAAA,GAE9BnJ,UAAU;AAAAC,OAAA,CAAAmJ,OAAA,GAAAD,QAAA"}
+exports.default = extensions;
+//# sourceMappingURL=general.js.map