@appium/support 2.55.4 → 2.57.0

package/build/lib/npm.js

@@ -0,0 +1,217 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.npm = exports.NPM = exports.INSTALL_LOCKFILE_RELATIVE_PATH = exports.CACHE_DIR_RELATIVE_PATH = void 0;
+
+require("source-map-support/register");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _semver = _interopRequireDefault(require("semver"));
+
+var _env = require("./env");
+
+var _teen_process = require("teen_process");
+
+var _fs = require("./fs");
+
+var util = _interopRequireWildcard(require("./util"));
+
+var system = _interopRequireWildcard(require("./system"));
+
+var _resolveFrom = _interopRequireDefault(require("resolve-from"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const CACHE_DIR_RELATIVE_PATH = _path.default.join('node_modules', '.cache', 'appium');
+
+exports.CACHE_DIR_RELATIVE_PATH = CACHE_DIR_RELATIVE_PATH;
+
+const INSTALL_LOCKFILE_RELATIVE_PATH = _path.default.join(CACHE_DIR_RELATIVE_PATH, '.install.lock');
+
+exports.INSTALL_LOCKFILE_RELATIVE_PATH = INSTALL_LOCKFILE_RELATIVE_PATH;
+
+class NPM {
+  _getInstallLockfilePath(cwd) {
+    return _path.default.join(cwd, INSTALL_LOCKFILE_RELATIVE_PATH);
+  }
+
+  async exec(cmd, args, opts, execOpts = {}) {
+    let {
+      cwd,
+      json,
+      lockFile
+    } = opts;
+    execOpts = { ...execOpts,
+      cwd
+    };
+    args.unshift(cmd);
+
+    if (json) {
+      args.push('--json');
+    }
+
+    const npmCmd = system.isWindows() ? 'npm.cmd' : 'npm';
+
+    let runner = async () => await (0, _teen_process.exec)(npmCmd, args, execOpts);
+
+    if (lockFile) {
+      const acquireLock = util.getLockFileGuard(lockFile);
+      const _runner = runner;
+
+      runner = async () => await acquireLock(_runner);
+    }
+
+    let ret;
+
+    try {
+      const {
+        stdout,
+        stderr,
+        code
+      } = await runner();
+      ret = {
+        stdout,
+        stderr,
+        code
+      };
+
+      try {
+        ret.json = JSON.parse(stdout);
+      } catch (ign) {}
+    } catch (e) {
+      const {
+        stdout = '',
+        stderr = '',
+        code = null
+      } = e;
+      const err = new Error(`npm command '${args.join(' ')}' failed with code ${code}.\n\nSTDOUT:\n${stdout.trim()}\n\nSTDERR:\n${stderr.trim()}`);
+      throw err;
+    }
+
+    return ret;
+  }
+
+  async getLatestVersion(cwd, pkg) {
+    var _await$this$exec$json;
+
+    return (_await$this$exec$json = (await this.exec('view', [pkg, 'dist-tags'], {
+      json: true,
+      cwd
+    })).json) === null || _await$this$exec$json === void 0 ? void 0 : _await$this$exec$json.latest;
+  }
+
+  async getLatestSafeUpgradeVersion(cwd, pkg, curVersion) {
+    const allVersions = (await this.exec('view', [pkg, 'versions'], {
+      json: true,
+      cwd
+    })).json;
+    return this.getLatestSafeUpgradeFromVersions(curVersion, allVersions);
+  }
+
+  async list(cwd, pkg) {
+    return (await this.exec('list', pkg ? [pkg] : [], {
+      cwd,
+      json: true
+    })).json;
+  }
+
+  getLatestSafeUpgradeFromVersions(curVersion, allVersions) {
+    let safeUpgradeVer = null;
+
+    const curSemver = _semver.default.parse(curVersion);
+
+    if (curSemver === null) {
+      throw new Error(`Could not parse current version '${curVersion}'`);
+    }
+
+    for (const testVer of allVersions) {
+      const testSemver = _semver.default.parse(testVer);
+
+      if (testSemver === null) {
+        throw new Error(`Could not parse version to test against: '${testVer}'`);
+      }
+
+      if (testSemver.prerelease.length > 0) {
+        continue;
+      }
+
+      if (curSemver.compare(testSemver) === 1) {
+        continue;
+      }
+
+      if (testSemver.major > curSemver.major) {
+        continue;
+      }
+
+      if (safeUpgradeVer === null || testSemver.compare(safeUpgradeVer) === 1) {
+        safeUpgradeVer = testSemver;
+      }
+    }
+
+    if (safeUpgradeVer) {
+      safeUpgradeVer = safeUpgradeVer.format();
+    }
+
+    return safeUpgradeVer;
+  }
+
+  async installPackage(cwd, pkgName, {
+    pkgVer
+  } = {}) {
+    let dummyPkgJson;
+
+    const dummyPkgPath = _path.default.join(cwd, 'package.json');
+
+    try {
+      dummyPkgJson = JSON.parse(await _fs.fs.readFile(dummyPkgPath, 'utf8'));
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        dummyPkgJson = {};
+        await _fs.fs.writeFile(dummyPkgPath, JSON.stringify(dummyPkgJson, null, 2), 'utf8');
+      } else {
+        throw err;
+      }
+    }
+
+    const installOpts = (await (0, _env.hasAppiumDependency)(cwd)) ? ['--save-dev'] : ['--save-dev', '--save-exact', '--global-style', '--no-package-lock'];
+    const res = await this.exec('install', [...installOpts, pkgVer ? `${pkgName}@${pkgVer}` : pkgName], {
+      cwd,
+      json: true,
+      lockFile: this._getInstallLockfilePath(cwd)
+    });
+
+    if (res.json) {
+      if (res.json.error) {
+        throw new Error(res.json.error);
+      }
+    }
+
+    const pkgJsonPath = (0, _resolveFrom.default)(cwd, `${pkgName}/package.json`);
+
+    try {
+      return require(pkgJsonPath);
+    } catch {
+      throw new Error('The package was not downloaded correctly; its package.json ' + 'did not exist or was unreadable. We looked for it at ' + pkgJsonPath);
+    }
+  }
+
+  async uninstallPackage(cwd, pkg) {
+    await this.exec('uninstall', [pkg], {
+      cwd,
+      lockFile: this._getInstallLockfilePath(cwd)
+    });
+  }
+
+}
+
+exports.NPM = NPM;
+const npm = new NPM();
+exports.npm = npm;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/npm.js"],"names":["CACHE_DIR_RELATIVE_PATH","path","join","INSTALL_LOCKFILE_RELATIVE_PATH","NPM","_getInstallLockfilePath","cwd","exec","cmd","args","opts","execOpts","json","lockFile","unshift","push","npmCmd","system","isWindows","runner","acquireLock","util","getLockFileGuard","_runner","ret","stdout","stderr","code","JSON","parse","ign","e","err","Error","trim","getLatestVersion","pkg","latest","getLatestSafeUpgradeVersion","curVersion","allVersions","getLatestSafeUpgradeFromVersions","list","safeUpgradeVer","curSemver","semver","testVer","testSemver","prerelease","length","compare","major","format","installPackage","pkgName","pkgVer","dummyPkgJson","dummyPkgPath","fs","readFile","writeFile","stringify","installOpts","res","error","pkgJsonPath","require","uninstallPackage","npm"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from 'path';\nimport semver from 'semver';\nimport { hasAppiumDependency } from './env';\nimport { exec } from 'teen_process';\nimport { fs } from './fs';\nimport * as util from './util';\nimport * as system from './system';\nimport resolveFrom from 'resolve-from';\n\n\n/**\n * Relative path to directory containing any Appium internal files\n * XXX: this is duplicated in `appium/lib/constants.js`.\n */\nexport const CACHE_DIR_RELATIVE_PATH = path.join(\n  'node_modules',\n  '.cache',\n  'appium',\n);\n\n/**\n * Relative path to lockfile used when installing an extension via `appium`\n */\nexport const INSTALL_LOCKFILE_RELATIVE_PATH = path.join(\n  CACHE_DIR_RELATIVE_PATH,\n  '.install.lock',\n);\n\n/**\n * XXX: This should probably be a singleton, but it isn't.  Maybe this module should just export functions?\n */\nexport class NPM {\n  /**\n   * Returns path to \"install\" lockfile\n   * @private\n   * @param {string} cwd\n   */\n  _getInstallLockfilePath (cwd) {\n    return path.join(cwd, INSTALL_LOCKFILE_RELATIVE_PATH);\n  }\n\n  /**\n   * Execute `npm` with given args.\n   *\n   * If the process exits with a nonzero code, the contents of `STDOUT` and `STDERR` will be in the\n   * `message` of the {@link TeenProcessExecError} rejected.\n   * @param {string} cmd\n   * @param {string[]} args\n   * @param {ExecOpts} opts\n   * @param {ExecOpts} [execOpts]\n   */\n  async exec (cmd, args, opts, execOpts = /** @type {ExecOpts} */({})) {\n    let { cwd, json, lockFile } = opts;\n\n    // make sure we perform the current operation in cwd\n    execOpts = {...execOpts, cwd};\n\n    args.unshift(cmd);\n    if (json) {\n      args.push('--json');\n    }\n    const npmCmd = system.isWindows() ? 'npm.cmd' : 'npm';\n    let runner = async () => await exec(npmCmd, args, execOpts);\n    if (lockFile) {\n      const acquireLock = util.getLockFileGuard(lockFile);\n      const _runner = runner;\n      runner = async () => await acquireLock(_runner);\n    }\n\n    /** @type {import('teen_process').ExecResult<string> & {json?: any}} */\n    let ret;\n    try {\n      const {stdout, stderr, code} = await runner();\n      ret = {stdout, stderr, code};\n      // if possible, parse NPM's json output. During NPM install 3rd-party\n      // packages can write to stdout, so sometimes the json output can't be\n      // guaranteed to be parseable\n      try {\n        ret.json = JSON.parse(stdout);\n      } catch (ign) {}\n    } catch (e) {\n      const {stdout = '', stderr = '', code = null} = /** @type {TeenProcessExecError} */(e);\n      const err = new Error(`npm command '${args.join(' ')}' failed with code ${code}.\\n\\nSTDOUT:\\n${stdout.trim()}\\n\\nSTDERR:\\n${stderr.trim()}`);\n      throw err;\n    }\n    return ret;\n  }\n\n  /**\n   * @param {string} cwd\n   * @param {string} pkg\n   */\n  async getLatestVersion (cwd, pkg) {\n    return (await this.exec('view', [pkg, 'dist-tags'], {\n      json: true,\n      cwd\n    })).json?.latest;\n  }\n\n  /**\n   * @param {string} cwd\n   * @param {string} pkg\n   * @param {string} curVersion\n   */\n  async getLatestSafeUpgradeVersion (cwd, pkg, curVersion) {\n    const allVersions = (await this.exec('view', [pkg, 'versions'], {\n      json: true,\n      cwd\n    })).json;\n    return this.getLatestSafeUpgradeFromVersions(curVersion, allVersions);\n  }\n\n  /**\n   * Runs `npm ls`, optionally for a particular package.\n   * @param {string} cwd\n   * @param {string} [pkg]\n   */\n  async list (cwd, pkg) {\n    return (await this.exec('list', pkg ? [pkg] : [], {cwd, json: true})).json;\n  }\n\n  /**\n   * Given a current version and a list of all versions for a package, return the version which is\n   * the highest safely-upgradable version (meaning not crossing any major revision boundaries, and\n   * not including any alpha/beta/rc versions)\n   *\n   * @param {string} curVersion - the current version of a package\n   * @param {Array<string>} allVersions - a list of version strings\n   *\n   * @return {string|null} - the highest safely-upgradable version, or null if there isn't one\n   */\n  getLatestSafeUpgradeFromVersions (curVersion, allVersions) {\n    let safeUpgradeVer = null;\n    const curSemver = semver.parse(curVersion);\n    if (curSemver === null) {\n      throw new Error(`Could not parse current version '${curVersion}'`);\n    }\n    for (const testVer of allVersions) {\n      const testSemver = semver.parse(testVer);\n      if (testSemver === null) {\n        throw new Error(`Could not parse version to test against: '${testVer}'`);\n      }\n      // if the test version is a prerelease, ignore it\n      if (testSemver.prerelease.length > 0) {\n        continue;\n      }\n      // if the current version is later than the test version, skip this test version\n      if (curSemver.compare(testSemver) === 1) {\n        continue;\n      }\n      // if the test version is newer, but crosses a major revision boundary, also skip it\n      if (testSemver.major > curSemver.major) {\n        continue;\n      }\n      // otherwise this version is safe to upgrade to. But there might be multiple ones of this\n      // kind, so keep iterating and keeping the highest\n      if (safeUpgradeVer === null || testSemver.compare(safeUpgradeVer) === 1) {\n        safeUpgradeVer = testSemver;\n      }\n    }\n    if (safeUpgradeVer) {\n      safeUpgradeVer = safeUpgradeVer.format();\n    }\n    return safeUpgradeVer;\n  }\n\n  /**\n   * Installs a package w/ `npm`\n   * @param {string} cwd\n   * @param {string} pkgName\n   * @param {InstallPackageOpts} [opts]\n   * @returns {Promise<import('type-fest').PackageJson>}\n   */\n  async installPackage (cwd, pkgName, {pkgVer} = {}) {\n    /** @type {any} */\n    let dummyPkgJson;\n    const dummyPkgPath = path.join(cwd, 'package.json');\n    try {\n      dummyPkgJson = JSON.parse(await fs.readFile(dummyPkgPath, 'utf8'));\n    } catch (err) {\n      if (err.code === 'ENOENT') {\n        dummyPkgJson = {};\n        await fs.writeFile(dummyPkgPath, JSON.stringify(dummyPkgJson, null, 2), 'utf8');\n      } else {\n        throw err;\n      }\n    }\n\n    /**\n     * If we've found a `package.json` containined the `appiumCreated` property,\n     * then we can do whatever we please with it, since we created it.  This is\n     * likely when `APPIUM_HOME` is the default (in `~/.appium`).  In that case,\n     * we want `--global-style` to avoid deduping, and we also do not need a\n     * `package-lock.json`.\n     *\n     * If we _haven't_ found such a key, then this `package.json` isn't a\n     * \"dummy\" and is controlled by the user.  So we'll just add it as a dev\n     * dep; whatever else it does is up to the user's npm config.\n     */\n    const installOpts = await hasAppiumDependency(cwd) ?\n      ['--save-dev'] :\n      ['--save-dev', '--save-exact', '--global-style', '--no-package-lock'];\n\n    const res = await this.exec('install', [\n      ...installOpts,\n      pkgVer ? `${pkgName}@${pkgVer}` : pkgName\n    ], {\n      cwd,\n      json: true,\n      lockFile: this._getInstallLockfilePath(cwd)\n    });\n\n    if (res.json) {\n      // we parsed a valid json response, so if we got an error here, return that\n      // message straightaway\n      if (res.json.error) {\n        throw new Error(res.json.error);\n      }\n    }\n\n    // Now read package data from the installed package to return, and make sure\n    // everything got installed ok. Remember, pkgName might end up with a / in it due to an npm\n    // org, so if so, that will get correctly exploded into multiple directories, by path.resolve here\n    // (even on Windows!)\n    const pkgJsonPath = resolveFrom(cwd, `${pkgName}/package.json`);\n    try {\n      return require(pkgJsonPath);\n    } catch {\n      throw new Error('The package was not downloaded correctly; its package.json ' +\n                      'did not exist or was unreadable. We looked for it at ' +\n                      pkgJsonPath);\n    }\n  }\n\n  /**\n   * @param {string} cwd\n   * @param {string} pkg\n   */\n  async uninstallPackage (cwd, pkg) {\n    await this.exec('uninstall', [pkg], {\n      cwd,\n      lockFile: this._getInstallLockfilePath(cwd)\n    });\n  }\n}\n\nexport const npm = new NPM();\n\n/**\n * Options for {@link NPM.installPackage}\n * @typedef InstallPackageOpts\n * @property {string} [pkgVer] - the version of the package to install\n */\n\n/**\n * Options for {@link NPM.exec}\n * @typedef ExecOpts\n * @property {string} cwd - Current working directory\n * @property {boolean} [json] - If `true`, supply `--json` flag to npm and resolve w/ parsed JSON\n * @property {string} [lockFile] - Path to lockfile to use\n */\n\n// THESE TYPES SHOULD BE IN TEEN PROCESS, NOT HERE\n\n/**\n * Extra props `teen_process.exec` adds to its error objects\n * @typedef TeenProcessExecErrorProps\n * @property {string} stdout - STDOUT\n * @property {string} stderr - STDERR\n * @property {number?} code - Exit code\n */\n\n/**\n * Error thrown by `teen_process.exec`\n * @typedef {Error & TeenProcessExecErrorProps} TeenProcessExecError\n */\n"]}

package/build/lib/plist.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Parses a file in xml or binary format of plist
+ * @param {string} plist The plist file path
+ * @param {boolean} mustExist If set to false, this method will return an empty object when the file doesn't exist
+ * @param {boolean} quiet If set to false, the plist path will be logged in debug level
+ * @returns {Promise<any>} parsed plist JS Object
+ */
+export function parsePlistFile(plist: string, mustExist?: boolean, quiet?: boolean): Promise<any>;
+/**
+ * Parses an buffer or a string to a JS object a plist from an object
+ * @param {string|Buffer} data The plist in the form of string or Buffer
+ * @returns {Object} parsed plist JS Object
+ * @throws Will throw an error if the plist type is unknown
+ */
+export function parsePlist(data: string | Buffer): any;
+/**
+ * Creates a plist from an object
+ * @param {Object} object The JS object to be turned into a plist
+ * @param {boolean} binary Set it to true for a binary plist
+ * @returns {string|Buffer} returns a buffer or a string in respect to the binary parameter
+ */
+export function createPlist(object: any, binary?: boolean): string | Buffer;
+/**
+ * Updates a plist file with the given fields
+ * @param {string} plist The plist file path
+ * @param {Object} updatedFields The updated fields-value pairs
+ * @param {boolean} binary If set to false, the file will be created as a xml plist
+ * @param {boolean} mustExist If set to false, this method will update an empty plist
+ * @param {boolean} quiet If set to false, the plist path will be logged in debug level
+ */
+export function updatePlistFile(plist: string, updatedFields: any, binary?: boolean, mustExist?: boolean, quiet?: boolean): Promise<void>;
+/**
+ * Creates a binary plist Buffer from an object
+ * @param {Object} data The object to be turned into a binary plist
+ * @returns {Buffer} plist in the form of a binary buffer
+ */
+export function createBinaryPlist(data: any): Buffer;
+/**
+ * Parses a Buffer into an Object
+ * @param {Buffer} data The beffer of a binary plist
+ */
+export function parseBinaryPlist(data: Buffer): any;
+//# sourceMappingURL=plist.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plist.d.ts","sourceRoot":"","sources":["../../lib/plist.js"],"names":[],"mappings":"AAuBA;;;;;;GAMG;AACH,sCALW,MAAM,cACN,OAAO,UACP,OAAO,GACL,QAAQ,GAAG,CAAC,CAmCxB;AAkFD;;;;;GAKG;AACH,iCAJW,MAAM,GAAC,MAAM,OAgBvB;AAhCD;;;;;GAKG;AACH,kDAHW,OAAO,GACL,MAAM,GAAC,MAAM,CAQzB;AA9ED;;;;;;;GAOG;AACH,uCANW,MAAM,+BAEN,OAAO,cACP,OAAO,UACP,OAAO,iBAmBjB;AACD;;;;GAIG;AACH,8CAFa,MAAM,CAIlB;AAED;;;GAGG;AACH,uCAFW,MAAM,OAMhB"}

package/build/lib/plist.js

@@ -156,7 +156,5 @@ function parsePlist(data) {
   }
 
   throw new Error(`Unknown type of plist, data: ${data.toString()}`);
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/plist.js"],"names":["BPLIST_IDENTIFIER","BUFFER","Buffer","from","TEXT","PLIST_IDENTIFIER","parseXmlPlistFile","plistFilename","xmlContent","fs","readFile","xmlplist","parse","parsePlistFile","plist","mustExist","quiet","exists","log","errorAndThrow","debug","obj","type","bplistParse","parseFile","length","Error","ign","err","message","updatePlistFile","updatedFields","binary","_","extend","newPlist","build","writeFile","createBinaryPlist","data","parseBinaryPlist","parseBuffer","getXmlPlist","isString","startsWith","isBuffer","compare","toString","getBinaryPlist","createPlist","object","parsePlist","textPlist","binaryPlist"],"mappings":";;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA,MAAMA,iBAAiB,GAAG;AACxBC,EAAAA,MAAM,EAAEC,MAAM,CAACC,IAAP,CAAY,UAAZ,CADgB;AAExBC,EAAAA,IAAI,EAAE;AAFkB,CAA1B;AAIA,MAAMC,gBAAgB,GAAG;AACvBJ,EAAAA,MAAM,EAAEC,MAAM,CAACC,IAAP,CAAY,GAAZ,CADe;AAEvBC,EAAAA,IAAI,EAAE;AAFiB,CAAzB;;AAMA,eAAeE,iBAAf,CAAkCC,aAAlC,EAAiD;AAC/C,MAAIC,UAAU,GAAG,MAAMC,YAAGC,QAAH,CAAYH,aAAZ,EAA2B,MAA3B,CAAvB;AACA,SAAOI,eAASC,KAAT,CAAeJ,UAAf,CAAP;AACD;;AASD,eAAeK,cAAf,CAA+BC,KAA/B,EAAsCC,SAAS,GAAG,IAAlD,EAAwDC,KAAK,GAAG,IAAhE,EAAsE;AAEpE,MAAI,EAAC,MAAMP,YAAGQ,MAAH,CAAUH,KAAV,CAAP,CAAJ,EAA6B;AAC3B,QAAIC,SAAJ,EAAe;AACbG,sBAAIC,aAAJ,CAAmB,8BAA6BL,KAAM,GAAtD;AACD,KAFD,MAEO;AACLI,sBAAIE,KAAJ,CAAW,eAAcN,KAAM,6CAA/B;;AACA,aAAO,EAAP;AACD;AACF;;AAED,MAAIO,GAAG,GAAG,EAAV;AACA,MAAIC,IAAI,GAAG,QAAX;;AACA,MAAI;AACFD,IAAAA,GAAG,GAAG,MAAME,sBAAYC,SAAZ,CAAsBV,KAAtB,CAAZ;;AACA,QAAIO,GAAG,CAACI,MAAR,EAAgB;AACdJ,MAAAA,GAAG,GAAGA,GAAG,CAAC,CAAD,CAAT;AACD,KAFD,MAEO;AACL,YAAM,IAAIK,KAAJ,CAAW,gBAAeZ,KAAM,wBAAhC,CAAN;AACD;AACF,GAPD,CAOE,OAAOa,GAAP,EAAY;AACZ,QAAI;AACFN,MAAAA,GAAG,GAAG,MAAMf,iBAAiB,CAACQ,KAAD,CAA7B;AACAQ,MAAAA,IAAI,GAAG,KAAP;AACD,KAHD,CAGE,OAAOM,GAAP,EAAY;AACZV,sBAAIC,aAAJ,CAAmB,+BAA8BL,KAAM,aAAYc,GAAG,CAACC,OAAQ,EAA/E;AACD;AACF;;AAED,MAAI,CAACb,KAAL,EAAY;AACVE,oBAAIE,KAAJ,CAAW,sBAAqBN,KAAM,QAAOQ,IAAK,EAAlD;AACD;;AACD,SAAOD,GAAP;AACD;;AAUD,eAAeS,eAAf,CAAgChB,KAAhC,EAAuCiB,aAAvC,EAAsDC,MAAM,GAAG,IAA/D,EAAqEjB,SAAS,GAAG,IAAjF,EAAuFC,KAAK,GAAG,IAA/F,EAAqG;AACnG,MAAIK,GAAJ;;AACA,MAAI;AACFA,IAAAA,GAAG,GAAG,MAAMR,cAAc,CAACC,KAAD,EAAQC,SAAR,CAA1B;AACD,GAFD,CAEE,OAAOa,GAAP,EAAY;AACZV,oBAAIC,aAAJ,CAAmB,2BAA0BS,GAAG,CAACC,OAAQ,EAAzD;AACD;;AACDI,kBAAEC,MAAF,CAASb,GAAT,EAAcU,aAAd;;AACA,MAAII,QAAQ,GAAGH,MAAM,GAAG,4BAAaX,GAAb,CAAH,GAAuBV,eAASyB,KAAT,CAAef,GAAf,CAA5C;;AACA,MAAI;AACF,UAAMZ,YAAG4B,SAAH,CAAavB,KAAb,EAAoBqB,QAApB,CAAN;AACD,GAFD,CAEE,OAAOP,GAAP,EAAY;AACZV,oBAAIC,aAAJ,CAAmB,yBAAwBS,GAAG,CAACC,OAAQ,EAAvD;AACD;;AACD,MAAI,CAACb,KAAL,EAAY;AACVE,oBAAIE,KAAJ,CAAW,qBAAoBN,KAAM,GAArC;AACD;AACF;;AAMD,SAASwB,iBAAT,CAA4BC,IAA5B,EAAkC;AAChC,SAAO,4BAAaA,IAAb,CAAP;AACD;;AAMD,SAASC,gBAAT,CAA2BD,IAA3B,EAAiC;AAC/B,SAAOhB,sBAAYkB,WAAZ,CAAwBF,IAAxB,CAAP;AACD;;AAED,SAASG,WAAT,CAAsBH,IAAtB,EAA4B;AAC1B,MAAIN,gBAAEU,QAAF,CAAWJ,IAAX,KAAoBA,IAAI,CAACK,UAAL,CAAgBvC,gBAAgB,CAACD,IAAjC,CAAxB,EAAgE;AAC9D,WAAOmC,IAAP;AACD;;AACD,MAAIN,gBAAEY,QAAF,CAAWN,IAAX,KAAoBlC,gBAAgB,CAACJ,MAAjB,CAAwB6C,OAAxB,CAAgCP,IAAhC,EAAsC,CAAtC,EAAyClC,gBAAgB,CAACJ,MAAjB,CAAwBwB,MAAjE,MAA6E,CAArG,EAAwG;AACtG,WAAOc,IAAI,CAACQ,QAAL,EAAP;AACD;;AACD,SAAO,IAAP;AACD;;AAED,SAASC,cAAT,CAAyBT,IAAzB,EAA+B;AAC7B,MAAIN,gBAAEU,QAAF,CAAWJ,IAAX,KAAoBA,IAAI,CAACK,UAAL,CAAgB5C,iBAAiB,CAACI,IAAlC,CAAxB,EAAiE;AAC/D,WAAOF,MAAM,CAACC,IAAP,CAAYoC,IAAZ,CAAP;AACD;;AAED,MAAIN,gBAAEY,QAAF,CAAWN,IAAX,KAAoBvC,iBAAiB,CAACC,MAAlB,CAAyB6C,OAAzB,CAAiCP,IAAjC,EAAuC,CAAvC,EAA0CvC,iBAAiB,CAACC,MAAlB,CAAyBwB,MAAnE,MAA+E,CAAvG,EAA0G;AACxG,WAAOc,IAAP;AACD;;AACD,SAAO,IAAP;AACD;;AAQD,SAASU,WAAT,CAAsBC,MAAtB,EAA8BlB,MAAM,GAAG,KAAvC,EAA8C;AAC5C,MAAIA,MAAJ,EAAY;AACV,WAAOM,iBAAiB,CAACY,MAAD,CAAxB;AACD,GAFD,MAEO;AACL,WAAOvC,eAASyB,KAAT,CAAec,MAAf,CAAP;AACD;AACF;;AAQD,SAASC,UAAT,CAAqBZ,IAArB,EAA2B;AACzB,MAAIa,SAAS,GAAGV,WAAW,CAACH,IAAD,CAA3B;;AACA,MAAIa,SAAJ,EAAe;AACb,WAAOzC,eAASC,KAAT,CAAewC,SAAf,CAAP;AACD;;AAED,MAAIC,WAAW,GAAGL,cAAc,CAACT,IAAD,CAAhC;;AACA,MAAIc,WAAJ,EAAiB;AACf,WAAOb,gBAAgB,CAACa,WAAD,CAAhB,CAA8B,CAA9B,CAAP;AACD;;AAED,QAAM,IAAI3B,KAAJ,CAAW,gCAA+Ba,IAAI,CAACQ,QAAL,EAAgB,EAA1D,CAAN;AACD","sourcesContent":["import xmlplist from 'plist';\nimport bplistCreate from 'bplist-creator';\nimport bplistParse from 'bplist-parser';\nimport fs from './fs';\nimport log from './logger';\nimport _ from 'lodash';\n\n\nconst BPLIST_IDENTIFIER = {\n  BUFFER: Buffer.from('bplist00'),\n  TEXT: 'bplist00'\n};\nconst PLIST_IDENTIFIER = {\n  BUFFER: Buffer.from('<'),\n  TEXT: '<'\n};\n\n// XML Plist library helper\nasync function parseXmlPlistFile (plistFilename) {\n  let xmlContent = await fs.readFile(plistFilename, 'utf8');\n  return xmlplist.parse(xmlContent);\n}\n\n/**\n * Parses a file in xml or binary format of plist\n * @param {string} plist The plist file path\n * @param {boolean} mustExist If set to false, this method will return an empty object when the file doesn't exist\n * @param {boolean} quiet If set to false, the plist path will be logged in debug level\n * @returns {Object} parsed plist JS Object\n */\nasync function parsePlistFile (plist, mustExist = true, quiet = true) {\n  // handle nonexistant file\n  if (!await fs.exists(plist)) {\n    if (mustExist) {\n      log.errorAndThrow(`Plist file doesn't exist: '${plist}'`);\n    } else {\n      log.debug(`Plist file '${plist}' does not exist. Returning an empty plist.`);\n      return {};\n    }\n  }\n\n  let obj = {};\n  let type = 'binary';\n  try {\n    obj = await bplistParse.parseFile(plist);\n    if (obj.length) {\n      obj = obj[0];\n    } else {\n      throw new Error(`Binary file '${plist}'' appears to be empty`);\n    }\n  } catch (ign) {\n    try {\n      obj = await parseXmlPlistFile(plist);\n      type = 'xml';\n    } catch (err) {\n      log.errorAndThrow(`Could not parse plist file '${plist}' as XML: ${err.message}`);\n    }\n  }\n\n  if (!quiet) {\n    log.debug(`Parsed plist file '${plist}' as ${type}`);\n  }\n  return obj;\n}\n\n/**\n * Updates a plist file with the given fields\n * @param {string} plist The plist file path\n * @param {Object} updatedFields The updated fields-value pairs\n * @param {boolean} binary If set to false, the file will be created as a xml plist\n * @param {boolean} mustExist If set to false, this method will update an empty plist\n * @param {boolean} quiet If set to false, the plist path will be logged in debug level\n */\nasync function updatePlistFile (plist, updatedFields, binary = true, mustExist = true, quiet = true) {\n  let obj;\n  try {\n    obj = await parsePlistFile(plist, mustExist);\n  } catch (err) {\n    log.errorAndThrow(`Could not update plist: ${err.message}`);\n  }\n  _.extend(obj, updatedFields);\n  let newPlist = binary ? bplistCreate(obj) : xmlplist.build(obj);\n  try {\n    await fs.writeFile(plist, newPlist);\n  } catch (err) {\n    log.errorAndThrow(`Could not save plist: ${err.message}`);\n  }\n  if (!quiet) {\n    log.debug(`Wrote plist file '${plist}'`);\n  }\n}\n/**\n * Creates a binary plist Buffer from an object\n * @param {Object} data The object to be turned into a binary plist\n * @returns {Buffer} plist in the form of a binary buffer\n */\nfunction createBinaryPlist (data) {\n  return bplistCreate(data);\n}\n\n/**\n * Parses a Buffer into an Object\n * @param {Buffer} data The beffer of a binary plist\n */\nfunction parseBinaryPlist (data) {\n  return bplistParse.parseBuffer(data);\n}\n\nfunction getXmlPlist (data) {\n  if (_.isString(data) && data.startsWith(PLIST_IDENTIFIER.TEXT)) {\n    return data;\n  }\n  if (_.isBuffer(data) && PLIST_IDENTIFIER.BUFFER.compare(data, 0, PLIST_IDENTIFIER.BUFFER.length) === 0) {\n    return data.toString();\n  }\n  return null;\n}\n\nfunction getBinaryPlist (data) {\n  if (_.isString(data) && data.startsWith(BPLIST_IDENTIFIER.TEXT)) {\n    return Buffer.from(data);\n  }\n\n  if (_.isBuffer(data) && BPLIST_IDENTIFIER.BUFFER.compare(data, 0, BPLIST_IDENTIFIER.BUFFER.length) === 0) {\n    return data;\n  }\n  return null;\n}\n\n/**\n * Creates a plist from an object\n * @param {Object} object The JS object to be turned into a plist\n * @param {boolean} binary Set it to true for a binary plist\n * @returns {string|Buffer} returns a buffer or a string in respect to the binary parameter\n */\nfunction createPlist (object, binary = false) {\n  if (binary) {\n    return createBinaryPlist(object);\n  } else {\n    return xmlplist.build(object);\n  }\n}\n\n/**\n * Parses an buffer or a string to a JS object a plist from an object\n * @param {string|Buffer} data The plist in the form of string or Buffer\n * @returns {Object} parsed plist JS Object\n * @throws Will throw an error if the plist type is unknown\n */\nfunction parsePlist (data) {\n  let textPlist = getXmlPlist(data);\n  if (textPlist) {\n    return xmlplist.parse(textPlist);\n  }\n\n  let binaryPlist = getBinaryPlist(data);\n  if (binaryPlist) {\n    return parseBinaryPlist(binaryPlist)[0];\n  }\n\n  throw new Error(`Unknown type of plist, data: ${data.toString()}`);\n}\n\nexport { parsePlistFile, parsePlist, createPlist, updatePlistFile, createBinaryPlist, parseBinaryPlist };\n"],"file":"lib/plist.js","sourceRoot":"../.."}
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/plist.js"],"names":["BPLIST_IDENTIFIER","BUFFER","Buffer","from","TEXT","PLIST_IDENTIFIER","parseXmlPlistFile","plistFilename","xmlContent","fs","readFile","xmlplist","parse","parsePlistFile","plist","mustExist","quiet","exists","log","errorAndThrow","debug","obj","type","bplistParse","parseFile","length","Error","ign","err","message","updatePlistFile","updatedFields","binary","_","extend","newPlist","build","writeFile","createBinaryPlist","data","parseBinaryPlist","parseBuffer","getXmlPlist","isString","startsWith","isBuffer","compare","toString","getBinaryPlist","createPlist","object","parsePlist","textPlist","binaryPlist"],"mappings":"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","sourcesContent":["import xmlplist from 'plist';\nimport bplistCreate from 'bplist-creator';\nimport bplistParse from 'bplist-parser';\nimport fs from './fs';\nimport log from './logger';\nimport _ from 'lodash';\n\n\nconst BPLIST_IDENTIFIER = {\n  BUFFER: Buffer.from('bplist00'),\n  TEXT: 'bplist00'\n};\nconst PLIST_IDENTIFIER = {\n  BUFFER: Buffer.from('<'),\n  TEXT: '<'\n};\n\n// XML Plist library helper\nasync function parseXmlPlistFile (plistFilename) {\n  let xmlContent = await fs.readFile(plistFilename, 'utf8');\n  return xmlplist.parse(xmlContent);\n}\n\n/**\n * Parses a file in xml or binary format of plist\n * @param {string} plist The plist file path\n * @param {boolean} mustExist If set to false, this method will return an empty object when the file doesn't exist\n * @param {boolean} quiet If set to false, the plist path will be logged in debug level\n * @returns {Promise<any>} parsed plist JS Object\n */\nasync function parsePlistFile (plist, mustExist = true, quiet = true) {\n  // handle nonexistant file\n  if (!await fs.exists(plist)) {\n    if (mustExist) {\n      log.errorAndThrow(`Plist file doesn't exist: '${plist}'`);\n    } else {\n      log.debug(`Plist file '${plist}' does not exist. Returning an empty plist.`);\n      return {};\n    }\n  }\n\n  let obj = {};\n  let type = 'binary';\n  try {\n    obj = await bplistParse.parseFile(plist);\n    if (obj.length) {\n      obj = obj[0];\n    } else {\n      throw new Error(`Binary file '${plist}'' appears to be empty`);\n    }\n  } catch (ign) {\n    try {\n      obj = await parseXmlPlistFile(plist);\n      type = 'xml';\n    } catch (err) {\n      log.errorAndThrow(`Could not parse plist file '${plist}' as XML: ${err.message}`);\n    }\n  }\n\n  if (!quiet) {\n    log.debug(`Parsed plist file '${plist}' as ${type}`);\n  }\n  return obj;\n}\n\n/**\n * Updates a plist file with the given fields\n * @param {string} plist The plist file path\n * @param {Object} updatedFields The updated fields-value pairs\n * @param {boolean} binary If set to false, the file will be created as a xml plist\n * @param {boolean} mustExist If set to false, this method will update an empty plist\n * @param {boolean} quiet If set to false, the plist path will be logged in debug level\n */\nasync function updatePlistFile (plist, updatedFields, binary = true, mustExist = true, quiet = true) {\n  let obj;\n  try {\n    obj = await parsePlistFile(plist, mustExist);\n  } catch (err) {\n    log.errorAndThrow(`Could not update plist: ${err.message}`);\n  }\n  _.extend(obj, updatedFields);\n  let newPlist = binary ? bplistCreate(obj) : xmlplist.build(obj);\n  try {\n    await fs.writeFile(plist, newPlist);\n  } catch (err) {\n    log.errorAndThrow(`Could not save plist: ${err.message}`);\n  }\n  if (!quiet) {\n    log.debug(`Wrote plist file '${plist}'`);\n  }\n}\n/**\n * Creates a binary plist Buffer from an object\n * @param {Object} data The object to be turned into a binary plist\n * @returns {Buffer} plist in the form of a binary buffer\n */\nfunction createBinaryPlist (data) {\n  return bplistCreate(data);\n}\n\n/**\n * Parses a Buffer into an Object\n * @param {Buffer} data The beffer of a binary plist\n */\nfunction parseBinaryPlist (data) {\n  // this function exists, but is not in the type declarations.\n  // @ts-expect-error\n  return bplistParse.parseBuffer(data);\n}\n\nfunction getXmlPlist (data) {\n  if (_.isString(data) && data.startsWith(PLIST_IDENTIFIER.TEXT)) {\n    return data;\n  }\n  if (_.isBuffer(data) && PLIST_IDENTIFIER.BUFFER.compare(data, 0, PLIST_IDENTIFIER.BUFFER.length) === 0) {\n    return data.toString();\n  }\n  return null;\n}\n\nfunction getBinaryPlist (data) {\n  if (_.isString(data) && data.startsWith(BPLIST_IDENTIFIER.TEXT)) {\n    return Buffer.from(data);\n  }\n\n  if (_.isBuffer(data) && BPLIST_IDENTIFIER.BUFFER.compare(data, 0, BPLIST_IDENTIFIER.BUFFER.length) === 0) {\n    return data;\n  }\n  return null;\n}\n\n/**\n * Creates a plist from an object\n * @param {Object} object The JS object to be turned into a plist\n * @param {boolean} binary Set it to true for a binary plist\n * @returns {string|Buffer} returns a buffer or a string in respect to the binary parameter\n */\nfunction createPlist (object, binary = false) {\n  if (binary) {\n    return createBinaryPlist(object);\n  } else {\n    return xmlplist.build(object);\n  }\n}\n\n/**\n * Parses an buffer or a string to a JS object a plist from an object\n * @param {string|Buffer} data The plist in the form of string or Buffer\n * @returns {Object} parsed plist JS Object\n * @throws Will throw an error if the plist type is unknown\n */\nfunction parsePlist (data) {\n  let textPlist = getXmlPlist(data);\n  if (textPlist) {\n    return xmlplist.parse(textPlist);\n  }\n\n  let binaryPlist = getBinaryPlist(data);\n  if (binaryPlist) {\n    return parseBinaryPlist(binaryPlist)[0];\n  }\n\n  throw new Error(`Unknown type of plist, data: ${data.toString()}`);\n}\n\nexport { parsePlistFile, parsePlist, createPlist, updatePlistFile, createBinaryPlist, parseBinaryPlist };\n"]}

package/build/lib/process.d.ts

@@ -0,0 +1,3 @@
+export function getProcessIds(appName: any): Promise<any[]>;
+export function killProcess(appName: any, force?: boolean): Promise<void>;
+//# sourceMappingURL=process.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../lib/process.js"],"names":[],"mappings":"AAWA,4DAYC;AAED,0EAgBC"}

package/build/lib/process.js

@@ -45,7 +45,5 @@ async function killProcess(appName, force = false) {
       throw new Error(`Error killing app '${appName}' with pkill: ${err.message}`);
     }
   }
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/system.d.ts

@@ -0,0 +1,7 @@
+export function isWindows(): boolean;
+export function isMac(): boolean;
+export function isLinux(): boolean;
+export function isOSWin64(): boolean;
+export function arch(): Promise<"32" | "64" | undefined>;
+export function macOsxVersion(): Promise<string>;
+//# sourceMappingURL=system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../lib/system.js"],"names":[],"mappings":"AAMA,qCAEC;AAED,iCAEC;AAED,mCAEC;AAED,qCAEC;AAED,yDAQC;AAED,iDAaC"}

package/build/lib/system.js

@@ -66,7 +66,5 @@ async function macOsxVersion() {
   }
 
   return versionMatch[1];
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/tempdir.d.ts

@@ -0,0 +1,63 @@
+export type Affixes = {
+    /**
+     * - prefix of the temp directory name
+     */
+    prefix?: string | undefined;
+    /**
+     * - suffix of the temp directory name
+     */
+    suffix?: string | undefined;
+};
+export type OpenedAffixes = {
+    /**
+     * - The path to file
+     */
+    path: string;
+    /**
+     * - The file descriptor opened
+     */
+    fd: number;
+};
+/**
+ * @typedef OpenedAffixes
+ * @property {string} path - The path to file
+ * @property {number} fd - The file descriptor opened
+ */
+/**
+ * Generate a temporary directory in os.tempdir() or process.env.APPIUM_TMP_DIR
+ * with arbitrary prefix/suffix for the directory name and return it as open.
+ *
+ * @param {Affixes} affixes
+ * @returns {Promise<OpenedAffixes>}
+ */
+export function open(affixes: Affixes): Promise<OpenedAffixes>;
+/**
+ * @typedef Affixes
+ * @property {string} [prefix] - prefix of the temp directory name
+ * @property {string} [suffix] - suffix of the temp directory name
+ */
+/**
+ * Generate a temporary directory in os.tempdir() or process.env.APPIUM_TMP_DIR
+ * with arbitrary prefix/suffix for the directory name.
+ *
+ * @param {string|Affixes} rawAffixes
+ * @param {string} [defaultPrefix]
+ * @returns {Promise<string>}  A path to the temporary directory with rawAffixes and defaultPrefix
+ */
+export function path(rawAffixes: string | Affixes, defaultPrefix?: string | undefined): Promise<string>;
+/**
+ * Generate a temporary directory in os.tempdir() or process.env.APPIUM_TMP_DIR.
+ * e.g.
+ * - No `process.env.APPIUM_TMP_DIR`: `/var/folders/34/2222sh8n27d6rcp7jqlkw8km0000gn/T/xxxxxxxx.yyyy`
+ * - With `process.env.APPIUM_TMP_DIR = '/path/to/root'`: `/path/to/root/xxxxxxxx.yyyy`
+ *
+ * @returns {Promise<string>} A path to the temporary directory
+ */
+export function openDir(): Promise<string>;
+/**
+ * Returns a path to a temporary directory whcih is defined as static in the same process
+ *
+ * @returns {Promise<string>} A temp directory path whcih is defined as static in the same process
+ */
+export function staticDir(): Promise<string>;
+//# sourceMappingURL=tempdir.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tempdir.d.ts","sourceRoot":"","sources":["../../lib/tempdir.js"],"names":[],"mappings":";;;;;;;;;;;;;;UAyDc,MAAM;;;;QACN,MAAM;;AAHpB;;;;GAIG;AAEH;;;;;;GAMG;AACH,8BAHW,OAAO,GACL,QAAQ,aAAa,CAAC,CAWlC;AA3CD;;;;GAIG;AAEH;;;;;;;GAOG;AACH,iCAJW,MAAM,GAAC,OAAO,uCAEZ,QAAQ,MAAM,CAAC,CAO3B;AA5CD;;;;;;;GAOG;AACH,2BAFa,QAAQ,MAAM,CAAC,CAiB3B;AAoFD;;;;GAIG;AACH,6BAFa,QAAQ,MAAM,CAAC,CAI3B"}

package/build/lib/tempdir.js

@@ -50,15 +50,12 @@ async function open(affixes) {
       fd
     };
   } catch (err) {
-    _logger.default.errorAndThrow(err);
+    return _logger.default.errorAndThrow(err);
   }
 }
 
 function parseAffixes(rawAffixes, defaultPrefix) {
-  let affixes = {
-    prefix: null,
-    suffix: null
-  };
+  let affixes = {};
 
   if (rawAffixes) {
     switch (typeof rawAffixes) {
@@ -87,7 +84,5 @@ exports.openDir = openDir;
 
 async function staticDir() {
   return _static;
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/timing.d.ts

@@ -0,0 +1,46 @@
+export default Timer;
+export class Timer {
+    _startTime: bigint | [number, number] | null;
+    get startTime(): bigint | [number, number] | null;
+    /**
+     * Start the timer
+     *
+     * @return {Timer} The current instance, for chaining
+     */
+    start(): Timer;
+    /**
+     * Get the duration since the timer was started
+     *
+     * @return {Duration} the duration
+     */
+    getDuration(): Duration;
+    toString(): string;
+}
+/**
+ * Class representing a duration, encapsulating the number and units.
+ */
+export class Duration {
+    constructor(nanos: any);
+    _nanos: any;
+    get nanos(): any;
+    /**
+     * Get the duration as nanoseconds
+     *
+     * @returns {number} The duration as nanoseconds
+     */
+    get asNanoSeconds(): number;
+    /**
+     * Get the duration converted into milliseconds
+     *
+     * @returns {number} The duration as milliseconds
+     */
+    get asMilliSeconds(): number;
+    /**
+     * Get the duration converted into seconds
+     *
+     * @returns {number} The duration fas seconds
+     */
+    get asSeconds(): number;
+    toString(): string;
+}
+//# sourceMappingURL=timing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../../lib/timing.js"],"names":[],"mappings":";AAoDA;IAKI,6CAAsB;IAGxB,kDAEC;IAED;;;;OAIG;IACH,SAFY,KAAK,CAWhB;IAED;;;;OAIG;IACH,eAFY,QAAQ,CAsBnB;IAED,mBAMC;CACF;AA3GD;;GAEG;AACH;IACE,wBAEC;IADC,YAAmB;IAGrB,iBAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,6BAEC;IAED;;;;OAIG;IACH,wBAEC;IAED,mBAGC;CACF"}