appium 2.0.0-beta.46 → 2.0.0-beta.48

package/build/lib/utils.js

@@ -1,224 +1,373 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.adjustNodePath = adjustNodePath;
-exports.getPackageVersion = getPackageVersion;
-exports.insertAppiumPrefixes = insertAppiumPrefixes;
-exports.inspect = void 0;
-exports.parseCapsForInnerDriver = parseCapsForInnerDriver;
-exports.pullSettings = pullSettings;
-exports.removeAppiumPrefixes = removeAppiumPrefixes;
-
-require("source-map-support/register");
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _logger = _interopRequireDefault(require("./logger"));
-
-var _baseDriver = require("@appium/base-driver");
-
-var _util = require("util");
-
-var _support = require("@appium/support");
-
-var _path = _interopRequireDefault(require("path"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adjustNodePath = exports.removeAppiumPrefixes = exports.pullSettings = exports.getPackageVersion = exports.insertAppiumPrefixes = exports.parseCapsForInnerDriver = exports.inspect = exports.isPluginCommandArgs = exports.isDriverCommandArgs = exports.isExtensionCommandArgs = exports.isServerCommandArgs = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const logger_1 = __importDefault(require("./logger"));
+const base_driver_1 = require("@appium/base-driver");
+const util_1 = require("util");
+const support_1 = require("@appium/support");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
 const W3C_APPIUM_PREFIX = 'appium';
-const STANDARD_CAPS_LOWERCASE = new Set([..._baseDriver.STANDARD_CAPS].map(cap => cap.toLowerCase()));
+const STANDARD_CAPS_LOWERCASE = new Set([...base_driver_1.STANDARD_CAPS].map((cap) => cap.toLowerCase()));
+/**
+ *
+ * If `stdout` is a TTY, this is `true`.
+ *
+ * Used for tighter control over log output.
+ * @type {boolean}
+ */
 const isStdoutTTY = process.stdout.isTTY;
-
-const inspect = _lodash.default.flow(_lodash.default.partialRight(_util.inspect, {
-  colors: true,
-  depth: null,
-  compact: !isStdoutTTY
-}), (...args) => {
-  _logger.default.info(...args);
+/**
+ * Dumps to value to the console using `info` logger.
+ *
+ * @todo May want to force color to be `false` if {@link isStdoutTTY} is `false`.
+ */
+const inspect = lodash_1.default.flow(lodash_1.default.partialRight(
+/** @type {(object: any, options: import('util').InspectOptions) => string} */ (util_1.inspect), { colors: true, depth: null, compact: !isStdoutTTY }), (...args) => {
+    logger_1.default.info(...args);
 });
-
 exports.inspect = inspect;
-
-function parseCapsForInnerDriver(jsonwpCapabilities, w3cCapabilities, constraints = {}, defaultCapabilities = {}) {
-  const hasW3CCaps = _lodash.default.isPlainObject(w3cCapabilities) && (_lodash.default.has(w3cCapabilities, 'alwaysMatch') || _lodash.default.has(w3cCapabilities, 'firstMatch'));
-
-  const hasJSONWPCaps = _lodash.default.isPlainObject(jsonwpCapabilities);
-
-  let desiredCaps = {};
-  let processedW3CCapabilities;
-  let processedJsonwpCapabilities;
-
-  if (!hasW3CCaps) {
-    return {
-      protocol: _baseDriver.PROTOCOLS.W3C,
-      error: new Error('W3C capabilities should be provided')
-    };
-  }
-
-  const {
-    W3C
-  } = _baseDriver.PROTOCOLS;
-  const protocol = W3C;
-  jsonwpCapabilities = _lodash.default.cloneDeep(jsonwpCapabilities);
-  w3cCapabilities = _lodash.default.cloneDeep(w3cCapabilities);
-  defaultCapabilities = _lodash.default.cloneDeep(defaultCapabilities);
-
-  if (!_lodash.default.isEmpty(defaultCapabilities)) {
-    if (hasW3CCaps) {
-      for (const [defaultCapKey, defaultCapValue] of _lodash.default.toPairs(defaultCapabilities)) {
-        let isCapAlreadySet = false;
-
-        for (const firstMatchEntry of w3cCapabilities.firstMatch ?? []) {
-          if (_lodash.default.isPlainObject(firstMatchEntry) && _lodash.default.has(removeAppiumPrefixes(firstMatchEntry), removeAppiumPrefix(defaultCapKey))) {
-            isCapAlreadySet = true;
-            break;
-          }
-        }
-
-        isCapAlreadySet = isCapAlreadySet || _lodash.default.isPlainObject(w3cCapabilities.alwaysMatch) && _lodash.default.has(removeAppiumPrefixes(w3cCapabilities.alwaysMatch), removeAppiumPrefix(defaultCapKey));
-
-        if (isCapAlreadySet) {
-          continue;
+/**
+ * Takes the caps that were provided in the request and translates them
+ * into caps that can be used by the inner drivers.
+ *
+ * @template {Constraints} C
+ * @template [J=any]
+ * @param {J} jsonwpCapabilities
+ * @param {W3CCapabilities<C>} w3cCapabilities
+ * @param {C} constraints
+ * @param {NSCapabilities<C>} [defaultCapabilities]
+ * @returns {ParsedDriverCaps<C,J>|InvalidCaps<C,J>}
+ */
+function parseCapsForInnerDriver(jsonwpCapabilities, w3cCapabilities, constraints = /** @type {C} */ ({}), defaultCapabilities = {}) {
+    // Check if the caller sent JSONWP caps, W3C caps, or both
+    const hasW3CCaps = lodash_1.default.isPlainObject(w3cCapabilities) &&
+        (lodash_1.default.has(w3cCapabilities, 'alwaysMatch') || lodash_1.default.has(w3cCapabilities, 'firstMatch'));
+    const hasJSONWPCaps = lodash_1.default.isPlainObject(jsonwpCapabilities);
+    let desiredCaps = /** @type {ParsedDriverCaps<C>['desiredCaps']} */ ({});
+    /** @type {ParsedDriverCaps<C>['processedW3CCapabilities']} */
+    let processedW3CCapabilities;
+    /** @type {ParsedDriverCaps<C>['processedJsonwpCapabilities']} */
+    let processedJsonwpCapabilities;
+    if (!hasW3CCaps) {
+        return /** @type {InvalidCaps<C>} */ ({
+            protocol: base_driver_1.PROTOCOLS.W3C,
+            error: new Error('W3C capabilities should be provided'),
+        });
+    }
+    const { W3C } = base_driver_1.PROTOCOLS;
+    const protocol = W3C;
+    // Make sure we don't mutate the original arguments
+    jsonwpCapabilities = lodash_1.default.cloneDeep(jsonwpCapabilities);
+    w3cCapabilities = lodash_1.default.cloneDeep(w3cCapabilities);
+    defaultCapabilities = lodash_1.default.cloneDeep(defaultCapabilities);
+    if (!lodash_1.default.isEmpty(defaultCapabilities)) {
+        if (hasW3CCaps) {
+            for (const [defaultCapKey, defaultCapValue] of lodash_1.default.toPairs(defaultCapabilities)) {
+                let isCapAlreadySet = false;
+                // Check if the key is already present in firstMatch entries
+                for (const firstMatchEntry of w3cCapabilities.firstMatch ?? []) {
+                    if (lodash_1.default.isPlainObject(firstMatchEntry) &&
+                        lodash_1.default.has(removeAppiumPrefixes(firstMatchEntry), removeAppiumPrefix(defaultCapKey))) {
+                        isCapAlreadySet = true;
+                        break;
+                    }
+                }
+                // Check if the key is already present in alwaysMatch entries
+                isCapAlreadySet =
+                    isCapAlreadySet ||
+                        (lodash_1.default.isPlainObject(w3cCapabilities.alwaysMatch) &&
+                            lodash_1.default.has(removeAppiumPrefixes(w3cCapabilities.alwaysMatch), removeAppiumPrefix(defaultCapKey)));
+                if (isCapAlreadySet) {
+                    // Skip if the key is already present in the provided caps
+                    continue;
+                }
+                // Only add the default capability if it is not overridden
+                if (lodash_1.default.isEmpty(w3cCapabilities.firstMatch)) {
+                    w3cCapabilities.firstMatch = /** @type {W3CCapabilities<C>['firstMatch']} */ ([
+                        { [defaultCapKey]: defaultCapValue },
+                    ]);
+                }
+                else {
+                    w3cCapabilities.firstMatch[0][defaultCapKey] = defaultCapValue;
+                }
+            }
         }
-
-        if (_lodash.default.isEmpty(w3cCapabilities.firstMatch)) {
-          w3cCapabilities.firstMatch = [{
-            [defaultCapKey]: defaultCapValue
-          }];
-        } else {
-          w3cCapabilities.firstMatch[0][defaultCapKey] = defaultCapValue;
+        if (hasJSONWPCaps) {
+            jsonwpCapabilities = {
+                ...removeAppiumPrefixes(defaultCapabilities),
+                ...jsonwpCapabilities,
+            };
         }
-      }
     }
-
+    // Get MJSONWP caps
     if (hasJSONWPCaps) {
-      jsonwpCapabilities = { ...removeAppiumPrefixes(defaultCapabilities),
-        ...jsonwpCapabilities
-      };
+        processedJsonwpCapabilities = { ...jsonwpCapabilities };
     }
-  }
-
-  if (hasJSONWPCaps) {
-    processedJsonwpCapabilities = { ...jsonwpCapabilities
-    };
-  }
-
-  if (hasW3CCaps) {
-    try {
-      desiredCaps = (0, _baseDriver.processCapabilities)(w3cCapabilities, constraints, true);
-    } catch (error) {
-      _logger.default.info(`Could not parse W3C capabilities: ${error.message}`);
-
-      return {
+    // Get W3C caps
+    if (hasW3CCaps) {
+        // Call the process capabilities algorithm to find matching caps on the W3C
+        // (see: https://github.com/jlipps/simple-wd-spec#processing-capabilities)
+        try {
+            desiredCaps = (0, base_driver_1.processCapabilities)(w3cCapabilities, constraints, true);
+        }
+        catch (error) {
+            logger_1.default.info(`Could not parse W3C capabilities: ${error.message}`);
+            return /** @type {InvalidCaps<C,J>} */ ({
+                desiredCaps,
+                processedJsonwpCapabilities,
+                processedW3CCapabilities,
+                protocol,
+                error,
+            });
+        }
+        // Create a new w3c capabilities payload that contains only the matching caps in `alwaysMatch`
+        processedW3CCapabilities = {
+            alwaysMatch: { ...insertAppiumPrefixes(desiredCaps) },
+            firstMatch: [{}],
+        };
+    }
+    return /** @type {ParsedDriverCaps<C,J>} */ ({
         desiredCaps,
         processedJsonwpCapabilities,
         processedW3CCapabilities,
         protocol,
-        error
-      };
-    }
-
-    processedW3CCapabilities = {
-      alwaysMatch: { ...insertAppiumPrefixes(desiredCaps)
-      },
-      firstMatch: [{}]
-    };
-  }
-
-  return {
-    desiredCaps,
-    processedJsonwpCapabilities,
-    processedW3CCapabilities,
-    protocol
-  };
+    });
 }
-
+exports.parseCapsForInnerDriver = parseCapsForInnerDriver;
+/**
+ * Takes a capabilities objects and prefixes capabilities with `appium:`
+ * @template {Constraints} [C={}]
+ * @param {Capabilities<C>} caps - Desired capabilities object
+ * @returns {NSCapabilities<C>}
+ */
 function insertAppiumPrefixes(caps) {
-  return _lodash.default.mapKeys(caps, (_, key) => STANDARD_CAPS_LOWERCASE.has(key.toLowerCase()) || key.includes(':') ? key : `${W3C_APPIUM_PREFIX}:${key}`);
+    return /** @type {NSCapabilities<C>} */ (lodash_1.default.mapKeys(caps, (_, key) => STANDARD_CAPS_LOWERCASE.has(key.toLowerCase()) || key.includes(':')
+        ? key
+        : `${W3C_APPIUM_PREFIX}:${key}`));
 }
-
+exports.insertAppiumPrefixes = insertAppiumPrefixes;
+/**
+ * @template {Constraints} [C={}]
+ * @param {NSCapabilities<C>} caps
+ * @returns {Capabilities<C>}
+ */
 function removeAppiumPrefixes(caps) {
-  return _lodash.default.mapKeys(caps, (_, key) => removeAppiumPrefix(key));
+    return /** @type {Capabilities<C>} */ (lodash_1.default.mapKeys(caps, (_, key) => removeAppiumPrefix(key)));
 }
-
+exports.removeAppiumPrefixes = removeAppiumPrefixes;
+/**
+ * @param {string} key
+ * @returns {string}
+ */
 function removeAppiumPrefix(key) {
-  const prefix = `${W3C_APPIUM_PREFIX}:`;
-  return _lodash.default.startsWith(key, prefix) ? key.substring(prefix.length) : key;
+    const prefix = `${W3C_APPIUM_PREFIX}:`;
+    return lodash_1.default.startsWith(key, prefix) ? key.substring(prefix.length) : key;
 }
-
+/**
+ *
+ * @param {string} pkgName
+ * @returns {string|undefined}
+ */
 function getPackageVersion(pkgName) {
-  const pkgInfo = require(`${pkgName}/package.json`) || {};
-  return pkgInfo.version;
+    const pkgInfo = require(`${pkgName}/package.json`) || {};
+    return pkgInfo.version;
 }
-
+exports.getPackageVersion = getPackageVersion;
+/**
+ * Adjusts NODE_PATH environment variable,
+ * so drivers and plugins could load their peer dependencies.
+ * Read https://nodejs.org/api/modules.html#loading-from-the-global-folders
+ * for more details.
+ * @returns {void}
+ */
 function adjustNodePath() {
-  const selfRoot = _support.node.getModuleRootSync('appium', __filename);
-
-  if (!selfRoot || _path.default.dirname(selfRoot).length >= selfRoot.length) {
-    return;
-  }
-
-  const nodeModulesRoot = _path.default.dirname(selfRoot);
-
-  const refreshRequirePaths = () => {
-    try {
-      require('module').Module._initPaths();
-
-      return true;
-    } catch (e) {
-      return false;
+    const selfRoot = support_1.node.getModuleRootSync('appium', __filename);
+    if (!selfRoot || path_1.default.dirname(selfRoot).length >= selfRoot.length) {
+        return;
+    }
+    const nodeModulesRoot = path_1.default.dirname(selfRoot);
+    const refreshRequirePaths = () => {
+        try {
+            // ! This hack allows us to avoid modification of import
+            // ! statements in client modules. It uses a private API though,
+            // ! so it could break (maybe, eventually).
+            // See https://gist.github.com/branneman/8048520#7-the-hack
+            // @ts-ignore
+            require('module').Module._initPaths();
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    };
+    if (!process.env.NODE_PATH) {
+        process.env.NODE_PATH = nodeModulesRoot;
+        if (refreshRequirePaths()) {
+            process.env.APPIUM_OMIT_PEER_DEPS = '1';
+        }
+        else {
+            delete process.env.NODE_PATH;
+        }
+        return;
+    }
+    const nodePathParts = process.env.NODE_PATH.split(path_1.default.delimiter);
+    if (nodePathParts.includes(nodeModulesRoot)) {
+        process.env.APPIUM_OMIT_PEER_DEPS = '1';
+        return;
     }
-  };
-
-  if (!process.env.NODE_PATH) {
-    process.env.NODE_PATH = nodeModulesRoot;
-
+    nodePathParts.push(nodeModulesRoot);
+    process.env.NODE_PATH = nodePathParts.join(path_1.default.delimiter);
     if (refreshRequirePaths()) {
-      process.env.APPIUM_OMIT_PEER_DEPS = '1';
-    } else {
-      delete process.env.NODE_PATH;
+        process.env.APPIUM_OMIT_PEER_DEPS = '1';
+    }
+    else {
+        process.env.NODE_PATH = lodash_1.default.without(nodePathParts, nodeModulesRoot).join(path_1.default.delimiter);
     }
-
-    return;
-  }
-
-  const nodePathParts = process.env.NODE_PATH.split(_path.default.delimiter);
-
-  if (nodePathParts.includes(nodeModulesRoot)) {
-    process.env.APPIUM_OMIT_PEER_DEPS = '1';
-    return;
-  }
-
-  nodePathParts.push(nodeModulesRoot);
-  process.env.NODE_PATH = nodePathParts.join(_path.default.delimiter);
-
-  if (refreshRequirePaths()) {
-    process.env.APPIUM_OMIT_PEER_DEPS = '1';
-  } else {
-    process.env.NODE_PATH = _lodash.default.without(nodePathParts, nodeModulesRoot).join(_path.default.delimiter);
-  }
 }
-
+exports.adjustNodePath = adjustNodePath;
+/**
+ * Pulls the initial values of Appium settings from the given capabilities argument.
+ * Each setting item must satisfy the following format:
+ * `setting[setting_name]: setting_value`
+ * The capabilities argument itself gets mutated, so it does not contain parsed
+ * settings anymore to avoid further parsing issues.
+ * Check
+ * https://github.com/appium/appium/blob/master/docs/en/advanced-concepts/settings.md
+ * for more details on the available settings.
+ *
+ * @param {?Object} caps - Capabilities dictionary. It is mutated if
+ * one or more settings have been pulled from it
+ * @return {Object} - An empty dictionary if the given caps contains no
+ * setting items or a dictionary containing parsed Appium setting names along with
+ * their values.
+ */
 function pullSettings(caps) {
-  if (!_lodash.default.isPlainObject(caps) || _lodash.default.isEmpty(caps)) {
-    return {};
-  }
-
-  const result = {};
-
-  for (const [key, value] of _lodash.default.toPairs(caps)) {
-    const match = /\bsettings\[(\S+)\]$/.exec(key);
-
-    if (!match) {
-      continue;
+    if (!lodash_1.default.isPlainObject(caps) || lodash_1.default.isEmpty(caps)) {
+        return {};
     }
-
-    result[match[1]] = value;
-    delete caps[key];
-  }
-
-  return result;
+    const result = {};
+    for (const [key, value] of lodash_1.default.toPairs(caps)) {
+        const match = /\bsettings\[(\S+)\]$/.exec(key);
+        if (!match) {
+            continue;
+        }
+        result[match[1]] = value;
+        delete caps[key];
+    }
+    return result;
+}
+exports.pullSettings = pullSettings;
+/**
+ * @template {CliCommand} [Cmd=ServerCommand]
+ * @template {CliExtensionSubcommand|void} [SubCmd=void]
+ * @param {Args<Cmd, SubCmd>} args
+ * @returns {args is Args<ServerCommand>}
+ */
+function isServerCommandArgs(args) {
+    return args.subcommand === constants_1.SERVER_SUBCOMMAND;
+}
+exports.isServerCommandArgs = isServerCommandArgs;
+/**
+ * @template {CliCommand} [Cmd=ServerCommand]
+ * @template {CliExtensionSubcommand|void} [SubCmd=void]
+ * @param {Args<Cmd, SubCmd>} args
+ * @returns {args is Args<CliExtensionCommand, SubCmd>}
+ */
+function isExtensionCommandArgs(args) {
+    return args.subcommand === constants_1.DRIVER_TYPE || args.subcommand === constants_1.PLUGIN_TYPE;
+}
+exports.isExtensionCommandArgs = isExtensionCommandArgs;
+/**
+ * @template {CliCommand} Cmd
+ * @template {CliExtensionSubcommand} SubCmd
+ * @param {Args<Cmd, SubCmd>} args
+ * @returns {args is Args<DriverCommand, SubCmd>}
+ */
+function isDriverCommandArgs(args) {
+    return args.subcommand === constants_1.DRIVER_TYPE;
+}
+exports.isDriverCommandArgs = isDriverCommandArgs;
+/**
+ * @template {CliCommand} Cmd
+ * @template {CliExtensionSubcommand} SubCmd
+ * @param {Args<Cmd, SubCmd>} args
+ * @returns {args is Args<PluginCommand, SubCmd>}
+ */
+function isPluginCommandArgs(args) {
+    return args.subcommand === constants_1.PLUGIN_TYPE;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["W3C_APPIUM_PREFIX","STANDARD_CAPS_LOWERCASE","Set","STANDARD_CAPS","map","cap","toLowerCase","isStdoutTTY","process","stdout","isTTY","inspect","_","flow","partialRight","dump","colors","depth","compact","args","logger","info","parseCapsForInnerDriver","jsonwpCapabilities","w3cCapabilities","constraints","defaultCapabilities","hasW3CCaps","isPlainObject","has","hasJSONWPCaps","desiredCaps","processedW3CCapabilities","processedJsonwpCapabilities","protocol","PROTOCOLS","W3C","error","Error","cloneDeep","isEmpty","defaultCapKey","defaultCapValue","toPairs","isCapAlreadySet","firstMatchEntry","firstMatch","removeAppiumPrefixes","removeAppiumPrefix","alwaysMatch","processCapabilities","message","insertAppiumPrefixes","caps","mapKeys","key","includes","prefix","startsWith","substring","length","getPackageVersion","pkgName","pkgInfo","require","version","adjustNodePath","selfRoot","node","getModuleRootSync","__filename","path","dirname","nodeModulesRoot","refreshRequirePaths","Module","_initPaths","e","env","NODE_PATH","APPIUM_OMIT_PEER_DEPS","nodePathParts","split","delimiter","push","join","without","pullSettings","result","value","match","exec"],"sources":["../../lib/utils.js"],"sourcesContent":["import _ from 'lodash';\nimport logger from './logger';\nimport {processCapabilities, PROTOCOLS, STANDARD_CAPS} from '@appium/base-driver';\nimport {inspect as dump} from 'util';\nimport {node} from '@appium/support';\nimport path from 'path';\n\nconst W3C_APPIUM_PREFIX = 'appium';\nconst STANDARD_CAPS_LOWERCASE = new Set([...STANDARD_CAPS].map((cap) => cap.toLowerCase()));\n\n/**\n *\n * If `stdout` is a TTY, this is `true`.\n *\n * Used for tighter control over log output.\n * @type {boolean}\n */\nconst isStdoutTTY = process.stdout.isTTY;\n\n/**\n * Dumps to value to the console using `info` logger.\n *\n * @todo May want to force color to be `false` if {@link isStdoutTTY} is `false`.\n */\nconst inspect = _.flow(\n  _.partialRight(\n    /** @type {(object: any, options: import('util').InspectOptions) => string} */ (dump),\n    {colors: true, depth: null, compact: !isStdoutTTY}\n  ),\n  (...args) => {\n    logger.info(...args);\n  }\n);\n\n/**\n * Takes the caps that were provided in the request and translates them\n * into caps that can be used by the inner drivers.\n *\n * @template {Constraints} C\n * @template [J=any]\n * @param {J} jsonwpCapabilities\n * @param {W3CCapabilities<C>} w3cCapabilities\n * @param {C} constraints\n * @param {NSCapabilities<C>} [defaultCapabilities]\n * @returns {ParsedDriverCaps<C,J>|InvalidCaps<C,J>}\n */\nfunction parseCapsForInnerDriver(\n  jsonwpCapabilities,\n  w3cCapabilities,\n  constraints = /** @type {C} */ ({}),\n  defaultCapabilities = {}\n) {\n  // Check if the caller sent JSONWP caps, W3C caps, or both\n  const hasW3CCaps =\n    _.isPlainObject(w3cCapabilities) &&\n    (_.has(w3cCapabilities, 'alwaysMatch') || _.has(w3cCapabilities, 'firstMatch'));\n  const hasJSONWPCaps = _.isPlainObject(jsonwpCapabilities);\n  let desiredCaps = /** @type {ParsedDriverCaps<C>['desiredCaps']} */ ({});\n  /** @type {ParsedDriverCaps<C>['processedW3CCapabilities']} */\n  let processedW3CCapabilities;\n  /** @type {ParsedDriverCaps<C>['processedJsonwpCapabilities']} */\n  let processedJsonwpCapabilities;\n\n  if (!hasW3CCaps) {\n    return /** @type {InvalidCaps<C>} */ ({\n      protocol: PROTOCOLS.W3C,\n      error: new Error('W3C capabilities should be provided'),\n    });\n  }\n\n  const {W3C} = PROTOCOLS;\n  const protocol = W3C;\n\n  // Make sure we don't mutate the original arguments\n  jsonwpCapabilities = _.cloneDeep(jsonwpCapabilities);\n  w3cCapabilities = _.cloneDeep(w3cCapabilities);\n  defaultCapabilities = _.cloneDeep(defaultCapabilities);\n\n  if (!_.isEmpty(defaultCapabilities)) {\n    if (hasW3CCaps) {\n      for (const [defaultCapKey, defaultCapValue] of _.toPairs(defaultCapabilities)) {\n        let isCapAlreadySet = false;\n        // Check if the key is already present in firstMatch entries\n        for (const firstMatchEntry of w3cCapabilities.firstMatch ?? []) {\n          if (\n            _.isPlainObject(firstMatchEntry) &&\n            _.has(removeAppiumPrefixes(firstMatchEntry), removeAppiumPrefix(defaultCapKey))\n          ) {\n            isCapAlreadySet = true;\n            break;\n          }\n        }\n        // Check if the key is already present in alwaysMatch entries\n        isCapAlreadySet =\n          isCapAlreadySet ||\n          (_.isPlainObject(w3cCapabilities.alwaysMatch) &&\n            _.has(\n              removeAppiumPrefixes(w3cCapabilities.alwaysMatch),\n              removeAppiumPrefix(defaultCapKey)\n            ));\n        if (isCapAlreadySet) {\n          // Skip if the key is already present in the provided caps\n          continue;\n        }\n\n        // Only add the default capability if it is not overridden\n        if (_.isEmpty(w3cCapabilities.firstMatch)) {\n          w3cCapabilities.firstMatch = /** @type {W3CCapabilities<C>['firstMatch']} */ ([\n            {[defaultCapKey]: defaultCapValue},\n          ]);\n        } else {\n          w3cCapabilities.firstMatch[0][defaultCapKey] = defaultCapValue;\n        }\n      }\n    }\n    if (hasJSONWPCaps) {\n      jsonwpCapabilities = {\n        ...removeAppiumPrefixes(defaultCapabilities),\n        ...jsonwpCapabilities,\n      };\n    }\n  }\n\n  // Get MJSONWP caps\n  if (hasJSONWPCaps) {\n    processedJsonwpCapabilities = {...jsonwpCapabilities};\n  }\n\n  // Get W3C caps\n  if (hasW3CCaps) {\n    // Call the process capabilities algorithm to find matching caps on the W3C\n    // (see: https://github.com/jlipps/simple-wd-spec#processing-capabilities)\n    try {\n      desiredCaps = processCapabilities(w3cCapabilities, constraints, true);\n    } catch (error) {\n      logger.info(`Could not parse W3C capabilities: ${error.message}`);\n      return /** @type {InvalidCaps<C,J>} */ ({\n        desiredCaps,\n        processedJsonwpCapabilities,\n        processedW3CCapabilities,\n        protocol,\n        error,\n      });\n    }\n\n    // Create a new w3c capabilities payload that contains only the matching caps in `alwaysMatch`\n    processedW3CCapabilities = {\n      alwaysMatch: {...insertAppiumPrefixes(desiredCaps)},\n      firstMatch: [{}],\n    };\n  }\n\n  return /** @type {ParsedDriverCaps<C,J>} */ ({\n    desiredCaps,\n    processedJsonwpCapabilities,\n    processedW3CCapabilities,\n    protocol,\n  });\n}\n\n/**\n * Takes a capabilities objects and prefixes capabilities with `appium:`\n * @template {Constraints} [C={}]\n * @param {Capabilities<C>} caps - Desired capabilities object\n * @returns {NSCapabilities<C>}\n */\nfunction insertAppiumPrefixes(caps) {\n  return /** @type {NSCapabilities<C>} */ (\n    _.mapKeys(caps, (_, key) =>\n      STANDARD_CAPS_LOWERCASE.has(key.toLowerCase()) || key.includes(':')\n        ? key\n        : `${W3C_APPIUM_PREFIX}:${key}`\n    )\n  );\n}\n\n/**\n * @template {Constraints} [C={}]\n * @param {NSCapabilities<C>} caps\n * @returns {Capabilities<C>}\n */\nfunction removeAppiumPrefixes(caps) {\n  return /** @type {Capabilities<C>} */ (_.mapKeys(caps, (_, key) => removeAppiumPrefix(key)));\n}\n\n/**\n * @param {string} key\n * @returns {string}\n */\nfunction removeAppiumPrefix(key) {\n  const prefix = `${W3C_APPIUM_PREFIX}:`;\n  return _.startsWith(key, prefix) ? key.substring(prefix.length) : key;\n}\n\n/**\n *\n * @param {string} pkgName\n * @returns {string|undefined}\n */\nfunction getPackageVersion(pkgName) {\n  const pkgInfo = require(`${pkgName}/package.json`) || {};\n  return pkgInfo.version;\n}\n\n/**\n * Adjusts NODE_PATH environment variable,\n * so drivers and plugins could load their peer dependencies.\n * Read https://nodejs.org/api/modules.html#loading-from-the-global-folders\n * for more details.\n * @returns {void}\n */\nfunction adjustNodePath() {\n  const selfRoot = node.getModuleRootSync('appium', __filename);\n  if (!selfRoot || path.dirname(selfRoot).length >= selfRoot.length) {\n    return;\n  }\n  const nodeModulesRoot = path.dirname(selfRoot);\n\n  const refreshRequirePaths = () => {\n    try {\n      // ! This hack allows us to avoid modification of import\n      // ! statements in client modules. It uses a private API though,\n      // ! so it could break (maybe, eventually).\n      // See https://gist.github.com/branneman/8048520#7-the-hack\n      // @ts-ignore\n      require('module').Module._initPaths();\n      return true;\n    } catch (e) {\n      return false;\n    }\n  };\n\n  if (!process.env.NODE_PATH) {\n    process.env.NODE_PATH = nodeModulesRoot;\n    if (refreshRequirePaths()) {\n      process.env.APPIUM_OMIT_PEER_DEPS = '1';\n    } else {\n      delete process.env.NODE_PATH;\n    }\n    return;\n  }\n\n  const nodePathParts = process.env.NODE_PATH.split(path.delimiter);\n  if (nodePathParts.includes(nodeModulesRoot)) {\n    process.env.APPIUM_OMIT_PEER_DEPS = '1';\n    return;\n  }\n\n  nodePathParts.push(nodeModulesRoot);\n  process.env.NODE_PATH = nodePathParts.join(path.delimiter);\n  if (refreshRequirePaths()) {\n    process.env.APPIUM_OMIT_PEER_DEPS = '1';\n  } else {\n    process.env.NODE_PATH = _.without(nodePathParts, nodeModulesRoot).join(path.delimiter);\n  }\n}\n\n/**\n * Pulls the initial values of Appium settings from the given capabilities argument.\n * Each setting item must satisfy the following format:\n * `setting[setting_name]: setting_value`\n * The capabilities argument itself gets mutated, so it does not contain parsed\n * settings anymore to avoid further parsing issues.\n * Check\n * https://github.com/appium/appium/blob/master/docs/en/advanced-concepts/settings.md\n * for more details on the available settings.\n *\n * @param {?Object} caps - Capabilities dictionary. It is mutated if\n * one or more settings have been pulled from it\n * @return {Object} - An empty dictionary if the given caps contains no\n * setting items or a dictionary containing parsed Appium setting names along with\n * their values.\n */\nfunction pullSettings(caps) {\n  if (!_.isPlainObject(caps) || _.isEmpty(caps)) {\n    return {};\n  }\n\n  const result = {};\n  for (const [key, value] of _.toPairs(caps)) {\n    const match = /\\bsettings\\[(\\S+)\\]$/.exec(key);\n    if (!match) {\n      continue;\n    }\n\n    result[match[1]] = value;\n    delete caps[key];\n  }\n  return result;\n}\n\nexport {\n  inspect,\n  parseCapsForInnerDriver,\n  insertAppiumPrefixes,\n  getPackageVersion,\n  pullSettings,\n  removeAppiumPrefixes,\n  adjustNodePath,\n};\n\n/**\n * @typedef {import('@appium/types').StringRecord} StringRecord\n * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template [J=any]\n * @typedef ParsedDriverCaps\n * @property {Capabilities<C>} desiredCaps\n * @property {string} protocol\n * @property {J} [processedJsonwpCapabilities]\n * @property {W3CCapabilities<C>} [processedW3CCapabilities]\n */\n\n/**\n * @todo protocol is more specific\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template [J=any]\n * @typedef InvalidCaps\n * @property {Error} error\n * @property {string} protocol\n * @property {Capabilities<C>} [desiredCaps]\n * @property {J} [processedJsonwpCapabilities]\n * @property {W3CCapabilities<C>} [processedW3CCapabilities]\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').W3CCapabilities<C, Extra>} W3CCapabilities\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef {import('@appium/types').NSCapabilities<C, Extra>} NSCapabilities\n */\n\n/**\n * @template {Constraints} C\n * @typedef {import('@appium/types').ConstraintsToCaps<C>} ConstraintsToCaps\n */\n\n/**\n * @template T\n * @typedef {import('type-fest').StringKeyOf<T>} StringKeyOf\n */\n\n/**\n * @typedef {import('@appium/types').Constraints} Constraints\n */\n"],"mappings":";;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;AAEA,MAAMA,iBAAiB,GAAG,QAA1B;AACA,MAAMC,uBAAuB,GAAG,IAAIC,GAAJ,CAAQ,CAAC,GAAGC,yBAAJ,EAAmBC,GAAnB,CAAwBC,GAAD,IAASA,GAAG,CAACC,WAAJ,EAAhC,CAAR,CAAhC;AASA,MAAMC,WAAW,GAAGC,OAAO,CAACC,MAAR,CAAeC,KAAnC;;AAOA,MAAMC,OAAO,GAAGC,eAAA,CAAEC,IAAF,CACdD,eAAA,CAAEE,YAAF,CACkFC,aADlF,EAEE;EAACC,MAAM,EAAE,IAAT;EAAeC,KAAK,EAAE,IAAtB;EAA4BC,OAAO,EAAE,CAACX;AAAtC,CAFF,CADc,EAKd,CAAC,GAAGY,IAAJ,KAAa;EACXC,eAAA,CAAOC,IAAP,CAAY,GAAGF,IAAf;AACD,CAPa,CAAhB;;;;AAsBA,SAASG,uBAAT,CACEC,kBADF,EAEEC,eAFF,EAGEC,WAAW,GAAqB,EAHlC,EAIEC,mBAAmB,GAAG,EAJxB,EAKE;EAEA,MAAMC,UAAU,GACdf,eAAA,CAAEgB,aAAF,CAAgBJ,eAAhB,MACCZ,eAAA,CAAEiB,GAAF,CAAML,eAAN,EAAuB,aAAvB,KAAyCZ,eAAA,CAAEiB,GAAF,CAAML,eAAN,EAAuB,YAAvB,CAD1C,CADF;;EAGA,MAAMM,aAAa,GAAGlB,eAAA,CAAEgB,aAAF,CAAgBL,kBAAhB,CAAtB;;EACA,IAAIQ,WAAW,GAAsD,EAArE;EAEA,IAAIC,wBAAJ;EAEA,IAAIC,2BAAJ;;EAEA,IAAI,CAACN,UAAL,EAAiB;IACf,OAAsC;MACpCO,QAAQ,EAAEC,qBAAA,CAAUC,GADgB;MAEpCC,KAAK,EAAE,IAAIC,KAAJ,CAAU,qCAAV;IAF6B,CAAtC;EAID;;EAED,MAAM;IAACF;EAAD,IAAQD,qBAAd;EACA,MAAMD,QAAQ,GAAGE,GAAjB;EAGAb,kBAAkB,GAAGX,eAAA,CAAE2B,SAAF,CAAYhB,kBAAZ,CAArB;EACAC,eAAe,GAAGZ,eAAA,CAAE2B,SAAF,CAAYf,eAAZ,CAAlB;EACAE,mBAAmB,GAAGd,eAAA,CAAE2B,SAAF,CAAYb,mBAAZ,CAAtB;;EAEA,IAAI,CAACd,eAAA,CAAE4B,OAAF,CAAUd,mBAAV,CAAL,EAAqC;IACnC,IAAIC,UAAJ,EAAgB;MACd,KAAK,MAAM,CAACc,aAAD,EAAgBC,eAAhB,CAAX,IAA+C9B,eAAA,CAAE+B,OAAF,CAAUjB,mBAAV,CAA/C,EAA+E;QAC7E,IAAIkB,eAAe,GAAG,KAAtB;;QAEA,KAAK,MAAMC,eAAX,IAA8BrB,eAAe,CAACsB,UAAhB,IAA8B,EAA5D,EAAgE;UAC9D,IACElC,eAAA,CAAEgB,aAAF,CAAgBiB,eAAhB,KACAjC,eAAA,CAAEiB,GAAF,CAAMkB,oBAAoB,CAACF,eAAD,CAA1B,EAA6CG,kBAAkB,CAACP,aAAD,CAA/D,CAFF,EAGE;YACAG,eAAe,GAAG,IAAlB;YACA;UACD;QACF;;QAEDA,eAAe,GACbA,eAAe,IACdhC,eAAA,CAAEgB,aAAF,CAAgBJ,eAAe,CAACyB,WAAhC,KACCrC,eAAA,CAAEiB,GAAF,CACEkB,oBAAoB,CAACvB,eAAe,CAACyB,WAAjB,CADtB,EAEED,kBAAkB,CAACP,aAAD,CAFpB,CAHJ;;QAOA,IAAIG,eAAJ,EAAqB;UAEnB;QACD;;QAGD,IAAIhC,eAAA,CAAE4B,OAAF,CAAUhB,eAAe,CAACsB,UAA1B,CAAJ,EAA2C;UACzCtB,eAAe,CAACsB,UAAhB,GAA8E,CAC5E;YAAC,CAACL,aAAD,GAAiBC;UAAlB,CAD4E,CAA9E;QAGD,CAJD,MAIO;UACLlB,eAAe,CAACsB,UAAhB,CAA2B,CAA3B,EAA8BL,aAA9B,IAA+CC,eAA/C;QACD;MACF;IACF;;IACD,IAAIZ,aAAJ,EAAmB;MACjBP,kBAAkB,GAAG,EACnB,GAAGwB,oBAAoB,CAACrB,mBAAD,CADJ;QAEnB,GAAGH;MAFgB,CAArB;IAID;EACF;;EAGD,IAAIO,aAAJ,EAAmB;IACjBG,2BAA2B,GAAG,EAAC,GAAGV;IAAJ,CAA9B;EACD;;EAGD,IAAII,UAAJ,EAAgB;IAGd,IAAI;MACFI,WAAW,GAAG,IAAAmB,+BAAA,EAAoB1B,eAApB,EAAqCC,WAArC,EAAkD,IAAlD,CAAd;IACD,CAFD,CAEE,OAAOY,KAAP,EAAc;MACdjB,eAAA,CAAOC,IAAP,CAAa,qCAAoCgB,KAAK,CAACc,OAAQ,EAA/D;;MACA,OAAwC;QACtCpB,WADsC;QAEtCE,2BAFsC;QAGtCD,wBAHsC;QAItCE,QAJsC;QAKtCG;MALsC,CAAxC;IAOD;;IAGDL,wBAAwB,GAAG;MACzBiB,WAAW,EAAE,EAAC,GAAGG,oBAAoB,CAACrB,WAAD;MAAxB,CADY;MAEzBe,UAAU,EAAE,CAAC,EAAD;IAFa,CAA3B;EAID;;EAED,OAA6C;IAC3Cf,WAD2C;IAE3CE,2BAF2C;IAG3CD,wBAH2C;IAI3CE;EAJ2C,CAA7C;AAMD;;AAQD,SAASkB,oBAAT,CAA8BC,IAA9B,EAAoC;EAClC,OACEzC,eAAA,CAAE0C,OAAF,CAAUD,IAAV,EAAgB,CAACzC,CAAD,EAAI2C,GAAJ,KACdtD,uBAAuB,CAAC4B,GAAxB,CAA4B0B,GAAG,CAACjD,WAAJ,EAA5B,KAAkDiD,GAAG,CAACC,QAAJ,CAAa,GAAb,CAAlD,GACID,GADJ,GAEK,GAAEvD,iBAAkB,IAAGuD,GAAI,EAHlC,CADF;AAOD;;AAOD,SAASR,oBAAT,CAA8BM,IAA9B,EAAoC;EAClC,OAAuCzC,eAAA,CAAE0C,OAAF,CAAUD,IAAV,EAAgB,CAACzC,CAAD,EAAI2C,GAAJ,KAAYP,kBAAkB,CAACO,GAAD,CAA9C,CAAvC;AACD;;AAMD,SAASP,kBAAT,CAA4BO,GAA5B,EAAiC;EAC/B,MAAME,MAAM,GAAI,GAAEzD,iBAAkB,GAApC;EACA,OAAOY,eAAA,CAAE8C,UAAF,CAAaH,GAAb,EAAkBE,MAAlB,IAA4BF,GAAG,CAACI,SAAJ,CAAcF,MAAM,CAACG,MAArB,CAA5B,GAA2DL,GAAlE;AACD;;AAOD,SAASM,iBAAT,CAA2BC,OAA3B,EAAoC;EAClC,MAAMC,OAAO,GAAGC,OAAO,CAAE,GAAEF,OAAQ,eAAZ,CAAP,IAAsC,EAAtD;EACA,OAAOC,OAAO,CAACE,OAAf;AACD;;AASD,SAASC,cAAT,GAA0B;EACxB,MAAMC,QAAQ,GAAGC,aAAA,CAAKC,iBAAL,CAAuB,QAAvB,EAAiCC,UAAjC,CAAjB;;EACA,IAAI,CAACH,QAAD,IAAaI,aAAA,CAAKC,OAAL,CAAaL,QAAb,EAAuBP,MAAvB,IAAiCO,QAAQ,CAACP,MAA3D,EAAmE;IACjE;EACD;;EACD,MAAMa,eAAe,GAAGF,aAAA,CAAKC,OAAL,CAAaL,QAAb,CAAxB;;EAEA,MAAMO,mBAAmB,GAAG,MAAM;IAChC,IAAI;MAMFV,OAAO,CAAC,QAAD,CAAP,CAAkBW,MAAlB,CAAyBC,UAAzB;;MACA,OAAO,IAAP;IACD,CARD,CAQE,OAAOC,CAAP,EAAU;MACV,OAAO,KAAP;IACD;EACF,CAZD;;EAcA,IAAI,CAACrE,OAAO,CAACsE,GAAR,CAAYC,SAAjB,EAA4B;IAC1BvE,OAAO,CAACsE,GAAR,CAAYC,SAAZ,GAAwBN,eAAxB;;IACA,IAAIC,mBAAmB,EAAvB,EAA2B;MACzBlE,OAAO,CAACsE,GAAR,CAAYE,qBAAZ,GAAoC,GAApC;IACD,CAFD,MAEO;MACL,OAAOxE,OAAO,CAACsE,GAAR,CAAYC,SAAnB;IACD;;IACD;EACD;;EAED,MAAME,aAAa,GAAGzE,OAAO,CAACsE,GAAR,CAAYC,SAAZ,CAAsBG,KAAtB,CAA4BX,aAAA,CAAKY,SAAjC,CAAtB;;EACA,IAAIF,aAAa,CAACzB,QAAd,CAAuBiB,eAAvB,CAAJ,EAA6C;IAC3CjE,OAAO,CAACsE,GAAR,CAAYE,qBAAZ,GAAoC,GAApC;IACA;EACD;;EAEDC,aAAa,CAACG,IAAd,CAAmBX,eAAnB;EACAjE,OAAO,CAACsE,GAAR,CAAYC,SAAZ,GAAwBE,aAAa,CAACI,IAAd,CAAmBd,aAAA,CAAKY,SAAxB,CAAxB;;EACA,IAAIT,mBAAmB,EAAvB,EAA2B;IACzBlE,OAAO,CAACsE,GAAR,CAAYE,qBAAZ,GAAoC,GAApC;EACD,CAFD,MAEO;IACLxE,OAAO,CAACsE,GAAR,CAAYC,SAAZ,GAAwBnE,eAAA,CAAE0E,OAAF,CAAUL,aAAV,EAAyBR,eAAzB,EAA0CY,IAA1C,CAA+Cd,aAAA,CAAKY,SAApD,CAAxB;EACD;AACF;;AAkBD,SAASI,YAAT,CAAsBlC,IAAtB,EAA4B;EAC1B,IAAI,CAACzC,eAAA,CAAEgB,aAAF,CAAgByB,IAAhB,CAAD,IAA0BzC,eAAA,CAAE4B,OAAF,CAAUa,IAAV,CAA9B,EAA+C;IAC7C,OAAO,EAAP;EACD;;EAED,MAAMmC,MAAM,GAAG,EAAf;;EACA,KAAK,MAAM,CAACjC,GAAD,EAAMkC,KAAN,CAAX,IAA2B7E,eAAA,CAAE+B,OAAF,CAAUU,IAAV,CAA3B,EAA4C;IAC1C,MAAMqC,KAAK,GAAG,uBAAuBC,IAAvB,CAA4BpC,GAA5B,CAAd;;IACA,IAAI,CAACmC,KAAL,EAAY;MACV;IACD;;IAEDF,MAAM,CAACE,KAAK,CAAC,CAAD,CAAN,CAAN,GAAmBD,KAAnB;IACA,OAAOpC,IAAI,CAACE,GAAD,CAAX;EACD;;EACD,OAAOiC,MAAP;AACD"}
+exports.isPluginCommandArgs = isPluginCommandArgs;
+/**
+ * @typedef {import('@appium/types').StringRecord} StringRecord
+ * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints
+ */
+/**
+ * @template {Constraints} [C=BaseDriverCapConstraints]
+ * @template [J=any]
+ * @typedef ParsedDriverCaps
+ * @property {Capabilities<C>} desiredCaps
+ * @property {string} protocol
+ * @property {J} [processedJsonwpCapabilities]
+ * @property {W3CCapabilities<C>} [processedW3CCapabilities]
+ */
+/**
+ * @todo protocol is more specific
+ * @template {Constraints} [C=BaseDriverCapConstraints]
+ * @template [J=any]
+ * @typedef InvalidCaps
+ * @property {Error} error
+ * @property {string} protocol
+ * @property {Capabilities<C>} [desiredCaps]
+ * @property {J} [processedJsonwpCapabilities]
+ * @property {W3CCapabilities<C>} [processedW3CCapabilities]
+ */
+/**
+ * @template {Constraints} [C=BaseDriverCapConstraints]
+ * @template {StringRecord|void} [Extra=void]
+ * @typedef {import('@appium/types').Capabilities<C, Extra>} Capabilities
+ */
+/**
+ * @template {Constraints} [C=BaseDriverCapConstraints]
+ * @template {StringRecord|void} [Extra=void]
+ * @typedef {import('@appium/types').W3CCapabilities<C, Extra>} W3CCapabilities
+ */
+/**
+ * @template {Constraints} [C=BaseDriverCapConstraints]
+ * @template {StringRecord|void} [Extra=void]
+ * @typedef {import('@appium/types').NSCapabilities<C, Extra>} NSCapabilities
+ */
+/**
+ * @template {Constraints} C
+ * @typedef {import('@appium/types').ConstraintsToCaps<C>} ConstraintsToCaps
+ */
+/**
+ * @template T
+ * @typedef {import('type-fest').StringKeyOf<T>} StringKeyOf
+ */
+/**
+ * @typedef {import('@appium/types').Constraints} Constraints
+ */
+/**
+ * @typedef {import('appium/types').CliCommand} CliCommand
+ * @typedef {import('appium/types').CliExtensionSubcommand} CliExtensionSubcommand
+ * @typedef {import('appium/types').CliExtensionCommand} CliExtensionCommand
+ * @typedef {import('appium/types').ServerCommand} ServerCommand
+ * @typedef {import('appium/types').DriverCommand} DriverCommand
+ * @typedef {import('appium/types').PluginCommand} PluginCommand
+ */
+/**
+ * @template {CliCommand} [Cmd=ServerCommand]
+ * @template {CliExtensionSubcommand|void} [SubCmd=void]
+ * @typedef {import('appium/types').Args<Cmd, SubCmd>} Args
+ */
+/**
+ * @template {CliCommand} [Cmd=ServerCommand]
+ * @template {CliExtensionSubcommand|void} [SubCmd=void]
+ * @typedef {import('appium/types').ParsedArgs<Cmd, SubCmd>} ParsedArgs
+ */
+//# sourceMappingURL=utils.js.map