@appium/base-driver 8.2.4 → 8.4.0

package/build/lib/basedriver/helpers.d.ts

@@ -0,0 +1,132 @@
+declare var _default: import('@appium/types').DriverHelpers;
+export default _default;
+export type PostProcessOptions = {
+    /**
+     * The information about the previously cached app instance (if exists):
+     * - packageHash: SHA1 hash of the package if it is a file and not a folder
+     * - lastModified: Optional Date instance, the value of file's `Last-Modified` header
+     * - immutable: Optional boolean value. Contains true if the file has an `immutable` mark
+     * in `Cache-control` header
+     * - maxAge: Optional integer representation of `maxAge` parameter in `Cache-control` header
+     * - timestamp: The timestamp this item has been added to the cache (measured in Unix epoch
+     * milliseconds)
+     * - integrity: An object containing either `file` property with SHA1 hash of the file
+     * or `folder` property with total amount of cached files and subfolders
+     * - fullPath: the full path to the cached app
+     */
+    cachedAppInfo: any | null;
+    /**
+     * Whether the app has been downloaded from a remote URL
+     */
+    isUrl: boolean;
+    /**
+     * Optional headers object. Only present if `isUrl` is true and if the server
+     * responds to HEAD requests. All header names are normalized to lowercase.
+     */
+    headers: any | null;
+    /**
+     * A string containing full path to the preprocessed application package (either
+     * downloaded or a local one)
+     */
+    appPath: string;
+};
+export type PostProcessResult = {
+    /**
+     * The full past to the post-processed application package on the
+     * local file system (might be a file or a folder path)
+     */
+    appPath: string;
+};
+export type ConfigureAppOptions = {
+    /**
+     * Optional function, which should be applied
+     * to the application after it is downloaded/preprocessed. This function may be async
+     * and is expected to accept single object parameter.
+     * The function is expected to either return a falsy value, which means the app must not be
+     * cached and a fresh copy of it is downloaded each time. If this function returns an object
+     * containing `appPath` property then the integrity of it will be verified and stored into
+     * the cache.
+     */
+    onPostProcess: (obj: PostProcessOptions) => (Promise<PostProcessResult | undefined> | PostProcessResult | undefined);
+    /**
+     * List of supported application extensions (
+     * including starting dots). This property is mandatory and must not be empty.
+     */
+    supportedExtensions: string[];
+};
+/**
+ * @typedef PostProcessOptions
+ * @property {?Object} cachedAppInfo The information about the previously cached app instance (if exists):
+ *    - packageHash: SHA1 hash of the package if it is a file and not a folder
+ *    - lastModified: Optional Date instance, the value of file's `Last-Modified` header
+ *    - immutable: Optional boolean value. Contains true if the file has an `immutable` mark
+ *                 in `Cache-control` header
+ *    - maxAge: Optional integer representation of `maxAge` parameter in `Cache-control` header
+ *    - timestamp: The timestamp this item has been added to the cache (measured in Unix epoch
+ *                 milliseconds)
+ *    - integrity: An object containing either `file` property with SHA1 hash of the file
+ *                 or `folder` property with total amount of cached files and subfolders
+ *    - fullPath: the full path to the cached app
+ * @property {boolean} isUrl Whether the app has been downloaded from a remote URL
+ * @property {?Object} headers Optional headers object. Only present if `isUrl` is true and if the server
+ * responds to HEAD requests. All header names are normalized to lowercase.
+ * @property {string} appPath A string containing full path to the preprocessed application package (either
+ * downloaded or a local one)
+ */
+/**
+ * @typedef PostProcessResult
+ * @property {string} appPath The full past to the post-processed application package on the
+ * local file system (might be a file or a folder path)
+ */
+/**
+ * @typedef ConfigureAppOptions
+ * @property {(obj: PostProcessOptions) => (Promise<PostProcessResult|undefined>|PostProcessResult|undefined)} onPostProcess
+ * Optional function, which should be applied
+ * to the application after it is downloaded/preprocessed. This function may be async
+ * and is expected to accept single object parameter.
+ * The function is expected to either return a falsy value, which means the app must not be
+ * cached and a fresh copy of it is downloaded each time. If this function returns an object
+ * containing `appPath` property then the integrity of it will be verified and stored into
+ * the cache.
+ * @property {string[]} supportedExtensions List of supported application extensions (
+ * including starting dots). This property is mandatory and must not be empty.
+ */
+/**
+ * Prepares an app to be used in an automated test. The app gets cached automatically
+ * if it is an archive or if it is downloaded from an URL.
+ * If the downloaded app has `.zip` extension, this method will unzip it.
+ * The unzip does not work when `onPostProcess` is provided.
+ *
+ * @param {string} app Either a full path to the app or a remote URL
+ * @param {string|string[]|ConfigureAppOptions} options
+ * @returns The full path to the resulting application bundle
+ */
+export function configureApp(app: string, options?: string | string[] | ConfigureAppOptions): Promise<any>;
+export function isPackageOrBundle(app: any): boolean;
+/**
+ * Finds all instances 'firstKey' and create a duplicate with the key 'secondKey',
+ * Do the same thing in reverse. If we find 'secondKey', create a duplicate with the key 'firstKey'.
+ *
+ * This will cause keys to be overwritten if the object contains 'firstKey' and 'secondKey'.
+
+ * @param {*} input Any type of input
+ * @param {String} firstKey The first key to duplicate
+ * @param {String} secondKey The second key to duplicate
+ */
+export function duplicateKeys(input: any, firstKey: string, secondKey: string): any;
+/**
+ * Takes a desired capability and tries to JSON.parse it as an array,
+ * and either returns the parsed array or a singleton array.
+ *
+ * @param {string|Array<String>} cap A desired capability
+ */
+export function parseCapsArray(cap: string | Array<string>): any[];
+/**
+ * Generate a string that uniquely describes driver instance
+ *
+ * @param {import('@appium/types').Core} obj driver instance
+ * @param {string?} sessionId session identifier (if exists)
+ * @returns {string}
+ */
+export function generateDriverLogPrefix(obj: import('@appium/types').Core, sessionId?: string | null): string;
+//# sourceMappingURL=helpers.d.ts.map

package/build/lib/basedriver/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/helpers.js"],"names":[],"mappings":"sBAgjBW,OAAO,eAAe,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;WA3YlC,OAAO;;;;;;;;;;aAGP,MAAM;;;;;;;aAMN,MAAM;;;;;;;;;;;;yBAMA,kBAAkB,KAAK,CAAC,QAAQ,iBAAiB,GAAC,SAAS,CAAC,GAAC,iBAAiB,GAAC,SAAS,CAAC;;;;;yBAQ/F,MAAM,EAAE;;AApCtB;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;GASG;AACH,kCAJW,MAAM,YACN,MAAM,GAAC,MAAM,EAAE,GAAC,mBAAmB,gBA8M7C;AA8ED,qDAEC;AAED;;;;;;;;;GASG;AACH,oFAuBC;AAED;;;;;GAKG;AACH,oCAFW,MAAM,GAAC,aAAa,SAoB9B;AAED;;;;;;GAMG;AACH,6CAJW,OAAO,eAAe,EAAE,IAAI,cAC5B,MAAM,UACJ,MAAM,CAKlB"}

package/build/lib/basedriver/helpers.js

@@ -6,7 +6,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.configureApp = configureApp;
+exports.default = void 0;
 exports.duplicateKeys = duplicateKeys;
+exports.generateDriverLogPrefix = generateDriverLogPrefix;
 exports.isPackageOrBundle = isPackageOrBundle;
 exports.parseCapsArray = parseCapsArray;
 
@@ -32,19 +34,19 @@ const IPA_EXT = '.ipa';
 const ZIP_EXTS = ['.zip', IPA_EXT];
 const ZIP_MIME_TYPES = ['application/zip', 'application/x-zip-compressed', 'multipart/x-zip'];
 const CACHED_APPS_MAX_AGE = 1000 * 60 * 60 * 24;
+const MAX_CACHED_APPS = 1024;
 const APPLICATIONS_CACHE = new _lruCache.default({
-  maxAge: CACHED_APPS_MAX_AGE,
+  max: MAX_CACHED_APPS,
+  ttl: CACHED_APPS_MAX_AGE,
   updateAgeOnGet: true,
   dispose: (app, {
     fullPath
   }) => {
     _logger.default.info(`The application '${app}' cached at '${fullPath}' has ` + `expired after ${CACHED_APPS_MAX_AGE}ms`);
 
-    setTimeout(async () => {
-      if (fullPath) {
-        await _support.fs.rimraf(fullPath);
-      }
-    });
+    if (fullPath) {
+      _support.fs.rimraf(fullPath);
+    }
   },
   noDisposeOnSet: true
 });
@@ -53,11 +55,11 @@ const SANITIZE_REPLACEMENT = '-';
 const DEFAULT_BASENAME = 'appium-app';
 const APP_DOWNLOAD_TIMEOUT_MS = 120 * 1000;
 process.on('exit', () => {
-  if (APPLICATIONS_CACHE.itemCount === 0) {
+  if (APPLICATIONS_CACHE.size === 0) {
     return;
   }
 
-  const appPaths = APPLICATIONS_CACHE.values().map(({
+  const appPaths = [...APPLICATIONS_CACHE.values()].map(({
     fullPath
   }) => fullPath);
 
@@ -528,7 +530,19 @@ function parseCapsArray(cap) {
   }
 
   throw new Error(`must provide a string or JSON Array; received ${cap}`);
-}require('source-map-support').install();
+}
 
+function generateDriverLogPrefix(obj, sessionId = null) {
+  const instanceName = `${obj.constructor.name}@${_support.node.getObjectId(obj).substring(0, 4)}`;
+  return sessionId ? `${instanceName} (${sessionId.substring(0, 8)})` : instanceName;
+}
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/basedriver/helpers.js"],"names":["IPA_EXT","ZIP_EXTS","ZIP_MIME_TYPES","CACHED_APPS_MAX_AGE","APPLICATIONS_CACHE","LRU","maxAge","updateAgeOnGet","dispose","app","fullPath","logger","info","setTimeout","fs","rimraf","noDisposeOnSet","APPLICATIONS_CACHE_GUARD","AsyncLock","SANITIZE_REPLACEMENT","DEFAULT_BASENAME","APP_DOWNLOAD_TIMEOUT_MS","process","on","itemCount","appPaths","values","map","debug","length","util","pluralize","appPath","rimrafSync","e","warn","message","retrieveHeaders","link","url","method","timeout","headers","getCachedApplicationPath","currentAppProps","cachedAppInfo","refresh","_","isPlainObject","lastModified","currentModified","immutable","currentImmutable","currentMaxAge","timestamp","getTime","msLeft","Date","now","path","basename","verifyAppExtension","supportedAppExtensions","toLower","includes","extname","Error","calculateFolderIntegrity","folderPath","glob","cwd","strict","nosort","calculateFileIntegrity","filePath","hash","isAppIntegrityOk","currentPath","expectedIntegrity","exists","stat","isDirectory","folder","file","configureApp","options","isString","onPostProcess","isArray","supportedExtensions","isEmpty","newApp","shouldUnzipApp","packageHash","remoteAppProps","protocol","pathname","parse","isUrl","get","acquire","test","maxAgeMatch","exec","parseInt","cachedPath","integrity","del","fileName","sanitizeName","decodeURIComponent","replacement","ct","some","mimeType","RegExp","escapeRegExp","match","resultingName","substring","resultingExt","first","targetPath","tempDir","prefix","suffix","downloadApp","errorMessage","isPackageAFile","isFile","isFunction","archivePath","tmpRoot","openDir","unzipApp","isAbsolute","resolve","storeAppInCache","appPathToCache","cachedFullPath","set","result","clone","Boolean","href","net","downloadFile","err","zipPath","dstRoot","zip","assertValidZip","timer","timing","Timer","start","useSystemUnzipEnv","env","APPIUM_PREFER_SYSTEM_UNZIP","useSystemUnzip","extractionOpts","fileNamesEncoding","extractAllTo","globPattern","ext","replace","join","sortedBundleItems","sort","a","b","split","sep","errorAndThrow","Math","round","getDuration","asMilliSeconds","matchedBundle","dstPath","mv","mkdirp","isPackageOrBundle","duplicateKeys","input","firstKey","secondKey","item","resultObj","key","value","toPairs","recursivelyCalledValue","parseCapsArray","cap","parsedCaps","JSON","ign"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport path from 'path';\nimport url from 'url';\nimport logger from './logger';\nimport { tempDir, fs, util, zip, net, timing } from '@appium/support';\nimport LRU from 'lru-cache';\nimport AsyncLock from 'async-lock';\nimport axios from 'axios';\n\nconst IPA_EXT = '.ipa';\nconst ZIP_EXTS = ['.zip', IPA_EXT];\nconst ZIP_MIME_TYPES = [\n  'application/zip',\n  'application/x-zip-compressed',\n  'multipart/x-zip',\n];\nconst CACHED_APPS_MAX_AGE = 1000 * 60 * 60 * 24; // ms\nconst APPLICATIONS_CACHE = new LRU({\n  maxAge: CACHED_APPS_MAX_AGE, // expire after 24 hours\n  updateAgeOnGet: true,\n  dispose: (app, {fullPath}) => {\n    logger.info(`The application '${app}' cached at '${fullPath}' has ` +\n      `expired after ${CACHED_APPS_MAX_AGE}ms`);\n    setTimeout(async () => {\n      if (fullPath) {\n        await fs.rimraf(fullPath);\n      }\n    });\n  },\n  noDisposeOnSet: true,\n});\nconst APPLICATIONS_CACHE_GUARD = new AsyncLock();\nconst SANITIZE_REPLACEMENT = '-';\nconst DEFAULT_BASENAME = 'appium-app';\nconst APP_DOWNLOAD_TIMEOUT_MS = 120 * 1000;\n\nprocess.on('exit', () => {\n  if (APPLICATIONS_CACHE.itemCount === 0) {\n    return;\n  }\n\n  const appPaths = APPLICATIONS_CACHE.values()\n    .map(({fullPath}) => fullPath);\n  logger.debug(`Performing cleanup of ${appPaths.length} cached ` +\n    util.pluralize('application', appPaths.length));\n  for (const appPath of appPaths) {\n    try {\n      // Asynchronous calls are not supported in onExit handler\n      fs.rimrafSync(appPath);\n    } catch (e) {\n      logger.warn(e.message);\n    }\n  }\n});\n\n\nasync function retrieveHeaders (link) {\n  try {\n    return (await axios({\n      url: link,\n      method: 'HEAD',\n      timeout: 5000,\n    })).headers;\n  } catch (e) {\n    logger.info(`Cannot send HEAD request to '${link}'. Original error: ${e.message}`);\n  }\n  return {};\n}\n\nfunction getCachedApplicationPath (link, currentAppProps = {}, cachedAppInfo = {}) {\n  const refresh = () => {\n    logger.debug(`A fresh copy of the application is going to be downloaded from ${link}`);\n    return null;\n  };\n\n  if (!_.isPlainObject(cachedAppInfo) || !_.isPlainObject(currentAppProps)) {\n    // if an invalid arg is passed then assume cache miss\n    return refresh();\n  }\n\n  const {\n    lastModified: currentModified,\n    immutable: currentImmutable,\n    // maxAge is in seconds\n    maxAge: currentMaxAge,\n  } = currentAppProps;\n  const {\n    // Date instance\n    lastModified,\n    // boolean\n    immutable,\n    // Unix time in milliseconds\n    timestamp,\n    fullPath,\n  } = cachedAppInfo;\n  if (lastModified && currentModified) {\n    if (currentModified.getTime() <= lastModified.getTime()) {\n      logger.debug(`The application at ${link} has not been modified since ${lastModified}`);\n      return fullPath;\n    }\n    logger.debug(`The application at ${link} has been modified since ${lastModified}`);\n    return refresh();\n  }\n  if (immutable && currentImmutable) {\n    logger.debug(`The application at ${link} is immutable`);\n    return fullPath;\n  }\n  if (currentMaxAge && timestamp) {\n    const msLeft = timestamp + currentMaxAge * 1000 - Date.now();\n    if (msLeft > 0) {\n      logger.debug(`The cached application '${path.basename(fullPath)}' will expire in ${msLeft / 1000}s`);\n      return fullPath;\n    }\n    logger.debug(`The cached application '${path.basename(fullPath)}' has expired`);\n  }\n  return refresh();\n}\n\nfunction verifyAppExtension (app, supportedAppExtensions) {\n  if (supportedAppExtensions.map(_.toLower).includes(_.toLower(path.extname(app)))) {\n    return app;\n  }\n  throw new Error(`New app path '${app}' did not have ` +\n    `${util.pluralize('extension', supportedAppExtensions.length, false)}: ` +\n    supportedAppExtensions);\n}\n\nasync function calculateFolderIntegrity (folderPath) {\n  return (await fs.glob('**/*', {cwd: folderPath, strict: false, nosort: true})).length;\n}\n\nasync function calculateFileIntegrity (filePath) {\n  return await fs.hash(filePath);\n}\n\nasync function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {\n  if (!await fs.exists(currentPath)) {\n    return false;\n  }\n\n  // Folder integrity check is simple:\n  // Verify the previous amount of files is not greater than the current one.\n  // We don't want to use equality comparison because of an assumption that the OS might\n  // create some unwanted service files/cached inside of that folder or its subfolders.\n  // Ofc, validating the hash sum of each file (or at least of file path) would be much\n  // more precise, but we don't need to be very precise here and also don't want to\n  // overuse RAM and have a performance drop.\n  return (await fs.stat(currentPath)).isDirectory()\n    ? await calculateFolderIntegrity(currentPath) >= expectedIntegrity?.folder\n    : await calculateFileIntegrity(currentPath) === expectedIntegrity?.file;\n}\n\n/**\n * @typedef {Object} PostProcessOptions\n * @property {?Object} cachedAppInfo The information about the previously cached app instance (if exists):\n *    - packageHash: SHA1 hash of the package if it is a file and not a folder\n *    - lastModified: Optional Date instance, the value of file's `Last-Modified` header\n *    - immutable: Optional boolean value. Contains true if the file has an `immutable` mark\n *                 in `Cache-control` header\n *    - maxAge: Optional integer representation of `maxAge` parameter in `Cache-control` header\n *    - timestamp: The timestamp this item has been added to the cache (measured in Unix epoch\n *                 milliseconds)\n *    - integrity: An object containing either `file` property with SHA1 hash of the file\n *                 or `folder` property with total amount of cached files and subfolders\n *    - fullPath: the full path to the cached app\n * @property {boolean} isUrl Whether the app has been downloaded from a remote URL\n * @property {?Object} headers Optional headers object. Only present if `isUrl` is true and if the server\n * responds to HEAD requests. All header names are normalized to lowercase.\n * @property {string} appPath A string containing full path to the preprocessed application package (either\n * downloaded or a local one)\n */\n\n/**\n * @typedef {Object} PostProcessResult\n * @property {string} appPath The full past to the post-processed application package on the\n * local file system (might be a file or a folder path)\n */\n\n/**\n * @typedef {Object} ConfigureAppOptions\n * @property {(obj: PostProcessOptions) => (Promise<PostProcessResult|undefined>|PostProcessResult|undefined)} onPostProcess\n * Optional function, which should be applied\n * to the application after it is downloaded/preprocessed. This function may be async\n * and is expected to accept single object parameter.\n * The function is expected to either return a falsy value, which means the app must not be\n * cached and a fresh copy of it is downloaded each time. If this function returns an object\n * containing `appPath` property then the integrity of it will be verified and stored into\n * the cache.\n * @property {string[]} supportedExtensions List of supported application extensions (\n * including starting dots). This property is mandatory and must not be empty.\n */\n\n/**\n * Prepares an app to be used in an automated test. The app gets cached automatically\n * if it is an archive or if it is downloaded from an URL.\n *\n * @param {string} app Either a full path to the app or a remote URL\n * @param {string|string[]|ConfigureAppOptions} options\n * @returns The full path to the resulting application bundle\n */\nasync function configureApp (app, options = {}) {\n  if (!_.isString(app)) {\n    // immediately shortcircuit if not given an app\n    return;\n  }\n\n  let supportedAppExtensions;\n  const {\n    onPostProcess,\n  } = _.isPlainObject(options) ? options : {};\n  if (_.isString(options)) {\n    supportedAppExtensions = [options];\n  } else if (_.isArray(options)) {\n    supportedAppExtensions = options;\n  } else if (_.isPlainObject(options)) {\n    supportedAppExtensions = options.supportedExtensions;\n  }\n  if (_.isEmpty(supportedAppExtensions)) {\n    throw new Error(`One or more supported app extensions must be provided`);\n  }\n\n  let newApp = app;\n  let shouldUnzipApp = false;\n  let packageHash = null;\n  let headers = null;\n  const remoteAppProps = {\n    lastModified: null,\n    immutable: false,\n    maxAge: null,\n  };\n  const {protocol, pathname} = url.parse(newApp);\n  const isUrl = ['http:', 'https:'].includes(protocol);\n\n  const cachedAppInfo = APPLICATIONS_CACHE.get(app);\n\n  return await APPLICATIONS_CACHE_GUARD.acquire(app, async () => {\n    if (isUrl) {\n      // Use the app from remote URL\n      logger.info(`Using downloadable app '${newApp}'`);\n      headers = await retrieveHeaders(newApp);\n      if (!_.isEmpty(headers)) {\n        if (headers['last-modified']) {\n          remoteAppProps.lastModified = new Date(headers['last-modified']);\n        }\n        logger.debug(`Last-Modified: ${headers['last-modified']}`);\n        if (headers['cache-control']) {\n          remoteAppProps.immutable = /\\bimmutable\\b/i.test(headers['cache-control']);\n          const maxAgeMatch = /\\bmax-age=(\\d+)\\b/i.exec(headers['cache-control']);\n          if (maxAgeMatch) {\n            remoteAppProps.maxAge = parseInt(maxAgeMatch[1], 10);\n          }\n        }\n        logger.debug(`Cache-Control: ${headers['cache-control']}`);\n      }\n      const cachedPath = getCachedApplicationPath(app, remoteAppProps, cachedAppInfo);\n      if (cachedPath) {\n        if (await isAppIntegrityOk(cachedPath, cachedAppInfo?.integrity)) {\n          logger.info(`Reusing previously downloaded application at '${cachedPath}'`);\n          return verifyAppExtension(cachedPath, supportedAppExtensions);\n        }\n        logger.info(`The application at '${cachedPath}' does not exist anymore ` +\n          `or its integrity has been damaged. Deleting it from the internal cache`);\n        APPLICATIONS_CACHE.del(app);\n      }\n\n      let fileName = null;\n      const basename = fs.sanitizeName(path.basename(decodeURIComponent(pathname)), {\n        replacement: SANITIZE_REPLACEMENT\n      });\n      const extname = path.extname(basename);\n      // to determine if we need to unzip the app, we have a number of places\n      // to look: content type, content disposition, or the file extension\n      if (ZIP_EXTS.includes(extname)) {\n        fileName = basename;\n        shouldUnzipApp = true;\n      }\n      if (headers['content-type']) {\n        const ct = headers['content-type'];\n        logger.debug(`Content-Type: ${ct}`);\n        // the filetype may not be obvious for certain urls, so check the mime type too\n        if (ZIP_MIME_TYPES.some((mimeType) => new RegExp(`\\\\b${_.escapeRegExp(mimeType)}\\\\b`).test(ct))) {\n          if (!fileName) {\n            fileName = `${DEFAULT_BASENAME}.zip`;\n          }\n          shouldUnzipApp = true;\n        }\n      }\n      if (headers['content-disposition'] && /^attachment/i.test(headers['content-disposition'])) {\n        logger.debug(`Content-Disposition: ${headers['content-disposition']}`);\n        const match = /filename=\"([^\"]+)/i.exec(headers['content-disposition']);\n        if (match) {\n          fileName = fs.sanitizeName(match[1], {\n            replacement: SANITIZE_REPLACEMENT\n          });\n          shouldUnzipApp = shouldUnzipApp || ZIP_EXTS.includes(path.extname(fileName));\n        }\n      }\n      if (!fileName) {\n        // assign the default file name and the extension if none has been detected\n        const resultingName = basename\n          ? basename.substring(0, basename.length - extname.length)\n          : DEFAULT_BASENAME;\n        let resultingExt = extname;\n        if (!supportedAppExtensions.includes(resultingExt)) {\n          logger.info(`The current file extension '${resultingExt}' is not supported. ` +\n            `Defaulting to '${_.first(supportedAppExtensions)}'`);\n          resultingExt = _.first(supportedAppExtensions);\n        }\n        fileName = `${resultingName}${resultingExt}`;\n      }\n      const targetPath = await tempDir.path({\n        prefix: fileName,\n        suffix: '',\n      });\n      newApp = await downloadApp(newApp, targetPath);\n    } else if (await fs.exists(newApp)) {\n      // Use the local app\n      logger.info(`Using local app '${newApp}'`);\n      shouldUnzipApp = ZIP_EXTS.includes(path.extname(newApp));\n    } else {\n      let errorMessage = `The application at '${newApp}' does not exist or is not accessible`;\n      // protocol value for 'C:\\\\temp' is 'c:', so we check the length as well\n      if (_.isString(protocol) && protocol.length > 2) {\n        errorMessage = `The protocol '${protocol}' used in '${newApp}' is not supported. ` +\n          `Only http: and https: protocols are supported`;\n      }\n      throw new Error(errorMessage);\n    }\n\n    const isPackageAFile = (await fs.stat(newApp)).isFile();\n    if (isPackageAFile) {\n      packageHash = await calculateFileIntegrity(newApp);\n    }\n\n    if (isPackageAFile && shouldUnzipApp && !_.isFunction(onPostProcess)) {\n      const archivePath = newApp;\n      if (packageHash === cachedAppInfo?.packageHash) {\n        const {fullPath} = cachedAppInfo;\n        if (await isAppIntegrityOk(fullPath, cachedAppInfo?.integrity)) {\n          if (archivePath !== app) {\n            await fs.rimraf(archivePath);\n          }\n          logger.info(`Will reuse previously cached application at '${fullPath}'`);\n          return verifyAppExtension(fullPath, supportedAppExtensions);\n        }\n        logger.info(`The application at '${fullPath}' does not exist anymore ` +\n          `or its integrity has been damaged. Deleting it from the cache`);\n        APPLICATIONS_CACHE.del(app);\n      }\n      const tmpRoot = await tempDir.openDir();\n      try {\n        newApp = await unzipApp(archivePath, tmpRoot, supportedAppExtensions);\n      } finally {\n        if (newApp !== archivePath && archivePath !== app) {\n          await fs.rimraf(archivePath);\n        }\n      }\n      logger.info(`Unzipped local app to '${newApp}'`);\n    } else if (!path.isAbsolute(newApp)) {\n      newApp = path.resolve(process.cwd(), newApp);\n      logger.warn(`The current application path '${app}' is not absolute ` +\n        `and has been rewritten to '${newApp}'. Consider using absolute paths rather than relative`);\n      app = newApp;\n    }\n\n    const storeAppInCache = async (appPathToCache) => {\n      const cachedFullPath = cachedAppInfo?.fullPath;\n      if (cachedFullPath && cachedFullPath !== appPathToCache) {\n        await fs.rimraf(cachedFullPath);\n      }\n      const integrity = {};\n      if ((await fs.stat(appPathToCache)).isDirectory()) {\n        integrity.folder = await calculateFolderIntegrity(appPathToCache);\n      } else {\n        integrity.file = await calculateFileIntegrity(appPathToCache);\n      }\n      APPLICATIONS_CACHE.set(app, {\n        ...remoteAppProps,\n        timestamp: Date.now(),\n        packageHash,\n        integrity,\n        fullPath: appPathToCache,\n      });\n      return appPathToCache;\n    };\n\n    if (_.isFunction(onPostProcess)) {\n      const result = await onPostProcess({\n        cachedAppInfo: _.clone(cachedAppInfo),\n        isUrl,\n        headers: _.clone(headers),\n        appPath: newApp,\n      });\n      return (!result?.appPath || app === result?.appPath || !await fs.exists(result?.appPath))\n        ? newApp\n        : await storeAppInCache(result.appPath);\n    }\n\n    verifyAppExtension(newApp, supportedAppExtensions);\n    return (app !== newApp && (packageHash || _.values(remoteAppProps).some(Boolean)))\n      ? await storeAppInCache(newApp)\n      : newApp;\n  });\n}\n\nasync function downloadApp (app, targetPath) {\n  const {href} = url.parse(app);\n  try {\n    await net.downloadFile(href, targetPath, {\n      timeout: APP_DOWNLOAD_TIMEOUT_MS,\n    });\n  } catch (err) {\n    throw new Error(`Unable to download the app: ${err.message}`);\n  }\n  return targetPath;\n}\n\n/**\n * Extracts the bundle from an archive into the given folder\n *\n * @param {string} zipPath Full path to the archive containing the bundle\n * @param {string} dstRoot Full path to the folder where the extracted bundle\n * should be placed\n * @param {Array<string>|string} supportedAppExtensions The list of extensions\n * the target application bundle supports, for example ['.apk', '.apks'] for\n * Android packages\n * @returns {string} Full path to the bundle in the destination folder\n * @throws {Error} If the given archive is invalid or no application bundles\n * have been found inside\n */\nasync function unzipApp (zipPath, dstRoot, supportedAppExtensions) {\n  await zip.assertValidZip(zipPath);\n\n  if (!_.isArray(supportedAppExtensions)) {\n    supportedAppExtensions = [supportedAppExtensions];\n  }\n\n  const tmpRoot = await tempDir.openDir();\n  try {\n    logger.debug(`Unzipping '${zipPath}'`);\n    const timer = new timing.Timer().start();\n    const useSystemUnzipEnv = process.env.APPIUM_PREFER_SYSTEM_UNZIP;\n    const useSystemUnzip = _.isEmpty(useSystemUnzipEnv)\n      || !['0', 'false'].includes(_.toLower(useSystemUnzipEnv));\n    /**\n     * Attempt to use use the system `unzip` (e.g., `/usr/bin/unzip`) due\n     * to the significant performance improvement it provides over the native\n     * JS \"unzip\" implementation.\n     * @type {import('@appium/support/lib/zip').ExtractAllOptions}\n     */\n    const extractionOpts = {useSystemUnzip};\n    // https://github.com/appium/appium/issues/14100\n    if (path.extname(zipPath) === IPA_EXT) {\n      logger.debug(`Enforcing UTF-8 encoding on the extracted file names for '${path.basename(zipPath)}'`);\n      extractionOpts.fileNamesEncoding = 'utf8';\n    }\n    await zip.extractAllTo(zipPath, tmpRoot, extractionOpts);\n    const globPattern = `**/*.+(${supportedAppExtensions.map((ext) => ext.replace(/^\\./, '')).join('|')})`;\n    const sortedBundleItems = (await fs.glob(globPattern, {\n      cwd: tmpRoot,\n      strict: false,\n    // Get the top level match\n    })).sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);\n    if (_.isEmpty(sortedBundleItems)) {\n      logger.errorAndThrow(`App unzipped OK, but we could not find any '${supportedAppExtensions}' ` +\n        util.pluralize('bundle', supportedAppExtensions.length, false) +\n        ` in it. Make sure your archive contains at least one package having ` +\n        `'${supportedAppExtensions}' ${util.pluralize('extension', supportedAppExtensions.length, false)}`);\n    }\n    logger.debug(`Extracted ${util.pluralize('bundle item', sortedBundleItems.length, true)} ` +\n      `from '${zipPath}' in ${Math.round(timer.getDuration().asMilliSeconds)}ms: ${sortedBundleItems}`);\n    const matchedBundle = _.first(sortedBundleItems);\n    logger.info(`Assuming '${matchedBundle}' is the correct bundle`);\n    const dstPath = path.resolve(dstRoot, path.basename(matchedBundle));\n    await fs.mv(path.resolve(tmpRoot, matchedBundle), dstPath, {mkdirp: true});\n    return dstPath;\n  } finally {\n    await fs.rimraf(tmpRoot);\n  }\n}\n\nfunction isPackageOrBundle (app) {\n  return (/^([a-zA-Z0-9\\-_]+\\.[a-zA-Z0-9\\-_]+)+$/).test(app);\n}\n\n/**\n * Finds all instances 'firstKey' and create a duplicate with the key 'secondKey',\n * Do the same thing in reverse. If we find 'secondKey', create a duplicate with the key 'firstKey'.\n *\n * This will cause keys to be overwritten if the object contains 'firstKey' and 'secondKey'.\n\n * @param {*} input Any type of input\n * @param {String} firstKey The first key to duplicate\n * @param {String} secondKey The second key to duplicate\n */\nfunction duplicateKeys (input, firstKey, secondKey) {\n  // If array provided, recursively call on all elements\n  if (_.isArray(input)) {\n    return input.map((item) => duplicateKeys(item, firstKey, secondKey));\n  }\n\n  // If object, create duplicates for keys and then recursively call on values\n  if (_.isPlainObject(input)) {\n    const resultObj = {};\n    for (let [key, value] of _.toPairs(input)) {\n      const recursivelyCalledValue = duplicateKeys(value, firstKey, secondKey);\n      if (key === firstKey) {\n        resultObj[secondKey] = recursivelyCalledValue;\n      } else if (key === secondKey) {\n        resultObj[firstKey] = recursivelyCalledValue;\n      }\n      resultObj[key] = recursivelyCalledValue;\n    }\n    return resultObj;\n  }\n\n  // Base case. Return primitives without doing anything.\n  return input;\n}\n\n/**\n * Takes a desired capability and tries to JSON.parse it as an array,\n * and either returns the parsed array or a singleton array.\n *\n * @param {string|Array<String>} cap A desired capability\n */\nfunction parseCapsArray (cap) {\n  if (_.isArray(cap)) {\n    return cap;\n  }\n\n  let parsedCaps;\n  try {\n    parsedCaps = JSON.parse(cap);\n    if (_.isArray(parsedCaps)) {\n      return parsedCaps;\n    }\n  } catch (ign) {\n    logger.warn(`Failed to parse capability as JSON array`);\n  }\n  if (_.isString(cap)) {\n    return [cap];\n  }\n  throw new Error(`must provide a string or JSON Array; received ${cap}`);\n}\n\nexport {\n  configureApp, isPackageOrBundle, duplicateKeys, parseCapsArray\n};\n"],"file":"lib/basedriver/helpers.js","sourceRoot":"../../.."}
+var _default = {
+  configureApp,
+  isPackageOrBundle,
+  duplicateKeys,
+  parseCapsArray,
+  generateDriverLogPrefix
+};
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/basedriver/helpers.js"],"names":["IPA_EXT","ZIP_EXTS","ZIP_MIME_TYPES","CACHED_APPS_MAX_AGE","MAX_CACHED_APPS","APPLICATIONS_CACHE","LRU","max","ttl","updateAgeOnGet","dispose","app","fullPath","logger","info","fs","rimraf","noDisposeOnSet","APPLICATIONS_CACHE_GUARD","AsyncLock","SANITIZE_REPLACEMENT","DEFAULT_BASENAME","APP_DOWNLOAD_TIMEOUT_MS","process","on","size","appPaths","values","map","debug","length","util","pluralize","appPath","rimrafSync","e","warn","message","retrieveHeaders","link","url","method","timeout","headers","getCachedApplicationPath","currentAppProps","cachedAppInfo","refresh","_","isPlainObject","lastModified","currentModified","immutable","currentImmutable","maxAge","currentMaxAge","timestamp","getTime","msLeft","Date","now","path","basename","verifyAppExtension","supportedAppExtensions","toLower","includes","extname","Error","calculateFolderIntegrity","folderPath","glob","cwd","strict","nosort","calculateFileIntegrity","filePath","hash","isAppIntegrityOk","currentPath","expectedIntegrity","exists","stat","isDirectory","folder","file","configureApp","options","isString","onPostProcess","isArray","supportedExtensions","isEmpty","newApp","shouldUnzipApp","packageHash","remoteAppProps","protocol","pathname","parse","isUrl","get","acquire","test","maxAgeMatch","exec","parseInt","cachedPath","integrity","del","fileName","sanitizeName","decodeURIComponent","replacement","ct","some","mimeType","RegExp","escapeRegExp","match","resultingName","substring","resultingExt","first","targetPath","tempDir","prefix","suffix","downloadApp","errorMessage","isPackageAFile","isFile","isFunction","archivePath","tmpRoot","openDir","unzipApp","isAbsolute","resolve","storeAppInCache","appPathToCache","cachedFullPath","set","result","clone","Boolean","href","net","downloadFile","err","zipPath","dstRoot","zip","assertValidZip","timer","timing","Timer","start","useSystemUnzipEnv","env","APPIUM_PREFER_SYSTEM_UNZIP","useSystemUnzip","extractionOpts","fileNamesEncoding","extractAllTo","globPattern","ext","replace","join","sortedBundleItems","sort","a","b","split","sep","errorAndThrow","Math","round","getDuration","asMilliSeconds","matchedBundle","dstPath","mv","mkdirp","isPackageOrBundle","duplicateKeys","input","firstKey","secondKey","item","resultObj","key","value","toPairs","recursivelyCalledValue","parseCapsArray","cap","parsedCaps","JSON","ign","generateDriverLogPrefix","obj","sessionId","instanceName","constructor","name","node","getObjectId"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport path from 'path';\nimport url from 'url';\nimport logger from './logger';\nimport { tempDir, fs, util, zip, net, timing, node } from '@appium/support';\nimport LRU from 'lru-cache';\nimport AsyncLock from 'async-lock';\nimport axios from 'axios';\n\nconst IPA_EXT = '.ipa';\nconst ZIP_EXTS = ['.zip', IPA_EXT];\nconst ZIP_MIME_TYPES = [\n  'application/zip',\n  'application/x-zip-compressed',\n  'multipart/x-zip',\n];\nconst CACHED_APPS_MAX_AGE = 1000 * 60 * 60 * 24; // ms\nconst MAX_CACHED_APPS = 1024;\nconst APPLICATIONS_CACHE = new LRU({\n  max: MAX_CACHED_APPS,\n  ttl: CACHED_APPS_MAX_AGE, // expire after 24 hours\n  updateAgeOnGet: true,\n  dispose: (app, {fullPath}) => {\n    logger.info(`The application '${app}' cached at '${fullPath}' has ` +\n      `expired after ${CACHED_APPS_MAX_AGE}ms`);\n    if (fullPath) {\n      fs.rimraf(fullPath);\n    }\n  },\n  noDisposeOnSet: true,\n});\nconst APPLICATIONS_CACHE_GUARD = new AsyncLock();\nconst SANITIZE_REPLACEMENT = '-';\nconst DEFAULT_BASENAME = 'appium-app';\nconst APP_DOWNLOAD_TIMEOUT_MS = 120 * 1000;\n\nprocess.on('exit', () => {\n  if (APPLICATIONS_CACHE.size === 0) {\n    return;\n  }\n\n  const appPaths = [...APPLICATIONS_CACHE.values()]\n    .map(({fullPath}) => fullPath);\n  logger.debug(`Performing cleanup of ${appPaths.length} cached ` +\n    util.pluralize('application', appPaths.length));\n  for (const appPath of appPaths) {\n    try {\n      // Asynchronous calls are not supported in onExit handler\n      fs.rimrafSync(appPath);\n    } catch (e) {\n      logger.warn(e.message);\n    }\n  }\n});\n\n\nasync function retrieveHeaders (link) {\n  try {\n    return (await axios({\n      url: link,\n      method: 'HEAD',\n      timeout: 5000,\n    })).headers;\n  } catch (e) {\n    logger.info(`Cannot send HEAD request to '${link}'. Original error: ${e.message}`);\n  }\n  return {};\n}\n\nfunction getCachedApplicationPath (link, currentAppProps = {}, cachedAppInfo = {}) {\n  const refresh = () => {\n    logger.debug(`A fresh copy of the application is going to be downloaded from ${link}`);\n    return null;\n  };\n\n  if (!_.isPlainObject(cachedAppInfo) || !_.isPlainObject(currentAppProps)) {\n    // if an invalid arg is passed then assume cache miss\n    return refresh();\n  }\n\n  const {\n    lastModified: currentModified,\n    immutable: currentImmutable,\n    // maxAge is in seconds\n    maxAge: currentMaxAge,\n  } = currentAppProps;\n  const {\n    // Date instance\n    lastModified,\n    // boolean\n    immutable,\n    // Unix time in milliseconds\n    timestamp,\n    fullPath,\n  } = cachedAppInfo;\n  if (lastModified && currentModified) {\n    if (currentModified.getTime() <= lastModified.getTime()) {\n      logger.debug(`The application at ${link} has not been modified since ${lastModified}`);\n      return fullPath;\n    }\n    logger.debug(`The application at ${link} has been modified since ${lastModified}`);\n    return refresh();\n  }\n  if (immutable && currentImmutable) {\n    logger.debug(`The application at ${link} is immutable`);\n    return fullPath;\n  }\n  if (currentMaxAge && timestamp) {\n    const msLeft = timestamp + currentMaxAge * 1000 - Date.now();\n    if (msLeft > 0) {\n      logger.debug(`The cached application '${path.basename(fullPath)}' will expire in ${msLeft / 1000}s`);\n      return fullPath;\n    }\n    logger.debug(`The cached application '${path.basename(fullPath)}' has expired`);\n  }\n  return refresh();\n}\n\nfunction verifyAppExtension (app, supportedAppExtensions) {\n  if (supportedAppExtensions.map(_.toLower).includes(_.toLower(path.extname(app)))) {\n    return app;\n  }\n  throw new Error(`New app path '${app}' did not have ` +\n    `${util.pluralize('extension', supportedAppExtensions.length, false)}: ` +\n    supportedAppExtensions);\n}\n\nasync function calculateFolderIntegrity (folderPath) {\n  return (await fs.glob('**/*', {cwd: folderPath, strict: false, nosort: true})).length;\n}\n\nasync function calculateFileIntegrity (filePath) {\n  return await fs.hash(filePath);\n}\n\nasync function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {\n  if (!await fs.exists(currentPath)) {\n    return false;\n  }\n\n  // Folder integrity check is simple:\n  // Verify the previous amount of files is not greater than the current one.\n  // We don't want to use equality comparison because of an assumption that the OS might\n  // create some unwanted service files/cached inside of that folder or its subfolders.\n  // Ofc, validating the hash sum of each file (or at least of file path) would be much\n  // more precise, but we don't need to be very precise here and also don't want to\n  // overuse RAM and have a performance drop.\n  return (await fs.stat(currentPath)).isDirectory()\n    ? await calculateFolderIntegrity(currentPath) >= expectedIntegrity?.folder\n    : await calculateFileIntegrity(currentPath) === expectedIntegrity?.file;\n}\n\n/**\n * @typedef PostProcessOptions\n * @property {?Object} cachedAppInfo The information about the previously cached app instance (if exists):\n *    - packageHash: SHA1 hash of the package if it is a file and not a folder\n *    - lastModified: Optional Date instance, the value of file's `Last-Modified` header\n *    - immutable: Optional boolean value. Contains true if the file has an `immutable` mark\n *                 in `Cache-control` header\n *    - maxAge: Optional integer representation of `maxAge` parameter in `Cache-control` header\n *    - timestamp: The timestamp this item has been added to the cache (measured in Unix epoch\n *                 milliseconds)\n *    - integrity: An object containing either `file` property with SHA1 hash of the file\n *                 or `folder` property with total amount of cached files and subfolders\n *    - fullPath: the full path to the cached app\n * @property {boolean} isUrl Whether the app has been downloaded from a remote URL\n * @property {?Object} headers Optional headers object. Only present if `isUrl` is true and if the server\n * responds to HEAD requests. All header names are normalized to lowercase.\n * @property {string} appPath A string containing full path to the preprocessed application package (either\n * downloaded or a local one)\n */\n\n/**\n * @typedef PostProcessResult\n * @property {string} appPath The full past to the post-processed application package on the\n * local file system (might be a file or a folder path)\n */\n\n/**\n * @typedef ConfigureAppOptions\n * @property {(obj: PostProcessOptions) => (Promise<PostProcessResult|undefined>|PostProcessResult|undefined)} onPostProcess\n * Optional function, which should be applied\n * to the application after it is downloaded/preprocessed. This function may be async\n * and is expected to accept single object parameter.\n * The function is expected to either return a falsy value, which means the app must not be\n * cached and a fresh copy of it is downloaded each time. If this function returns an object\n * containing `appPath` property then the integrity of it will be verified and stored into\n * the cache.\n * @property {string[]} supportedExtensions List of supported application extensions (\n * including starting dots). This property is mandatory and must not be empty.\n */\n\n/**\n * Prepares an app to be used in an automated test. The app gets cached automatically\n * if it is an archive or if it is downloaded from an URL.\n * If the downloaded app has `.zip` extension, this method will unzip it.\n * The unzip does not work when `onPostProcess` is provided.\n *\n * @param {string} app Either a full path to the app or a remote URL\n * @param {string|string[]|ConfigureAppOptions} options\n * @returns The full path to the resulting application bundle\n */\nasync function configureApp (app, options = {}) {\n  if (!_.isString(app)) {\n    // immediately shortcircuit if not given an app\n    return;\n  }\n\n  let supportedAppExtensions;\n  const {\n    onPostProcess,\n  } = _.isPlainObject(options) ? options : {};\n  if (_.isString(options)) {\n    supportedAppExtensions = [options];\n  } else if (_.isArray(options)) {\n    supportedAppExtensions = options;\n  } else if (_.isPlainObject(options)) {\n    supportedAppExtensions = options.supportedExtensions;\n  }\n  if (_.isEmpty(supportedAppExtensions)) {\n    throw new Error(`One or more supported app extensions must be provided`);\n  }\n\n  let newApp = app;\n  let shouldUnzipApp = false;\n  let packageHash = null;\n  let headers = null;\n  const remoteAppProps = {\n    lastModified: null,\n    immutable: false,\n    maxAge: null,\n  };\n  const {protocol, pathname} = url.parse(newApp);\n  const isUrl = ['http:', 'https:'].includes(protocol);\n\n  const cachedAppInfo = APPLICATIONS_CACHE.get(app);\n\n  return await APPLICATIONS_CACHE_GUARD.acquire(app, async () => {\n    if (isUrl) {\n      // Use the app from remote URL\n      logger.info(`Using downloadable app '${newApp}'`);\n      headers = await retrieveHeaders(newApp);\n      if (!_.isEmpty(headers)) {\n        if (headers['last-modified']) {\n          remoteAppProps.lastModified = new Date(headers['last-modified']);\n        }\n        logger.debug(`Last-Modified: ${headers['last-modified']}`);\n        if (headers['cache-control']) {\n          remoteAppProps.immutable = /\\bimmutable\\b/i.test(headers['cache-control']);\n          const maxAgeMatch = /\\bmax-age=(\\d+)\\b/i.exec(headers['cache-control']);\n          if (maxAgeMatch) {\n            remoteAppProps.maxAge = parseInt(maxAgeMatch[1], 10);\n          }\n        }\n        logger.debug(`Cache-Control: ${headers['cache-control']}`);\n      }\n      const cachedPath = getCachedApplicationPath(app, remoteAppProps, cachedAppInfo);\n      if (cachedPath) {\n        if (await isAppIntegrityOk(cachedPath, cachedAppInfo?.integrity)) {\n          logger.info(`Reusing previously downloaded application at '${cachedPath}'`);\n          return verifyAppExtension(cachedPath, supportedAppExtensions);\n        }\n        logger.info(`The application at '${cachedPath}' does not exist anymore ` +\n          `or its integrity has been damaged. Deleting it from the internal cache`);\n        APPLICATIONS_CACHE.del(app);\n      }\n\n      let fileName = null;\n      const basename = fs.sanitizeName(path.basename(decodeURIComponent(pathname)), {\n        replacement: SANITIZE_REPLACEMENT\n      });\n      const extname = path.extname(basename);\n      // to determine if we need to unzip the app, we have a number of places\n      // to look: content type, content disposition, or the file extension\n      if (ZIP_EXTS.includes(extname)) {\n        fileName = basename;\n        shouldUnzipApp = true;\n      }\n      if (headers['content-type']) {\n        const ct = headers['content-type'];\n        logger.debug(`Content-Type: ${ct}`);\n        // the filetype may not be obvious for certain urls, so check the mime type too\n        if (ZIP_MIME_TYPES.some((mimeType) => new RegExp(`\\\\b${_.escapeRegExp(mimeType)}\\\\b`).test(ct))) {\n          if (!fileName) {\n            fileName = `${DEFAULT_BASENAME}.zip`;\n          }\n          shouldUnzipApp = true;\n        }\n      }\n      if (headers['content-disposition'] && /^attachment/i.test(headers['content-disposition'])) {\n        logger.debug(`Content-Disposition: ${headers['content-disposition']}`);\n        const match = /filename=\"([^\"]+)/i.exec(headers['content-disposition']);\n        if (match) {\n          fileName = fs.sanitizeName(match[1], {\n            replacement: SANITIZE_REPLACEMENT\n          });\n          shouldUnzipApp = shouldUnzipApp || ZIP_EXTS.includes(path.extname(fileName));\n        }\n      }\n      if (!fileName) {\n        // assign the default file name and the extension if none has been detected\n        const resultingName = basename\n          ? basename.substring(0, basename.length - extname.length)\n          : DEFAULT_BASENAME;\n        let resultingExt = extname;\n        if (!supportedAppExtensions.includes(resultingExt)) {\n          logger.info(`The current file extension '${resultingExt}' is not supported. ` +\n            `Defaulting to '${_.first(supportedAppExtensions)}'`);\n          resultingExt = _.first(supportedAppExtensions);\n        }\n        fileName = `${resultingName}${resultingExt}`;\n      }\n      const targetPath = await tempDir.path({\n        prefix: fileName,\n        suffix: '',\n      });\n      newApp = await downloadApp(newApp, targetPath);\n    } else if (await fs.exists(newApp)) {\n      // Use the local app\n      logger.info(`Using local app '${newApp}'`);\n      shouldUnzipApp = ZIP_EXTS.includes(path.extname(newApp));\n    } else {\n      let errorMessage = `The application at '${newApp}' does not exist or is not accessible`;\n      // protocol value for 'C:\\\\temp' is 'c:', so we check the length as well\n      if (_.isString(protocol) && protocol.length > 2) {\n        errorMessage = `The protocol '${protocol}' used in '${newApp}' is not supported. ` +\n          `Only http: and https: protocols are supported`;\n      }\n      throw new Error(errorMessage);\n    }\n\n    const isPackageAFile = (await fs.stat(newApp)).isFile();\n    if (isPackageAFile) {\n      packageHash = await calculateFileIntegrity(newApp);\n    }\n\n    if (isPackageAFile && shouldUnzipApp && !_.isFunction(onPostProcess)) {\n      const archivePath = newApp;\n      if (packageHash === cachedAppInfo?.packageHash) {\n        const {fullPath} = cachedAppInfo;\n        if (await isAppIntegrityOk(fullPath, cachedAppInfo?.integrity)) {\n          if (archivePath !== app) {\n            await fs.rimraf(archivePath);\n          }\n          logger.info(`Will reuse previously cached application at '${fullPath}'`);\n          return verifyAppExtension(fullPath, supportedAppExtensions);\n        }\n        logger.info(`The application at '${fullPath}' does not exist anymore ` +\n          `or its integrity has been damaged. Deleting it from the cache`);\n        APPLICATIONS_CACHE.del(app);\n      }\n      const tmpRoot = await tempDir.openDir();\n      try {\n        newApp = await unzipApp(archivePath, tmpRoot, supportedAppExtensions);\n      } finally {\n        if (newApp !== archivePath && archivePath !== app) {\n          await fs.rimraf(archivePath);\n        }\n      }\n      logger.info(`Unzipped local app to '${newApp}'`);\n    } else if (!path.isAbsolute(newApp)) {\n      newApp = path.resolve(process.cwd(), newApp);\n      logger.warn(`The current application path '${app}' is not absolute ` +\n        `and has been rewritten to '${newApp}'. Consider using absolute paths rather than relative`);\n      app = newApp;\n    }\n\n    const storeAppInCache = async (appPathToCache) => {\n      const cachedFullPath = cachedAppInfo?.fullPath;\n      if (cachedFullPath && cachedFullPath !== appPathToCache) {\n        await fs.rimraf(cachedFullPath);\n      }\n      const integrity = {};\n      if ((await fs.stat(appPathToCache)).isDirectory()) {\n        integrity.folder = await calculateFolderIntegrity(appPathToCache);\n      } else {\n        integrity.file = await calculateFileIntegrity(appPathToCache);\n      }\n      APPLICATIONS_CACHE.set(app, {\n        ...remoteAppProps,\n        timestamp: Date.now(),\n        packageHash,\n        integrity,\n        fullPath: appPathToCache,\n      });\n      return appPathToCache;\n    };\n\n    if (_.isFunction(onPostProcess)) {\n      const result = await onPostProcess({\n        cachedAppInfo: _.clone(cachedAppInfo),\n        isUrl,\n        headers: _.clone(headers),\n        appPath: newApp,\n      });\n      return (!result?.appPath || app === result?.appPath || !await fs.exists(result?.appPath))\n        ? newApp\n        : await storeAppInCache(result.appPath);\n    }\n\n    verifyAppExtension(newApp, supportedAppExtensions);\n    return (app !== newApp && (packageHash || _.values(remoteAppProps).some(Boolean)))\n      ? await storeAppInCache(newApp)\n      : newApp;\n  });\n}\n\nasync function downloadApp (app, targetPath) {\n  const {href} = url.parse(app);\n  try {\n    await net.downloadFile(href, targetPath, {\n      timeout: APP_DOWNLOAD_TIMEOUT_MS,\n    });\n  } catch (err) {\n    throw new Error(`Unable to download the app: ${err.message}`);\n  }\n  return targetPath;\n}\n\n/**\n * Extracts the bundle from an archive into the given folder\n *\n * @param {string} zipPath Full path to the archive containing the bundle\n * @param {string} dstRoot Full path to the folder where the extracted bundle\n * should be placed\n * @param {Array<string>|string} supportedAppExtensions The list of extensions\n * the target application bundle supports, for example ['.apk', '.apks'] for\n * Android packages\n * @returns {string} Full path to the bundle in the destination folder\n * @throws {Error} If the given archive is invalid or no application bundles\n * have been found inside\n */\nasync function unzipApp (zipPath, dstRoot, supportedAppExtensions) {\n  await zip.assertValidZip(zipPath);\n\n  if (!_.isArray(supportedAppExtensions)) {\n    supportedAppExtensions = [supportedAppExtensions];\n  }\n\n  const tmpRoot = await tempDir.openDir();\n  try {\n    logger.debug(`Unzipping '${zipPath}'`);\n    const timer = new timing.Timer().start();\n    const useSystemUnzipEnv = process.env.APPIUM_PREFER_SYSTEM_UNZIP;\n    const useSystemUnzip = _.isEmpty(useSystemUnzipEnv)\n      || !['0', 'false'].includes(_.toLower(useSystemUnzipEnv));\n    /**\n     * Attempt to use use the system `unzip` (e.g., `/usr/bin/unzip`) due\n     * to the significant performance improvement it provides over the native\n     * JS \"unzip\" implementation.\n     * @type {import('@appium/support/lib/zip').ExtractAllOptions}\n     */\n    const extractionOpts = {useSystemUnzip};\n    // https://github.com/appium/appium/issues/14100\n    if (path.extname(zipPath) === IPA_EXT) {\n      logger.debug(`Enforcing UTF-8 encoding on the extracted file names for '${path.basename(zipPath)}'`);\n      extractionOpts.fileNamesEncoding = 'utf8';\n    }\n    await zip.extractAllTo(zipPath, tmpRoot, extractionOpts);\n    const globPattern = `**/*.+(${supportedAppExtensions.map((ext) => ext.replace(/^\\./, '')).join('|')})`;\n    const sortedBundleItems = (await fs.glob(globPattern, {\n      cwd: tmpRoot,\n      strict: false,\n    // Get the top level match\n    })).sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);\n    if (_.isEmpty(sortedBundleItems)) {\n      logger.errorAndThrow(`App unzipped OK, but we could not find any '${supportedAppExtensions}' ` +\n        util.pluralize('bundle', supportedAppExtensions.length, false) +\n        ` in it. Make sure your archive contains at least one package having ` +\n        `'${supportedAppExtensions}' ${util.pluralize('extension', supportedAppExtensions.length, false)}`);\n    }\n    logger.debug(`Extracted ${util.pluralize('bundle item', sortedBundleItems.length, true)} ` +\n      `from '${zipPath}' in ${Math.round(timer.getDuration().asMilliSeconds)}ms: ${sortedBundleItems}`);\n    const matchedBundle = _.first(sortedBundleItems);\n    logger.info(`Assuming '${matchedBundle}' is the correct bundle`);\n    const dstPath = path.resolve(dstRoot, path.basename(matchedBundle));\n    await fs.mv(path.resolve(tmpRoot, matchedBundle), dstPath, {mkdirp: true});\n    return dstPath;\n  } finally {\n    await fs.rimraf(tmpRoot);\n  }\n}\n\nfunction isPackageOrBundle (app) {\n  return (/^([a-zA-Z0-9\\-_]+\\.[a-zA-Z0-9\\-_]+)+$/).test(app);\n}\n\n/**\n * Finds all instances 'firstKey' and create a duplicate with the key 'secondKey',\n * Do the same thing in reverse. If we find 'secondKey', create a duplicate with the key 'firstKey'.\n *\n * This will cause keys to be overwritten if the object contains 'firstKey' and 'secondKey'.\n\n * @param {*} input Any type of input\n * @param {String} firstKey The first key to duplicate\n * @param {String} secondKey The second key to duplicate\n */\nfunction duplicateKeys (input, firstKey, secondKey) {\n  // If array provided, recursively call on all elements\n  if (_.isArray(input)) {\n    return input.map((item) => duplicateKeys(item, firstKey, secondKey));\n  }\n\n  // If object, create duplicates for keys and then recursively call on values\n  if (_.isPlainObject(input)) {\n    const resultObj = {};\n    for (let [key, value] of _.toPairs(input)) {\n      const recursivelyCalledValue = duplicateKeys(value, firstKey, secondKey);\n      if (key === firstKey) {\n        resultObj[secondKey] = recursivelyCalledValue;\n      } else if (key === secondKey) {\n        resultObj[firstKey] = recursivelyCalledValue;\n      }\n      resultObj[key] = recursivelyCalledValue;\n    }\n    return resultObj;\n  }\n\n  // Base case. Return primitives without doing anything.\n  return input;\n}\n\n/**\n * Takes a desired capability and tries to JSON.parse it as an array,\n * and either returns the parsed array or a singleton array.\n *\n * @param {string|Array<String>} cap A desired capability\n */\nfunction parseCapsArray (cap) {\n  if (_.isArray(cap)) {\n    return cap;\n  }\n\n  let parsedCaps;\n  try {\n    parsedCaps = JSON.parse(cap);\n    if (_.isArray(parsedCaps)) {\n      return parsedCaps;\n    }\n  } catch (ign) {\n    logger.warn(`Failed to parse capability as JSON array`);\n  }\n  if (_.isString(cap)) {\n    return [cap];\n  }\n  throw new Error(`must provide a string or JSON Array; received ${cap}`);\n}\n\n/**\n * Generate a string that uniquely describes driver instance\n *\n * @param {import('@appium/types').Core} obj driver instance\n * @param {string?} sessionId session identifier (if exists)\n * @returns {string}\n */\nfunction generateDriverLogPrefix (obj, sessionId = null) {\n  const instanceName = `${obj.constructor.name}@${node.getObjectId(obj).substring(0, 4)}`;\n  return sessionId ? `${instanceName} (${sessionId.substring(0, 8)})` : instanceName;\n}\n\n/** @type {import('@appium/types').DriverHelpers} */\nexport default {\n  configureApp, isPackageOrBundle, duplicateKeys, parseCapsArray, generateDriverLogPrefix\n};\nexport {\n  configureApp, isPackageOrBundle, duplicateKeys, parseCapsArray, generateDriverLogPrefix\n};\n"]}

package/build/lib/basedriver/logger.d.ts

@@ -0,0 +1,3 @@
+export default log;
+declare const log: import("@appium/types").AppiumLogger;
+//# sourceMappingURL=logger.d.ts.map

package/build/lib/basedriver/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/logger.js"],"names":[],"mappings":";AAEA,wDAA2C"}

package/build/lib/basedriver/logger.js

@@ -12,7 +12,5 @@ var _support = require("@appium/support");
 const log = _support.logger.getLogger('BaseDriver');
 
 var _default = log;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9iYXNlZHJpdmVyL2xvZ2dlci5qcyJdLCJuYW1lcyI6WyJsb2ciLCJsb2dnZXIiLCJnZXRMb2dnZXIiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBOztBQUVBLE1BQU1BLEdBQUcsR0FBR0MsZ0JBQU9DLFNBQVAsQ0FBaUIsWUFBakIsQ0FBWjs7ZUFDZUYsRyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGxvZ2dlciB9IGZyb20gJ0BhcHBpdW0vc3VwcG9ydCc7XG5cbmNvbnN0IGxvZyA9IGxvZ2dlci5nZXRMb2dnZXIoJ0Jhc2VEcml2ZXInKTtcbmV4cG9ydCBkZWZhdWx0IGxvZztcbiJdLCJmaWxlIjoibGliL2Jhc2Vkcml2ZXIvbG9nZ2VyLmpzIiwic291cmNlUm9vdCI6Ii4uLy4uLy4uIn0=
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9iYXNlZHJpdmVyL2xvZ2dlci5qcyJdLCJuYW1lcyI6WyJsb2ciLCJsb2dnZXIiLCJnZXRMb2dnZXIiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBOztBQUVBLE1BQU1BLEdBQUcsR0FBR0MsZ0JBQU9DLFNBQVAsQ0FBaUIsWUFBakIsQ0FBWjs7ZUFDZUYsRyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGxvZ2dlciB9IGZyb20gJ0BhcHBpdW0vc3VwcG9ydCc7XG5cbmNvbnN0IGxvZyA9IGxvZ2dlci5nZXRMb2dnZXIoJ0Jhc2VEcml2ZXInKTtcbmV4cG9ydCBkZWZhdWx0IGxvZztcbiJdfQ==

package/build/lib/constants.d.ts

@@ -0,0 +1,9 @@
+export const MAX_LOG_BODY_LENGTH: 1024;
+export const MJSONWP_ELEMENT_KEY: "ELEMENT";
+export const W3C_ELEMENT_KEY: "element-6066-11e4-a52e-4f735466cecf";
+export namespace PROTOCOLS {
+    const W3C: string;
+    const MJSONWP: string;
+}
+export const DEFAULT_BASE_PATH: "";
+//# sourceMappingURL=constants.d.ts.map

package/build/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../lib/constants.js"],"names":[],"mappings":"AAQA,uCAAiC;AACjC,4CAAsC;AACtC,oEAAwD;;;;;AAOxD,mCAA6B"}

package/build/lib/constants.js

@@ -21,7 +21,5 @@ const PROTOCOLS = {
 };
 exports.PROTOCOLS = PROTOCOLS;
 const DEFAULT_BASE_PATH = '';
-exports.DEFAULT_BASE_PATH = DEFAULT_BASE_PATH;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9jb25zdGFudHMuanMiXSwibmFtZXMiOlsiTUFYX0xPR19CT0RZX0xFTkdUSCIsIk1KU09OV1BfRUxFTUVOVF9LRVkiLCJXM0NfRUxFTUVOVF9LRVkiLCJ1dGlsIiwiVzNDX1dFQl9FTEVNRU5UX0lERU5USUZJRVIiLCJQUk9UT0NPTFMiLCJXM0MiLCJNSlNPTldQIiwiREVGQVVMVF9CQVNFX1BBVEgiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBOztBQVFBLE1BQU1BLG1CQUFtQixHQUFHLElBQTVCOztBQUNBLE1BQU1DLG1CQUFtQixHQUFHLFNBQTVCOztBQUNBLE1BQU1DLGVBQWUsR0FBR0MsY0FBS0MsMEJBQTdCOztBQUNBLE1BQU1DLFNBQVMsR0FBRztBQUNoQkMsRUFBQUEsR0FBRyxFQUFFLEtBRFc7QUFFaEJDLEVBQUFBLE9BQU8sRUFBRTtBQUZPLENBQWxCOztBQU1BLE1BQU1DLGlCQUFpQixHQUFHLEVBQTFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdXRpbCB9IGZyb20gJ0BhcHBpdW0vc3VwcG9ydCc7XG5cbi8vIFRoZSBkZWZhdWx0IG1heGltdW0gbGVuZ3RoIG9mIGEgc2luZ2xlIGxvZyByZWNvcmRcbi8vIGNvbnRhaW5pbmcgaHR0cCByZXF1ZXN0L3Jlc3BvbnNlIGJvZHlcbi8vIFRoaXMgdmFsdWUgY291bGQgYmUgZ2xvYmFsbHkgY3VzdG9taXplZCB1c2luZyB0aGUgLS1sb2ctZmlsdGVyc1xuLy8gc2VydmVyIGZlYXR1cmUuIEV4YW1wbGUgcnVsZTpcbi8vIFx0e1wicGF0dGVyblwiOiBcIiguezEsMTUwfSkuKlwiLCBcImZsYWdzXCI6IFwic1wiLCBcInJlcGxhY2VyXCI6IFwiJDFcIn1cbi8vIF4gY3V0cyBhbGwgbG9nIHJlY29yZHMgdG8gbWF4aW11bSAxNTAgY2hhcnNcbmNvbnN0IE1BWF9MT0dfQk9EWV9MRU5HVEggPSAxMDI0O1xuY29uc3QgTUpTT05XUF9FTEVNRU5UX0tFWSA9ICdFTEVNRU5UJztcbmNvbnN0IFczQ19FTEVNRU5UX0tFWSA9IHV0aWwuVzNDX1dFQl9FTEVNRU5UX0lERU5USUZJRVI7XG5jb25zdCBQUk9UT0NPTFMgPSB7XG4gIFczQzogJ1czQycsXG4gIE1KU09OV1A6ICdNSlNPTldQJyxcbn07XG5cbi8vIEJlZm9yZSBBcHBpdW0gMi4wLCB0aGlzIGRlZmF1bHQgdmFsdWUgd2FzICcvd2QvaHViJyBieSBoaXN0b3JpY2FsIHJlYXNvbnMuXG5jb25zdCBERUZBVUxUX0JBU0VfUEFUSCA9ICcnO1xuXG5cbmV4cG9ydCB7XG4gIE1BWF9MT0dfQk9EWV9MRU5HVEgsIE1KU09OV1BfRUxFTUVOVF9LRVksIFczQ19FTEVNRU5UX0tFWSxcbiAgUFJPVE9DT0xTLCBERUZBVUxUX0JBU0VfUEFUSFxufTtcbiJdLCJmaWxlIjoibGliL2NvbnN0YW50cy5qcyIsInNvdXJjZVJvb3QiOiIuLi8uLiJ9
+exports.DEFAULT_BASE_PATH = DEFAULT_BASE_PATH;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9jb25zdGFudHMuanMiXSwibmFtZXMiOlsiTUFYX0xPR19CT0RZX0xFTkdUSCIsIk1KU09OV1BfRUxFTUVOVF9LRVkiLCJXM0NfRUxFTUVOVF9LRVkiLCJ1dGlsIiwiVzNDX1dFQl9FTEVNRU5UX0lERU5USUZJRVIiLCJQUk9UT0NPTFMiLCJXM0MiLCJNSlNPTldQIiwiREVGQVVMVF9CQVNFX1BBVEgiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBOztBQVFBLE1BQU1BLG1CQUFtQixHQUFHLElBQTVCOztBQUNBLE1BQU1DLG1CQUFtQixHQUFHLFNBQTVCOztBQUNBLE1BQU1DLGVBQWUsR0FBR0MsY0FBS0MsMEJBQTdCOztBQUNBLE1BQU1DLFNBQVMsR0FBRztBQUNoQkMsRUFBQUEsR0FBRyxFQUFFLEtBRFc7QUFFaEJDLEVBQUFBLE9BQU8sRUFBRTtBQUZPLENBQWxCOztBQU1BLE1BQU1DLGlCQUFpQixHQUFHLEVBQTFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdXRpbCB9IGZyb20gJ0BhcHBpdW0vc3VwcG9ydCc7XG5cbi8vIFRoZSBkZWZhdWx0IG1heGltdW0gbGVuZ3RoIG9mIGEgc2luZ2xlIGxvZyByZWNvcmRcbi8vIGNvbnRhaW5pbmcgaHR0cCByZXF1ZXN0L3Jlc3BvbnNlIGJvZHlcbi8vIFRoaXMgdmFsdWUgY291bGQgYmUgZ2xvYmFsbHkgY3VzdG9taXplZCB1c2luZyB0aGUgLS1sb2ctZmlsdGVyc1xuLy8gc2VydmVyIGZlYXR1cmUuIEV4YW1wbGUgcnVsZTpcbi8vIFx0e1wicGF0dGVyblwiOiBcIiguezEsMTUwfSkuKlwiLCBcImZsYWdzXCI6IFwic1wiLCBcInJlcGxhY2VyXCI6IFwiJDFcIn1cbi8vIF4gY3V0cyBhbGwgbG9nIHJlY29yZHMgdG8gbWF4aW11bSAxNTAgY2hhcnNcbmNvbnN0IE1BWF9MT0dfQk9EWV9MRU5HVEggPSAxMDI0O1xuY29uc3QgTUpTT05XUF9FTEVNRU5UX0tFWSA9ICdFTEVNRU5UJztcbmNvbnN0IFczQ19FTEVNRU5UX0tFWSA9IHV0aWwuVzNDX1dFQl9FTEVNRU5UX0lERU5USUZJRVI7XG5jb25zdCBQUk9UT0NPTFMgPSB7XG4gIFczQzogJ1czQycsXG4gIE1KU09OV1A6ICdNSlNPTldQJyxcbn07XG5cbi8vIEJlZm9yZSBBcHBpdW0gMi4wLCB0aGlzIGRlZmF1bHQgdmFsdWUgd2FzICcvd2QvaHViJyBieSBoaXN0b3JpY2FsIHJlYXNvbnMuXG5jb25zdCBERUZBVUxUX0JBU0VfUEFUSCA9ICcnO1xuXG5cbmV4cG9ydCB7XG4gIE1BWF9MT0dfQk9EWV9MRU5HVEgsIE1KU09OV1BfRUxFTUVOVF9LRVksIFczQ19FTEVNRU5UX0tFWSxcbiAgUFJPVE9DT0xTLCBERUZBVUxUX0JBU0VfUEFUSFxufTtcbiJdfQ==

package/build/lib/express/crash.d.ts

@@ -0,0 +1,3 @@
+export function produceError(): void;
+export function produceCrash(): void;
+//# sourceMappingURL=crash.d.ts.map

package/build/lib/express/crash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crash.d.ts","sourceRoot":"","sources":["../../../lib/express/crash.js"],"names":[],"mappings":"AAGA,qCAEC;AAED,qCAEC"}

package/build/lib/express/crash.js

@@ -16,7 +16,5 @@ function produceError() {
 
 function produceCrash() {
   throw new Error('We just tried to crash Appium!');
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9leHByZXNzL2NyYXNoLmpzIl0sIm5hbWVzIjpbInByb2R1Y2VFcnJvciIsImVycm9ycyIsIlVua25vd25Db21tYW5kRXJyb3IiLCJwcm9kdWNlQ3Jhc2giLCJFcnJvciJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7OztBQUFBOztBQUdBLFNBQVNBLFlBQVQsR0FBeUI7QUFDdkIsUUFBTSxJQUFJQyxpQkFBT0MsbUJBQVgsQ0FBK0Isb0NBQS9CLENBQU47QUFDRDs7QUFFRCxTQUFTQyxZQUFULEdBQXlCO0FBQ3ZCLFFBQU0sSUFBSUMsS0FBSixDQUFVLGdDQUFWLENBQU47QUFDRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGVycm9ycyB9IGZyb20gJy4uL3Byb3RvY29sJztcblxuXG5mdW5jdGlvbiBwcm9kdWNlRXJyb3IgKCkge1xuICB0aHJvdyBuZXcgZXJyb3JzLlVua25vd25Db21tYW5kRXJyb3IoJ1Byb2R1Y2VkIGdlbmVyaWMgZXJyb3IgZm9yIHRlc3RpbmcnKTtcbn1cblxuZnVuY3Rpb24gcHJvZHVjZUNyYXNoICgpIHtcbiAgdGhyb3cgbmV3IEVycm9yKCdXZSBqdXN0IHRyaWVkIHRvIGNyYXNoIEFwcGl1bSEnKTtcbn1cblxuXG5leHBvcnQgeyBwcm9kdWNlRXJyb3IsIHByb2R1Y2VDcmFzaCB9O1xuIl0sImZpbGUiOiJsaWIvZXhwcmVzcy9jcmFzaC5qcyIsInNvdXJjZVJvb3QiOiIuLi8uLi8uLiJ9
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9leHByZXNzL2NyYXNoLmpzIl0sIm5hbWVzIjpbInByb2R1Y2VFcnJvciIsImVycm9ycyIsIlVua25vd25Db21tYW5kRXJyb3IiLCJwcm9kdWNlQ3Jhc2giLCJFcnJvciJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7OztBQUFBOztBQUdBLFNBQVNBLFlBQVQsR0FBeUI7QUFDdkIsUUFBTSxJQUFJQyxpQkFBT0MsbUJBQVgsQ0FBK0Isb0NBQS9CLENBQU47QUFDRDs7QUFFRCxTQUFTQyxZQUFULEdBQXlCO0FBQ3ZCLFFBQU0sSUFBSUMsS0FBSixDQUFVLGdDQUFWLENBQU47QUFDRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGVycm9ycyB9IGZyb20gJy4uL3Byb3RvY29sJztcblxuXG5mdW5jdGlvbiBwcm9kdWNlRXJyb3IgKCkge1xuICB0aHJvdyBuZXcgZXJyb3JzLlVua25vd25Db21tYW5kRXJyb3IoJ1Byb2R1Y2VkIGdlbmVyaWMgZXJyb3IgZm9yIHRlc3RpbmcnKTtcbn1cblxuZnVuY3Rpb24gcHJvZHVjZUNyYXNoICgpIHtcbiAgdGhyb3cgbmV3IEVycm9yKCdXZSBqdXN0IHRyaWVkIHRvIGNyYXNoIEFwcGl1bSEnKTtcbn1cblxuXG5leHBvcnQgeyBwcm9kdWNlRXJyb3IsIHByb2R1Y2VDcmFzaCB9O1xuIl19

package/build/lib/express/express-logging.d.ts

@@ -0,0 +1,3 @@
+export const endLogFormatter: any;
+export const startLogFormatter: any;
+//# sourceMappingURL=express-logging.d.ts.map

package/build/lib/express/express-logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express-logging.d.ts","sourceRoot":"","sources":["../../../lib/express/express-logging.js"],"names":[],"mappings":"AAoCA,kCAGG;AAIH,oCAWsB"}

package/build/lib/express/express-logging.js

@@ -11,7 +11,7 @@ require("source-map-support/register");
 
 var _lodash = _interopRequireDefault(require("lodash"));
 
-require("@dabh/colors");
+require("@colors/colors");
 
 var _morgan = _interopRequireDefault(require("morgan"));
 
@@ -66,7 +66,5 @@ const startLogFormatter = (0, _morgan.default)((tokens, req, res) => {
 }, {
   immediate: true
 });
-exports.startLogFormatter = startLogFormatter;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+exports.startLogFormatter = startLogFormatter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/express/idempotency.d.ts

@@ -0,0 +1,2 @@
+export function handleIdempotency(req: any, res: any, next: any): Promise<any>;
+//# sourceMappingURL=idempotency.d.ts.map

package/build/lib/express/idempotency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idempotency.d.ts","sourceRoot":"","sources":["../../../lib/express/idempotency.js"],"names":[],"mappings":"AAgGA,+EAqDC"}