@appium/support 2.61.1 → 3.0.1

package/build/lib/util.js

@@ -1,90 +1,26 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.W3C_WEB_ELEMENT_IDENTIFIER = exports.MiB = exports.KiB = exports.GiB = void 0;
-exports.cancellableDelay = cancellableDelay;
-exports.coerceVersion = coerceVersion;
-exports.compareVersions = compareVersions;
-exports.escapeSpace = escapeSpace;
-exports.escapeSpecialChars = escapeSpecialChars;
-exports.filterObject = filterObject;
-exports.getLockFileGuard = getLockFileGuard;
-exports.hasContent = hasContent;
-exports.hasValue = hasValue;
-exports.isSameDestination = isSameDestination;
-exports.isSubPath = isSubPath;
-exports.jsonStringify = jsonStringify;
-exports.localIp = localIp;
-exports.multiResolve = multiResolve;
-exports.pluralize = pluralize;
-exports.quote = quote;
-exports.safeJsonParse = safeJsonParse;
-Object.defineProperty(exports, "shellParse", {
-  enumerable: true,
-  get: function () {
-    return _shellQuote.parse;
-  }
-});
-exports.toInMemoryBase64 = toInMemoryBase64;
-exports.toReadableSizeString = toReadableSizeString;
-exports.unleakString = unleakString;
-exports.unwrapElement = unwrapElement;
-Object.defineProperty(exports, "uuidV1", {
-  enumerable: true,
-  get: function () {
-    return _uuid.v1;
-  }
-});
-Object.defineProperty(exports, "uuidV3", {
-  enumerable: true,
-  get: function () {
-    return _uuid.v3;
-  }
-});
-Object.defineProperty(exports, "uuidV4", {
-  enumerable: true,
-  get: function () {
-    return _uuid.v4;
-  }
-});
-Object.defineProperty(exports, "uuidV5", {
-  enumerable: true,
-  get: function () {
-    return _uuid.v5;
-  }
-});
-exports.wrapElement = wrapElement;
-
-require("source-map-support/register");
-
-var _bluebird = _interopRequireDefault(require("bluebird"));
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _os = _interopRequireDefault(require("os"));
-
-var _path = _interopRequireDefault(require("path"));
-
-var _fs = _interopRequireDefault(require("./fs"));
-
-var _semver = _interopRequireDefault(require("semver"));
-
-var _shellQuote = require("shell-quote");
-
-var _pluralize = _interopRequireDefault(require("pluralize"));
-
-var _stream = _interopRequireDefault(require("stream"));
-
-var _base64Stream = require("base64-stream");
-
-var _uuid = require("uuid");
-
-var _lockfile2 = _interopRequireDefault(require("lockfile"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLockFileGuard = exports.shellParse = exports.uuidV5 = exports.uuidV4 = exports.uuidV3 = exports.uuidV1 = exports.toInMemoryBase64 = exports.KiB = exports.MiB = exports.GiB = exports.pluralize = exports.jsonStringify = exports.unleakString = exports.quote = exports.coerceVersion = exports.compareVersions = exports.isSameDestination = exports.W3C_WEB_ELEMENT_IDENTIFIER = exports.isSubPath = exports.toReadableSizeString = exports.filterObject = exports.unwrapElement = exports.wrapElement = exports.safeJsonParse = exports.multiResolve = exports.cancellableDelay = exports.localIp = exports.escapeSpecialChars = exports.escapeSpace = exports.hasValue = exports.hasContent = void 0;
+const bluebird_1 = __importDefault(require("bluebird"));
+const lodash_1 = __importDefault(require("lodash"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("./fs"));
+const semver_1 = __importDefault(require("semver"));
+const shell_quote_1 = require("shell-quote");
+Object.defineProperty(exports, "shellParse", { enumerable: true, get: function () { return shell_quote_1.parse; } });
+const pluralize_1 = __importDefault(require("pluralize"));
+const stream_1 = __importDefault(require("stream"));
+const base64_stream_1 = require("base64-stream");
+const uuid_1 = require("uuid");
+Object.defineProperty(exports, "uuidV1", { enumerable: true, get: function () { return uuid_1.v1; } });
+Object.defineProperty(exports, "uuidV3", { enumerable: true, get: function () { return uuid_1.v3; } });
+Object.defineProperty(exports, "uuidV4", { enumerable: true, get: function () { return uuid_1.v4; } });
+Object.defineProperty(exports, "uuidV5", { enumerable: true, get: function () { return uuid_1.v5; } });
+const lockfile_1 = __importDefault(require("lockfile"));
 const W3C_WEB_ELEMENT_IDENTIFIER = 'element-6066-11e4-a52e-4f735466cecf';
 exports.W3C_WEB_ELEMENT_IDENTIFIER = W3C_WEB_ELEMENT_IDENTIFIER;
 const KiB = 1024;
@@ -93,325 +29,487 @@ const MiB = KiB * 1024;
 exports.MiB = MiB;
 const GiB = MiB * 1024;
 exports.GiB = GiB;
-
+/**
+ * @template {string} T
+ * @param {T} val
+ * @returns {val is NonEmptyString<T>}
+ */
 function hasContent(val) {
-  return _lodash.default.isString(val) && val !== '';
+    return lodash_1.default.isString(val) && val !== '';
 }
-
+exports.hasContent = hasContent;
+/**
+ * return true if the the value is not `undefined`, `null`, or `NaN`.
+ *
+ * XXX: `NaN` is not expressible in TypeScript.
+ * @template T
+ * @param {T} val
+ * @returns {val is NonNullable<T>}
+ */
 function hasValue(val) {
-  if (_lodash.default.isNumber(val)) {
-    return !_lodash.default.isNaN(val);
-  }
-
-  return !_lodash.default.isUndefined(val) && !_lodash.default.isNull(val);
+    // avoid incorrectly evaluating `0` as false
+    if (lodash_1.default.isNumber(val)) {
+        return !lodash_1.default.isNaN(val);
+    }
+    return !lodash_1.default.isUndefined(val) && !lodash_1.default.isNull(val);
 }
-
+exports.hasValue = hasValue;
+// escape spaces in string, for commandline calls
 function escapeSpace(str) {
-  return str.split(/ /).join('\\ ');
+    return str.split(/ /).join('\\ ');
 }
-
+exports.escapeSpace = escapeSpace;
 function escapeSpecialChars(str, quoteEscape) {
-  if (typeof str !== 'string') {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    if (typeof quoteEscape === 'undefined') {
+        quoteEscape = false;
+    }
+    str = str
+        .replace(/[\\]/g, '\\\\')
+        .replace(/[\/]/g, '\\/') // eslint-disable-line no-useless-escape
+        .replace(/[\b]/g, '\\b')
+        .replace(/[\f]/g, '\\f')
+        .replace(/[\n]/g, '\\n')
+        .replace(/[\r]/g, '\\r')
+        .replace(/[\t]/g, '\\t')
+        .replace(/[\"]/g, '\\"') // eslint-disable-line no-useless-escape
+        .replace(/\\'/g, "\\'");
+    if (quoteEscape) {
+        let re = new RegExp(quoteEscape, 'g');
+        str = str.replace(re, `\\${quoteEscape}`);
+    }
     return str;
-  }
-
-  if (typeof quoteEscape === 'undefined') {
-    quoteEscape = false;
-  }
-
-  str = str.replace(/[\\]/g, '\\\\').replace(/[\/]/g, '\\/').replace(/[\b]/g, '\\b').replace(/[\f]/g, '\\f').replace(/[\n]/g, '\\n').replace(/[\r]/g, '\\r').replace(/[\t]/g, '\\t').replace(/[\"]/g, '\\"').replace(/\\'/g, "\\'");
-
-  if (quoteEscape) {
-    let re = new RegExp(quoteEscape, 'g');
-    str = str.replace(re, `\\${quoteEscape}`);
-  }
-
-  return str;
 }
-
+exports.escapeSpecialChars = escapeSpecialChars;
 function localIp() {
-  let ip = _lodash.default.chain(_os.default.networkInterfaces()).values().flatten().filter(function (val) {
-    return val.family === 'IPv4' && val.internal === false;
-  }).map('address').first().value();
-
-  return ip;
+    let ip = lodash_1.default.chain(os_1.default.networkInterfaces())
+        .values()
+        .flatten()
+        // @ts-ignore
+        .filter(function (val) {
+        return val.family === 'IPv4' && val.internal === false;
+    })
+        .map('address')
+        .first()
+        .value();
+    return ip;
 }
-
+exports.localIp = localIp;
+/*
+ * Creates a promise that is cancellable, and will timeout
+ * after `ms` delay
+ */
 function cancellableDelay(ms) {
-  let timer;
-  let resolve;
-  let reject;
-  const delay = new _bluebird.default.Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-    timer = setTimeout(function () {
-      resolve();
-    }, ms);
-  });
-
-  delay.cancel = function () {
-    clearTimeout(timer);
-    reject(new _bluebird.default.CancellationError());
-  };
-
-  return delay;
+    let timer;
+    let resolve;
+    let reject;
+    const delay = new bluebird_1.default.Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+        timer = setTimeout(function () {
+            resolve();
+        }, ms);
+    });
+    // override Bluebird's `cancel`, which does not work when using `await` on
+    // a promise, since `resolve`/`reject` are never called
+    delay.cancel = function () {
+        clearTimeout(timer);
+        reject(new bluebird_1.default.CancellationError());
+    };
+    return delay;
 }
-
+exports.cancellableDelay = cancellableDelay;
 function multiResolve(roots, ...args) {
-  return roots.map(root => _path.default.resolve(root, ...args));
+    return roots.map((root) => path_1.default.resolve(root, ...args));
 }
-
+exports.multiResolve = multiResolve;
+/*
+ * Parses an object if possible. Otherwise returns the object without parsing.
+ */
 function safeJsonParse(obj) {
-  try {
-    return JSON.parse(obj);
-  } catch (ign) {
-    return obj;
-  }
+    try {
+        return JSON.parse(obj);
+    }
+    catch (ign) {
+        // ignore: this is not json parsable
+        return obj;
+    }
 }
-
+exports.safeJsonParse = safeJsonParse;
+/*
+ * Stringifies the object passed in, converting Buffers into Strings for better
+ * display. This mimics JSON.stringify (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)
+ * except the `replacer` argument can only be a function.
+ *
+ * @param {object} obj - the object to be serialized
+ * @param {?function} replacer - function to transform the properties added to the
+ *                               serialized object
+ * @param {?number|string} space - used to insert white space into the output JSON
+ *                                 string for readability purposes. Defaults to 2
+ * returns {string} - the JSON object serialized as a string
+ */
 function jsonStringify(obj, replacer, space = 2) {
-  if (!_lodash.default.isFunction(replacer)) {
-    replacer = (k, v) => v;
-  }
-
-  const bufferToJSON = Buffer.prototype.toJSON;
-  delete Buffer.prototype.toJSON;
-
-  try {
-    return JSON.stringify(obj, (key, value) => {
-      const updatedValue = Buffer.isBuffer(value) ? value.toString('utf8') : value;
-      return replacer(key, updatedValue);
-    }, space);
-  } finally {
-    Buffer.prototype.toJSON = bufferToJSON;
-  }
+    // if no replacer is passed, or it is not a function, just use a pass-through
+    if (!lodash_1.default.isFunction(replacer)) {
+        replacer = (k, v) => v;
+    }
+    // Buffers cannot be serialized in a readable way
+    const bufferToJSON = Buffer.prototype.toJSON;
+    delete Buffer.prototype.toJSON;
+    try {
+        return JSON.stringify(obj, (key, value) => {
+            const updatedValue = Buffer.isBuffer(value) ? value.toString('utf8') : value;
+            return replacer(key, updatedValue);
+        }, space);
+    }
+    finally {
+        // restore the function, so as to not break further serialization
+        Buffer.prototype.toJSON = bufferToJSON;
+    }
 }
-
+exports.jsonStringify = jsonStringify;
+/*
+ * Removes the wrapper from element, if it exists.
+ *   { ELEMENT: 4 } becomes 4
+ *   { element-6066-11e4-a52e-4f735466cecf: 5 } becomes 5
+ */
 function unwrapElement(el) {
-  for (const propName of [W3C_WEB_ELEMENT_IDENTIFIER, 'ELEMENT']) {
-    if (_lodash.default.has(el, propName)) {
-      return el[propName];
+    for (const propName of [W3C_WEB_ELEMENT_IDENTIFIER, 'ELEMENT']) {
+        if (lodash_1.default.has(el, propName)) {
+            return el[propName];
+        }
     }
-  }
-
-  return el;
+    return el;
 }
-
+exports.unwrapElement = unwrapElement;
 function wrapElement(elementId) {
-  return {
-    ELEMENT: elementId,
-    [W3C_WEB_ELEMENT_IDENTIFIER]: elementId
-  };
+    return {
+        ELEMENT: elementId,
+        [W3C_WEB_ELEMENT_IDENTIFIER]: elementId,
+    };
 }
-
+exports.wrapElement = wrapElement;
+/*
+ * Returns object consisting of all properties in the original element
+ * which were truthy given the predicate.
+ * If the predicate is
+ *   * missing - it will remove all properties whose values are `undefined`
+ *   * a scalar - it will test all properties' values against that value
+ *   * a function - it will pass each value and the original object into the function
+ */
 function filterObject(obj, predicate) {
-  let newObj = _lodash.default.clone(obj);
-
-  if (_lodash.default.isUndefined(predicate)) {
-    predicate = v => !_lodash.default.isUndefined(v);
-  } else if (!_lodash.default.isFunction(predicate)) {
-    const valuePredicate = predicate;
-
-    predicate = v => v === valuePredicate;
-  }
-
-  for (const key of Object.keys(obj)) {
-    if (!predicate(obj[key], obj)) {
-      delete newObj[key];
+    let newObj = lodash_1.default.clone(obj);
+    if (lodash_1.default.isUndefined(predicate)) {
+        // remove any element from the object whose value is undefined
+        predicate = (v) => !lodash_1.default.isUndefined(v);
     }
-  }
-
-  return newObj;
+    else if (!lodash_1.default.isFunction(predicate)) {
+        // make predicate into a function
+        const valuePredicate = predicate;
+        predicate = (v) => v === valuePredicate;
+    }
+    for (const key of Object.keys(obj)) {
+        if (!predicate(obj[key], obj)) {
+            delete newObj[key];
+        }
+    }
+    return newObj;
 }
-
+exports.filterObject = filterObject;
+/**
+ * Converts number of bytes to a readable size string.
+ *
+ * @param {number|string} bytes - The actual number of bytes.
+ * @returns {string} The actual string representation, for example
+ *                   '1.00 KB' for '1024 B'
+ * @throws {Error} If bytes count cannot be converted to an integer or
+ *                 if it is less than zero.
+ */
 function toReadableSizeString(bytes) {
-  const intBytes = parseInt(String(bytes), 10);
-
-  if (isNaN(intBytes) || intBytes < 0) {
-    throw new Error(`Cannot convert '${bytes}' to a readable size format`);
-  }
-
-  if (intBytes >= GiB) {
-    return `${(intBytes / (GiB * 1.0)).toFixed(2)} GB`;
-  } else if (intBytes >= MiB) {
-    return `${(intBytes / (MiB * 1.0)).toFixed(2)} MB`;
-  } else if (intBytes >= KiB) {
-    return `${(intBytes / (KiB * 1.0)).toFixed(2)} KB`;
-  }
-
-  return `${intBytes} B`;
+    const intBytes = parseInt(String(bytes), 10);
+    if (isNaN(intBytes) || intBytes < 0) {
+        throw new Error(`Cannot convert '${bytes}' to a readable size format`);
+    }
+    if (intBytes >= GiB) {
+        return `${(intBytes / (GiB * 1.0)).toFixed(2)} GB`;
+    }
+    else if (intBytes >= MiB) {
+        return `${(intBytes / (MiB * 1.0)).toFixed(2)} MB`;
+    }
+    else if (intBytes >= KiB) {
+        return `${(intBytes / (KiB * 1.0)).toFixed(2)} KB`;
+    }
+    return `${intBytes} B`;
 }
-
+exports.toReadableSizeString = toReadableSizeString;
+/**
+ * Checks whether the given path is a subpath of the
+ * particular root folder. Both paths can include .. and . specifiers
+ *
+ * @param {string} originalPath The absolute file/folder path
+ * @param {string} root The absolute root folder path
+ * @param {?boolean} forcePosix Set it to true if paths must be interpreted in POSIX format
+ * @returns {boolean} true if the given original path is the subpath of the root folder
+ * @throws {Error} if any of the given paths is not absolute
+ */
 function isSubPath(originalPath, root, forcePosix = null) {
-  const pathObj = forcePosix ? _path.default.posix : _path.default;
-
-  for (const p of [originalPath, root]) {
-    if (!pathObj.isAbsolute(p)) {
-      throw new Error(`'${p}' is expected to be an absolute path`);
+    const pathObj = forcePosix ? path_1.default.posix : path_1.default;
+    for (const p of [originalPath, root]) {
+        if (!pathObj.isAbsolute(p)) {
+            throw new Error(`'${p}' is expected to be an absolute path`);
+        }
     }
-  }
-
-  const normalizedRoot = pathObj.normalize(root);
-  const normalizedPath = pathObj.normalize(originalPath);
-  return normalizedPath.startsWith(normalizedRoot);
+    const normalizedRoot = pathObj.normalize(root);
+    const normalizedPath = pathObj.normalize(originalPath);
+    return normalizedPath.startsWith(normalizedRoot);
 }
-
+exports.isSubPath = isSubPath;
+/**
+ * Checks whether the given paths are pointing to the same file system
+ * destination.
+ *
+ * @param {string} path1 - Absolute or relative path to a file/folder
+ * @param {string} path2 - Absolute or relative path to a file/folder
+ * @param {...string} pathN - Zero or more absolute or relative paths to files/folders
+ * @returns {Promise<boolean>} true if all paths are pointing to the same file system item
+ */
 async function isSameDestination(path1, path2, ...pathN) {
-  const allPaths = [path1, path2, ...pathN];
-
-  if (!(await _bluebird.default.reduce(allPaths, async (a, b) => a && (await _fs.default.exists(b)), true))) {
-    return false;
-  }
-
-  const areAllItemsEqual = arr => !!arr.reduce((a, b) => a === b ? a : NaN);
-
-  if (areAllItemsEqual(allPaths)) {
-    return true;
-  }
-
-  let mapCb = async x => (await _fs.default.stat(x, {
-    bigint: true
-  })).ino;
-
-  return areAllItemsEqual(await _bluebird.default.map(allPaths, mapCb));
+    const allPaths = [path1, path2, ...pathN];
+    if (!(await bluebird_1.default.reduce(allPaths, async (a, b) => a && (await fs_1.default.exists(b)), true))) {
+        return false;
+    }
+    const areAllItemsEqual = (arr) => !!arr.reduce((a, b) => (a === b ? a : NaN));
+    if (areAllItemsEqual(allPaths)) {
+        return true;
+    }
+    let mapCb = async (x) => (await fs_1.default.stat(x, {
+        bigint: true,
+    })).ino;
+    return areAllItemsEqual(await bluebird_1.default.map(allPaths, mapCb));
 }
-
-function coerceVersion(ver, strict = true) {
-  const result = _semver.default.valid(_semver.default.coerce(`${ver}`));
-
-  if (strict && !result) {
-    throw new Error(`'${ver}' cannot be coerced to a valid version number`);
-  }
-
-  return result;
+exports.isSameDestination = isSameDestination;
+/**
+ * Coerces the given number/string to a valid version string
+ *
+ * @template {boolean} [Strict=true]
+ * @param {string} ver - Version string to coerce
+ * @param {Strict} [strict] - If `true` then an exception will be thrown
+ * if `ver` cannot be coerced
+ * @returns {Strict extends true ? string : string|null} Coerced version number or null if the string cannot be
+ * coerced and strict mode is disabled
+ * @throws {Error} if strict mode is enabled and `ver` cannot be coerced
+ */
+function coerceVersion(ver, strict = /** @type {Strict} */ (true)) {
+    const result = semver_1.default.valid(semver_1.default.coerce(`${ver}`));
+    if (strict && !result) {
+        throw new Error(`'${ver}' cannot be coerced to a valid version number`);
+    }
+    return /** @type {Strict extends true ? string : string?} */ (result);
 }
-
+exports.coerceVersion = coerceVersion;
 const SUPPORTED_OPERATORS = ['==', '!=', '>', '<', '>=', '<=', '='];
-
+/**
+ * Compares two version strings
+ *
+ * @param {string} ver1 - The first version number to compare. Should be a valid
+ * version number supported by semver parser.
+ * @param {string} ver2 - The second version number to compare. Should be a valid
+ * version number supported by semver parser.
+ * @param {string} operator - One of supported version number operators:
+ * ==, !=, >, <, <=, >=, =
+ * @returns {boolean} true or false depending on the actual comparison result
+ * @throws {Error} if an unsupported operator is supplied or any of the supplied
+ * version strings cannot be coerced
+ */
 function compareVersions(ver1, operator, ver2) {
-  if (!SUPPORTED_OPERATORS.includes(operator)) {
-    throw new Error(`The '${operator}' comparison operator is not supported. ` + `Only '${JSON.stringify(SUPPORTED_OPERATORS)}' operators are supported`);
-  }
-
-  const semverOperator = ['==', '!='].includes(operator) ? '=' : operator;
-
-  const result = _semver.default.satisfies(coerceVersion(ver1), `${semverOperator}${coerceVersion(ver2)}`);
-
-  return operator === '!=' ? !result : result;
+    if (!SUPPORTED_OPERATORS.includes(operator)) {
+        throw new Error(`The '${operator}' comparison operator is not supported. ` +
+            `Only '${JSON.stringify(SUPPORTED_OPERATORS)}' operators are supported`);
+    }
+    const semverOperator = ['==', '!='].includes(operator) ? '=' : operator;
+    const result = semver_1.default.satisfies(coerceVersion(ver1), `${semverOperator}${coerceVersion(ver2)}`);
+    return operator === '!=' ? !result : result;
 }
-
+exports.compareVersions = compareVersions;
+/**
+ * Add appropriate quotes to command arguments. See https://github.com/substack/node-shell-quote
+ * for more details
+ *
+ * @param {string|string[]} args - The arguments that will be parsed
+ * @returns {string} - The arguments, quoted
+ */
 function quote(args) {
-  return (0, _shellQuote.quote)(_lodash.default.castArray(args));
+    return (0, shell_quote_1.quote)(lodash_1.default.castArray(args));
 }
-
+exports.quote = quote;
+/**
+ * This function is necessary to workaround unexpected memory leaks
+ * caused by NodeJS string interning
+ * behavior described in https://bugs.chromium.org/p/v8/issues/detail?id=2869
+ *
+ * @param {*} s - The string to unleak
+ * @return {string} Either the unleaked string or the original object converted to string
+ */
 function unleakString(s) {
-  return ` ${s}`.substr(1);
+    return ` ${s}`.substr(1);
 }
-
+exports.unleakString = unleakString;
+/**
+ * @typedef PluralizeOptions
+ * @property {boolean} [inclusive=false] - Whether to prefix with the number (e.g., 3 ducks)
+ */
+/**
+ * Get the form of a word appropriate to the count
+ *
+ * @param {string} word - The word to pluralize
+ * @param {number} count - How many of the word exist
+ * @param {PluralizeOptions|boolean} options - options for word pluralization,
+ *   or a boolean indicating the options.inclusive property
+ * @returns {string} The word pluralized according to the number
+ */
 function pluralize(word, count, options = {}) {
-  let inclusive = false;
-
-  if (_lodash.default.isBoolean(options)) {
-    inclusive = options;
-  } else if (_lodash.default.isBoolean(options === null || options === void 0 ? void 0 : options.inclusive)) {
-    inclusive = options.inclusive;
-  }
-
-  return (0, _pluralize.default)(word, count, inclusive);
+    let inclusive = false;
+    if (lodash_1.default.isBoolean(options)) {
+        // if passed in as a boolean
+        inclusive = options;
+    }
+    else if (lodash_1.default.isBoolean(options?.inclusive)) {
+        // if passed in as an options hash
+        inclusive = options.inclusive;
+    }
+    return (0, pluralize_1.default)(word, count, inclusive);
 }
-
+exports.pluralize = pluralize;
+/**
+ * @typedef EncodingOptions
+ * @property {number} [maxSize=1073741824] The maximum size of
+ * the resulting buffer in bytes. This is set to 1GB by default, because
+ * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap
+ * size must be enough to keep the resulting object (usually this size is
+ * limited to 1.4 GB)
+ */
+/**
+ * Converts contents of a local file to an in-memory base-64 encoded buffer.
+ * The operation is memory-usage friendly and should be used while encoding
+ * large files to base64
+ *
+ * @param {string} srcPath The full path to the file being encoded
+ * @param {EncodingOptions} opts
+ * @returns {Promise<Buffer>} base64-encoded content of the source file as memory buffer
+ * @throws {Error} if there was an error while reading the source file
+ * or the source file is too
+ */
 async function toInMemoryBase64(srcPath, opts = {}) {
-  if (!(await _fs.default.exists(srcPath)) || (await _fs.default.stat(srcPath)).isDirectory()) {
-    throw new Error(`No such file: ${srcPath}`);
-  }
-
-  const {
-    maxSize = 1 * GiB
-  } = opts;
-  const resultBuffers = [];
-  let resultBuffersSize = 0;
-  const resultWriteStream = new _stream.default.Writable({
-    write: (buffer, encoding, next) => {
-      resultBuffers.push(buffer);
-      resultBuffersSize += buffer.length;
-
-      if (maxSize > 0 && resultBuffersSize > maxSize) {
-        resultWriteStream.emit('error', new Error(`The size of the resulting ` + `buffer must not be greater than ${toReadableSizeString(maxSize)}`));
-      }
-
-      next();
+    if (!(await fs_1.default.exists(srcPath)) || (await fs_1.default.stat(srcPath)).isDirectory()) {
+        throw new Error(`No such file: ${srcPath}`);
     }
-  });
-
-  const readerStream = _fs.default.createReadStream(srcPath);
-
-  const base64EncoderStream = new _base64Stream.Base64Encode();
-  const resultWriteStreamPromise = new _bluebird.default((resolve, reject) => {
-    resultWriteStream.once('error', e => {
-      readerStream.unpipe(base64EncoderStream);
-      base64EncoderStream.unpipe(resultWriteStream);
-      readerStream.destroy();
-      reject(e);
+    const { maxSize = 1 * GiB } = opts;
+    const resultBuffers = [];
+    let resultBuffersSize = 0;
+    const resultWriteStream = new stream_1.default.Writable({
+        write: (buffer, encoding, next) => {
+            resultBuffers.push(buffer);
+            resultBuffersSize += buffer.length;
+            if (maxSize > 0 && resultBuffersSize > maxSize) {
+                resultWriteStream.emit('error', new Error(`The size of the resulting ` +
+                    `buffer must not be greater than ${toReadableSizeString(maxSize)}`));
+            }
+            next();
+        },
+    });
+    const readerStream = fs_1.default.createReadStream(srcPath);
+    const base64EncoderStream = new base64_stream_1.Base64Encode();
+    const resultWriteStreamPromise = new bluebird_1.default((resolve, reject) => {
+        resultWriteStream.once('error', (e) => {
+            readerStream.unpipe(base64EncoderStream);
+            base64EncoderStream.unpipe(resultWriteStream);
+            readerStream.destroy();
+            reject(e);
+        });
+        resultWriteStream.once('finish', resolve);
+    });
+    const readStreamPromise = new bluebird_1.default((resolve, reject) => {
+        readerStream.once('close', resolve);
+        readerStream.once('error', (e) => reject(new Error(`Failed to read '${srcPath}': ${e.message}`)));
     });
-    resultWriteStream.once('finish', resolve);
-  });
-  const readStreamPromise = new _bluebird.default((resolve, reject) => {
-    readerStream.once('close', resolve);
-    readerStream.once('error', e => reject(new Error(`Failed to read '${srcPath}': ${e.message}`)));
-  });
-  readerStream.pipe(base64EncoderStream);
-  base64EncoderStream.pipe(resultWriteStream);
-  await _bluebird.default.all([readStreamPromise, resultWriteStreamPromise]);
-  return Buffer.concat(resultBuffers);
+    readerStream.pipe(base64EncoderStream);
+    base64EncoderStream.pipe(resultWriteStream);
+    await bluebird_1.default.all([readStreamPromise, resultWriteStreamPromise]);
+    return Buffer.concat(resultBuffers);
 }
-
+exports.toInMemoryBase64 = toInMemoryBase64;
+/**
+ * @typedef LockFileOptions
+ * @property {number} [timeout=120] The max time in seconds to wait for the lock
+ * @property {boolean} [tryRecovery=false] Whether to try lock recovery if
+ * the first attempt to acquire it timed out.
+ */
+/**
+ * Create an async function which, when called, will not proceed until a certain file is no
+ * longer present on the system. This allows for preventing concurrent behavior across processes
+ * using a known lockfile path.
+ *
+ * @template T
+ * @param {string} lockFile The full path to the file used for the lock
+ * @param {LockFileOptions} opts
+ * @returns async function that takes another async function defining the locked
+ * behavior
+ */
 function getLockFileGuard(lockFile, opts = {}) {
-  const {
-    timeout = 120,
-    tryRecovery = false
-  } = opts;
-
-  const lock = _bluebird.default.promisify(_lockfile2.default.lock);
-
-  const check = _bluebird.default.promisify(_lockfile2.default.check);
-
-  const unlock = _bluebird.default.promisify(_lockfile2.default.unlock);
-
-  const guard = async behavior => {
-    let triedRecovery = false;
-
-    do {
-      try {
-        if (_lockfile2.default.checkSync(lockFile)) {
-          await lock(lockFile, {
-            wait: timeout * 1000
-          });
-        } else {
-          _lockfile2.default.lockSync(lockFile);
+    const { timeout = 120, tryRecovery = false } = opts;
+    const lock = /** @type {(lockfile: string, opts: import('lockfile').Options)=>B<void>} */ (bluebird_1.default.promisify(lockfile_1.default.lock));
+    const check = bluebird_1.default.promisify(lockfile_1.default.check);
+    const unlock = bluebird_1.default.promisify(lockfile_1.default.unlock);
+    /**
+     * @param {(...args: any[]) => T} behavior
+     * @returns {Promise<T>}
+     */
+    const guard = async (behavior) => {
+        let triedRecovery = false;
+        do {
+            try {
+                // if the lockfile doesn't exist, lock it synchronously to make sure no other call
+                // on the same spin of the event loop can also initiate a lock. If the lockfile does exist
+                // then just use the regular async 'lock' method which will wait on the lock.
+                if (lockfile_1.default.checkSync(lockFile)) {
+                    await lock(lockFile, { wait: timeout * 1000 });
+                }
+                else {
+                    lockfile_1.default.lockSync(lockFile);
+                }
+                break;
+            }
+            catch (e) {
+                if (lodash_1.default.includes(e.message, 'EEXIST') && tryRecovery && !triedRecovery) {
+                    // There could be cases where a process has been forcefully terminated
+                    // without a chance to clean up pending locks: https://github.com/npm/lockfile/issues/26
+                    lockfile_1.default.unlockSync(lockFile);
+                    triedRecovery = true;
+                    continue;
+                }
+                throw new Error(`Could not acquire lock on '${lockFile}' after ${timeout}s. ` +
+                    `Original error: ${e.message}`);
+            }
+            // eslint-disable-next-line no-constant-condition
+        } while (true);
+        try {
+            return await behavior();
         }
-
-        break;
-      } catch (e) {
-        if (_lodash.default.includes(e.message, 'EEXIST') && tryRecovery && !triedRecovery) {
-          _lockfile2.default.unlockSync(lockFile);
-
-          triedRecovery = true;
-          continue;
+        finally {
+            // whether the behavior succeeded or not, get rid of the lock
+            await unlock(lockFile);
         }
-
-        throw new Error(`Could not acquire lock on '${lockFile}' after ${timeout}s. ` + `Original error: ${e.message}`);
-      }
-    } while (true);
-
-    try {
-      return await behavior();
-    } finally {
-      await unlock(lockFile);
-    }
-  };
-
-  guard.check = async () => await check(lockFile);
-
-  return guard;
+    };
+    guard.check = async () => await check(lockFile);
+    return guard;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["W3C_WEB_ELEMENT_IDENTIFIER","KiB","MiB","GiB","hasContent","val","_","isString","hasValue","isNumber","isNaN","isUndefined","isNull","escapeSpace","str","split","join","escapeSpecialChars","quoteEscape","replace","re","RegExp","localIp","ip","chain","os","networkInterfaces","values","flatten","filter","family","internal","map","first","value","cancellableDelay","ms","timer","resolve","reject","delay","B","Promise","_resolve","_reject","setTimeout","cancel","clearTimeout","CancellationError","multiResolve","roots","args","root","path","safeJsonParse","obj","JSON","parse","ign","jsonStringify","replacer","space","isFunction","k","v","bufferToJSON","Buffer","prototype","toJSON","stringify","key","updatedValue","isBuffer","toString","unwrapElement","el","propName","has","wrapElement","elementId","ELEMENT","filterObject","predicate","newObj","clone","valuePredicate","Object","keys","toReadableSizeString","bytes","intBytes","parseInt","String","Error","toFixed","isSubPath","originalPath","forcePosix","pathObj","posix","p","isAbsolute","normalizedRoot","normalize","normalizedPath","startsWith","isSameDestination","path1","path2","pathN","allPaths","reduce","a","b","fs","exists","areAllItemsEqual","arr","NaN","mapCb","x","stat","bigint","ino","coerceVersion","ver","strict","result","semver","valid","coerce","SUPPORTED_OPERATORS","compareVersions","ver1","operator","ver2","includes","semverOperator","satisfies","quote","shellQuote","castArray","unleakString","s","substr","pluralize","word","count","options","inclusive","isBoolean","pluralizeLib","toInMemoryBase64","srcPath","opts","isDirectory","maxSize","resultBuffers","resultBuffersSize","resultWriteStream","stream","Writable","write","buffer","encoding","next","push","length","emit","readerStream","createReadStream","base64EncoderStream","Base64Encode","resultWriteStreamPromise","once","e","unpipe","destroy","readStreamPromise","message","pipe","all","concat","getLockFileGuard","lockFile","timeout","tryRecovery","lock","promisify","_lockfile","check","unlock","guard","behavior","triedRecovery","checkSync","wait","lockSync","unlockSync"],"sources":["../../lib/util.js"],"sourcesContent":["import B from 'bluebird';\nimport _ from 'lodash';\nimport os from 'os';\nimport path from 'path';\nimport fs from './fs';\nimport semver from 'semver';\nimport {\n  // https://www.npmjs.com/package/shell-quote\n  quote as shellQuote,\n  parse as shellParse,\n} from 'shell-quote';\nimport pluralizeLib from 'pluralize';\nimport stream from 'stream';\nimport {Base64Encode} from 'base64-stream';\nimport {\n  // https://www.npmjs.com/package/uuid\n  v1 as uuidV1,\n  v3 as uuidV3,\n  v4 as uuidV4,\n  v5 as uuidV5,\n} from 'uuid';\nimport _lockfile from 'lockfile';\n\nconst W3C_WEB_ELEMENT_IDENTIFIER = 'element-6066-11e4-a52e-4f735466cecf';\nconst KiB = 1024;\nconst MiB = KiB * 1024;\nconst GiB = MiB * 1024;\n\n/**\n * @template {string} T\n * @param {T} val\n * @returns {val is NonEmptyString<T>}\n */\nexport function hasContent(val) {\n  return _.isString(val) && val !== '';\n}\n\n/**\n * return true if the the value is not `undefined`, `null`, or `NaN`.\n *\n * XXX: `NaN` is not expressible in TypeScript.\n * @template T\n * @param {T} val\n * @returns {val is NonNullable<T>}\n */\nfunction hasValue(val) {\n  // avoid incorrectly evaluating `0` as false\n  if (_.isNumber(val)) {\n    return !_.isNaN(val);\n  }\n  return !_.isUndefined(val) && !_.isNull(val);\n}\n\n// escape spaces in string, for commandline calls\nfunction escapeSpace(str) {\n  return str.split(/ /).join('\\\\ ');\n}\n\nfunction escapeSpecialChars(str, quoteEscape) {\n  if (typeof str !== 'string') {\n    return str;\n  }\n  if (typeof quoteEscape === 'undefined') {\n    quoteEscape = false;\n  }\n  str = str\n    .replace(/[\\\\]/g, '\\\\\\\\')\n    .replace(/[\\/]/g, '\\\\/') // eslint-disable-line no-useless-escape\n    .replace(/[\\b]/g, '\\\\b')\n    .replace(/[\\f]/g, '\\\\f')\n    .replace(/[\\n]/g, '\\\\n')\n    .replace(/[\\r]/g, '\\\\r')\n    .replace(/[\\t]/g, '\\\\t')\n    .replace(/[\\\"]/g, '\\\\\"') // eslint-disable-line no-useless-escape\n    .replace(/\\\\'/g, \"\\\\'\");\n  if (quoteEscape) {\n    let re = new RegExp(quoteEscape, 'g');\n    str = str.replace(re, `\\\\${quoteEscape}`);\n  }\n  return str;\n}\n\nfunction localIp() {\n  let ip = _.chain(os.networkInterfaces())\n    .values()\n    .flatten()\n    // @ts-ignore\n    .filter(function (val) {\n      return val.family === 'IPv4' && val.internal === false;\n    })\n    .map('address')\n    .first()\n    .value();\n  return ip;\n}\n\n/*\n * Creates a promise that is cancellable, and will timeout\n * after `ms` delay\n */\nfunction cancellableDelay(ms) {\n  let timer;\n  let resolve;\n  let reject;\n\n  const delay = new B.Promise((_resolve, _reject) => {\n    resolve = _resolve;\n    reject = _reject;\n    timer = setTimeout(function () {\n      resolve();\n    }, ms);\n  });\n\n  // override Bluebird's `cancel`, which does not work when using `await` on\n  // a promise, since `resolve`/`reject` are never called\n  delay.cancel = function () {\n    clearTimeout(timer);\n    reject(new B.CancellationError());\n  };\n  return delay;\n}\n\nfunction multiResolve(roots, ...args) {\n  return roots.map((root) => path.resolve(root, ...args));\n}\n\n/*\n * Parses an object if possible. Otherwise returns the object without parsing.\n */\nfunction safeJsonParse(obj) {\n  try {\n    return JSON.parse(obj);\n  } catch (ign) {\n    // ignore: this is not json parsable\n    return obj;\n  }\n}\n\n/*\n * Stringifies the object passed in, converting Buffers into Strings for better\n * display. This mimics JSON.stringify (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)\n * except the `replacer` argument can only be a function.\n *\n * @param {object} obj - the object to be serialized\n * @param {?function} replacer - function to transform the properties added to the\n *                               serialized object\n * @param {?number|string} space - used to insert white space into the output JSON\n *                                 string for readability purposes. Defaults to 2\n * returns {string} - the JSON object serialized as a string\n */\nfunction jsonStringify(obj, replacer, space = 2) {\n  // if no replacer is passed, or it is not a function, just use a pass-through\n  if (!_.isFunction(replacer)) {\n    replacer = (k, v) => v;\n  }\n\n  // Buffers cannot be serialized in a readable way\n  const bufferToJSON = Buffer.prototype.toJSON;\n  delete Buffer.prototype.toJSON;\n  try {\n    return JSON.stringify(\n      obj,\n      (key, value) => {\n        const updatedValue = Buffer.isBuffer(value) ? value.toString('utf8') : value;\n        return replacer(key, updatedValue);\n      },\n      space\n    );\n  } finally {\n    // restore the function, so as to not break further serialization\n    Buffer.prototype.toJSON = bufferToJSON;\n  }\n}\n\n/*\n * Removes the wrapper from element, if it exists.\n *   { ELEMENT: 4 } becomes 4\n *   { element-6066-11e4-a52e-4f735466cecf: 5 } becomes 5\n */\nfunction unwrapElement(el) {\n  for (const propName of [W3C_WEB_ELEMENT_IDENTIFIER, 'ELEMENT']) {\n    if (_.has(el, propName)) {\n      return el[propName];\n    }\n  }\n  return el;\n}\n\nfunction wrapElement(elementId) {\n  return {\n    ELEMENT: elementId,\n    [W3C_WEB_ELEMENT_IDENTIFIER]: elementId,\n  };\n}\n\n/*\n * Returns object consisting of all properties in the original element\n * which were truthy given the predicate.\n * If the predicate is\n *   * missing - it will remove all properties whose values are `undefined`\n *   * a scalar - it will test all properties' values against that value\n *   * a function - it will pass each value and the original object into the function\n */\nfunction filterObject(obj, predicate) {\n  let newObj = _.clone(obj);\n  if (_.isUndefined(predicate)) {\n    // remove any element from the object whose value is undefined\n    predicate = (v) => !_.isUndefined(v);\n  } else if (!_.isFunction(predicate)) {\n    // make predicate into a function\n    const valuePredicate = predicate;\n    predicate = (v) => v === valuePredicate;\n  }\n  for (const key of Object.keys(obj)) {\n    if (!predicate(obj[key], obj)) {\n      delete newObj[key];\n    }\n  }\n  return newObj;\n}\n\n/**\n * Converts number of bytes to a readable size string.\n *\n * @param {number|string} bytes - The actual number of bytes.\n * @returns {string} The actual string representation, for example\n *                   '1.00 KB' for '1024 B'\n * @throws {Error} If bytes count cannot be converted to an integer or\n *                 if it is less than zero.\n */\nfunction toReadableSizeString(bytes) {\n  const intBytes = parseInt(String(bytes), 10);\n  if (isNaN(intBytes) || intBytes < 0) {\n    throw new Error(`Cannot convert '${bytes}' to a readable size format`);\n  }\n  if (intBytes >= GiB) {\n    return `${(intBytes / (GiB * 1.0)).toFixed(2)} GB`;\n  } else if (intBytes >= MiB) {\n    return `${(intBytes / (MiB * 1.0)).toFixed(2)} MB`;\n  } else if (intBytes >= KiB) {\n    return `${(intBytes / (KiB * 1.0)).toFixed(2)} KB`;\n  }\n  return `${intBytes} B`;\n}\n\n/**\n * Checks whether the given path is a subpath of the\n * particular root folder. Both paths can include .. and . specifiers\n *\n * @param {string} originalPath The absolute file/folder path\n * @param {string} root The absolute root folder path\n * @param {?boolean} forcePosix Set it to true if paths must be interpreted in POSIX format\n * @returns {boolean} true if the given original path is the subpath of the root folder\n * @throws {Error} if any of the given paths is not absolute\n */\nfunction isSubPath(originalPath, root, forcePosix = null) {\n  const pathObj = forcePosix ? path.posix : path;\n  for (const p of [originalPath, root]) {\n    if (!pathObj.isAbsolute(p)) {\n      throw new Error(`'${p}' is expected to be an absolute path`);\n    }\n  }\n  const normalizedRoot = pathObj.normalize(root);\n  const normalizedPath = pathObj.normalize(originalPath);\n  return normalizedPath.startsWith(normalizedRoot);\n}\n\n/**\n * Checks whether the given paths are pointing to the same file system\n * destination.\n *\n * @param {string} path1 - Absolute or relative path to a file/folder\n * @param {string} path2 - Absolute or relative path to a file/folder\n * @param {...string} pathN - Zero or more absolute or relative paths to files/folders\n * @returns {Promise<boolean>} true if all paths are pointing to the same file system item\n */\nasync function isSameDestination(path1, path2, ...pathN) {\n  const allPaths = [path1, path2, ...pathN];\n  if (!(await B.reduce(allPaths, async (a, b) => a && (await fs.exists(b)), true))) {\n    return false;\n  }\n\n  const areAllItemsEqual = (arr) => !!arr.reduce((a, b) => (a === b ? a : NaN));\n  if (areAllItemsEqual(allPaths)) {\n    return true;\n  }\n\n  let mapCb = async (x) =>\n    (\n      await fs.stat(x, {\n        bigint: true,\n      })\n    ).ino;\n  return areAllItemsEqual(await B.map(allPaths, mapCb));\n}\n\n/**\n * Coerces the given number/string to a valid version string\n *\n * @template {boolean} [Strict=true]\n * @param {string} ver - Version string to coerce\n * @param {Strict} [strict] - If `true` then an exception will be thrown\n * if `ver` cannot be coerced\n * @returns {Strict extends true ? string : string|null} Coerced version number or null if the string cannot be\n * coerced and strict mode is disabled\n * @throws {Error} if strict mode is enabled and `ver` cannot be coerced\n */\nfunction coerceVersion(ver, strict = /** @type {Strict} */ (true)) {\n  const result = semver.valid(semver.coerce(`${ver}`));\n  if (strict && !result) {\n    throw new Error(`'${ver}' cannot be coerced to a valid version number`);\n  }\n  return /** @type {Strict extends true ? string : string?} */ (result);\n}\n\nconst SUPPORTED_OPERATORS = ['==', '!=', '>', '<', '>=', '<=', '='];\n\n/**\n * Compares two version strings\n *\n * @param {string} ver1 - The first version number to compare. Should be a valid\n * version number supported by semver parser.\n * @param {string} ver2 - The second version number to compare. Should be a valid\n * version number supported by semver parser.\n * @param {string} operator - One of supported version number operators:\n * ==, !=, >, <, <=, >=, =\n * @returns {boolean} true or false depending on the actual comparison result\n * @throws {Error} if an unsupported operator is supplied or any of the supplied\n * version strings cannot be coerced\n */\nfunction compareVersions(ver1, operator, ver2) {\n  if (!SUPPORTED_OPERATORS.includes(operator)) {\n    throw new Error(\n      `The '${operator}' comparison operator is not supported. ` +\n        `Only '${JSON.stringify(SUPPORTED_OPERATORS)}' operators are supported`\n    );\n  }\n\n  const semverOperator = ['==', '!='].includes(operator) ? '=' : operator;\n  const result = semver.satisfies(coerceVersion(ver1), `${semverOperator}${coerceVersion(ver2)}`);\n  return operator === '!=' ? !result : result;\n}\n\n/**\n * Add appropriate quotes to command arguments. See https://github.com/substack/node-shell-quote\n * for more details\n *\n * @param {string|string[]} args - The arguments that will be parsed\n * @returns {string} - The arguments, quoted\n */\nfunction quote(args) {\n  return shellQuote(_.castArray(args));\n}\n\n/**\n * This function is necessary to workaround unexpected memory leaks\n * caused by NodeJS string interning\n * behavior described in https://bugs.chromium.org/p/v8/issues/detail?id=2869\n *\n * @param {*} s - The string to unleak\n * @return {string} Either the unleaked string or the original object converted to string\n */\nfunction unleakString(s) {\n  return ` ${s}`.substr(1);\n}\n\n/**\n * @typedef PluralizeOptions\n * @property {boolean} [inclusive=false] - Whether to prefix with the number (e.g., 3 ducks)\n */\n\n/**\n * Get the form of a word appropriate to the count\n *\n * @param {string} word - The word to pluralize\n * @param {number} count - How many of the word exist\n * @param {PluralizeOptions|boolean} options - options for word pluralization,\n *   or a boolean indicating the options.inclusive property\n * @returns {string} The word pluralized according to the number\n */\nfunction pluralize(word, count, options = {}) {\n  let inclusive = false;\n  if (_.isBoolean(options)) {\n    // if passed in as a boolean\n    inclusive = options;\n  } else if (_.isBoolean(options?.inclusive)) {\n    // if passed in as an options hash\n    inclusive = options.inclusive;\n  }\n  return pluralizeLib(word, count, inclusive);\n}\n\n/**\n * @typedef EncodingOptions\n * @property {number} [maxSize=1073741824] The maximum size of\n * the resulting buffer in bytes. This is set to 1GB by default, because\n * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap\n * size must be enough to keep the resulting object (usually this size is\n * limited to 1.4 GB)\n */\n\n/**\n * Converts contents of a local file to an in-memory base-64 encoded buffer.\n * The operation is memory-usage friendly and should be used while encoding\n * large files to base64\n *\n * @param {string} srcPath The full path to the file being encoded\n * @param {EncodingOptions} opts\n * @returns {Promise<Buffer>} base64-encoded content of the source file as memory buffer\n * @throws {Error} if there was an error while reading the source file\n * or the source file is too\n */\nasync function toInMemoryBase64(srcPath, opts = {}) {\n  if (!(await fs.exists(srcPath)) || (await fs.stat(srcPath)).isDirectory()) {\n    throw new Error(`No such file: ${srcPath}`);\n  }\n\n  const {maxSize = 1 * GiB} = opts;\n  const resultBuffers = [];\n  let resultBuffersSize = 0;\n  const resultWriteStream = new stream.Writable({\n    write: (buffer, encoding, next) => {\n      resultBuffers.push(buffer);\n      resultBuffersSize += buffer.length;\n      if (maxSize > 0 && resultBuffersSize > maxSize) {\n        resultWriteStream.emit(\n          'error',\n          new Error(\n            `The size of the resulting ` +\n              `buffer must not be greater than ${toReadableSizeString(maxSize)}`\n          )\n        );\n      }\n      next();\n    },\n  });\n\n  const readerStream = fs.createReadStream(srcPath);\n  const base64EncoderStream = new Base64Encode();\n  const resultWriteStreamPromise = new B((resolve, reject) => {\n    resultWriteStream.once('error', (e) => {\n      readerStream.unpipe(base64EncoderStream);\n      base64EncoderStream.unpipe(resultWriteStream);\n      readerStream.destroy();\n      reject(e);\n    });\n    resultWriteStream.once('finish', resolve);\n  });\n  const readStreamPromise = new B((resolve, reject) => {\n    readerStream.once('close', resolve);\n    readerStream.once('error', (e) =>\n      reject(new Error(`Failed to read '${srcPath}': ${e.message}`))\n    );\n  });\n  readerStream.pipe(base64EncoderStream);\n  base64EncoderStream.pipe(resultWriteStream);\n\n  await B.all([readStreamPromise, resultWriteStreamPromise]);\n  return Buffer.concat(resultBuffers);\n}\n\n/**\n * @typedef LockFileOptions\n * @property {number} [timeout=120] The max time in seconds to wait for the lock\n * @property {boolean} [tryRecovery=false] Whether to try lock recovery if\n * the first attempt to acquire it timed out.\n */\n\n/**\n * Create an async function which, when called, will not proceed until a certain file is no\n * longer present on the system. This allows for preventing concurrent behavior across processes\n * using a known lockfile path.\n *\n * @template T\n * @param {string} lockFile The full path to the file used for the lock\n * @param {LockFileOptions} opts\n * @returns async function that takes another async function defining the locked\n * behavior\n */\nfunction getLockFileGuard(lockFile, opts = {}) {\n  const {timeout = 120, tryRecovery = false} = opts;\n\n  const lock = /** @type {(lockfile: string, opts: import('lockfile').Options)=>B<void>} */ (\n    B.promisify(_lockfile.lock)\n  );\n  const check = B.promisify(_lockfile.check);\n  const unlock = B.promisify(_lockfile.unlock);\n\n  /**\n   * @param {(...args: any[]) => T} behavior\n   * @returns {Promise<T>}\n   */\n  const guard = async (behavior) => {\n    let triedRecovery = false;\n    do {\n      try {\n        // if the lockfile doesn't exist, lock it synchronously to make sure no other call\n        // on the same spin of the event loop can also initiate a lock. If the lockfile does exist\n        // then just use the regular async 'lock' method which will wait on the lock.\n        if (_lockfile.checkSync(lockFile)) {\n          await lock(lockFile, {wait: timeout * 1000});\n        } else {\n          _lockfile.lockSync(lockFile);\n        }\n        break;\n      } catch (e) {\n        if (_.includes(e.message, 'EEXIST') && tryRecovery && !triedRecovery) {\n          // There could be cases where a process has been forcefully terminated\n          // without a chance to clean up pending locks: https://github.com/npm/lockfile/issues/26\n          _lockfile.unlockSync(lockFile);\n          triedRecovery = true;\n          continue;\n        }\n        throw new Error(\n          `Could not acquire lock on '${lockFile}' after ${timeout}s. ` +\n            `Original error: ${e.message}`\n        );\n      }\n      // eslint-disable-next-line no-constant-condition\n    } while (true);\n    try {\n      return await behavior();\n    } finally {\n      // whether the behavior succeeded or not, get rid of the lock\n      await unlock(lockFile);\n    }\n  };\n\n  guard.check = async () => await check(lockFile);\n\n  return guard;\n}\n\nexport {\n  hasValue,\n  escapeSpace,\n  escapeSpecialChars,\n  localIp,\n  cancellableDelay,\n  multiResolve,\n  safeJsonParse,\n  wrapElement,\n  unwrapElement,\n  filterObject,\n  toReadableSizeString,\n  isSubPath,\n  W3C_WEB_ELEMENT_IDENTIFIER,\n  isSameDestination,\n  compareVersions,\n  coerceVersion,\n  quote,\n  unleakString,\n  jsonStringify,\n  pluralize,\n  GiB,\n  MiB,\n  KiB,\n  toInMemoryBase64,\n  uuidV1,\n  uuidV3,\n  uuidV4,\n  uuidV5,\n  shellParse,\n  getLockFileGuard,\n};\n\n/**\n * A `string` which is never `''`.\n *\n * @template {string} T\n * @typedef {T extends '' ? never : T} NonEmptyString\n */\n"],"mappings":"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"}
+exports.getLockFileGuard = getLockFileGuard;
+/**
+ * A `string` which is never `''`.
+ *
+ * @template {string} T
+ * @typedef {T extends '' ? never : T} NonEmptyString
+ */
+//# sourceMappingURL=util.js.map