@appium/support 7.0.4 → 7.0.6

package/build/lib/util.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shellParse = exports.uuidV5 = exports.uuidV4 = exports.uuidV3 = exports.uuidV1 = exports.KiB = exports.MiB = exports.GiB = exports.W3C_WEB_ELEMENT_IDENTIFIER = void 0;
+exports.GiB = exports.MiB = exports.KiB = exports.W3C_WEB_ELEMENT_IDENTIFIER = exports.uuidV5 = exports.uuidV4 = exports.uuidV3 = exports.uuidV1 = exports.shellParse = void 0;
 exports.hasContent = hasContent;
 exports.hasValue = hasValue;
 exports.escapeSpace = escapeSpace;
@@ -45,178 +45,179 @@ exports.localIp = localIp;
 exports.cancellableDelay = cancellableDelay;
 exports.multiResolve = multiResolve;
 exports.safeJsonParse = safeJsonParse;
-exports.wrapElement = wrapElement;
+exports.jsonStringify = jsonStringify;
 exports.unwrapElement = unwrapElement;
+exports.wrapElement = wrapElement;
 exports.filterObject = filterObject;
 exports.toReadableSizeString = toReadableSizeString;
 exports.isSubPath = isSubPath;
 exports.isSameDestination = isSameDestination;
-exports.compareVersions = compareVersions;
 exports.coerceVersion = coerceVersion;
+exports.compareVersions = compareVersions;
 exports.quote = quote;
-exports.jsonStringify = jsonStringify;
 exports.pluralize = pluralize;
 exports.toInMemoryBase64 = toInMemoryBase64;
 exports.getLockFileGuard = getLockFileGuard;
 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 node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = __importDefault(require("node:stream"));
+const node_util_1 = require("node:util");
+const asyncbox_1 = require("asyncbox");
 const fs_1 = require("./fs");
 const semver = __importStar(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");
+var 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 = __importStar(require("lockfile"));
-const W3C_WEB_ELEMENT_IDENTIFIER = 'element-6066-11e4-a52e-4f735466cecf';
-exports.W3C_WEB_ELEMENT_IDENTIFIER = W3C_WEB_ELEMENT_IDENTIFIER;
-const KiB = 1024;
-exports.KiB = KiB;
-const MiB = KiB * 1024;
-exports.MiB = MiB;
-const GiB = MiB * 1024;
-exports.GiB = GiB;
+/** W3C WebDriver element identifier key used in element objects. */
+exports.W3C_WEB_ELEMENT_IDENTIFIER = 'element-6066-11e4-a52e-4f735466cecf';
+/** Size of one kibibyte in bytes (1024). */
+exports.KiB = 1024;
+/** Size of one mebibyte in bytes (1024 * 1024). */
+exports.MiB = exports.KiB * 1024;
+/** Size of one gibibyte in bytes (1024 * 1024 * 1024). */
+exports.GiB = exports.MiB * 1024;
 /**
- * @template {string} T
- * @param {T} val
- * @returns {val is NonEmptyString<T>}
+ * Type guard: returns true if the value is a non-empty string.
+ *
+ * @param val - Value to check
+ * @returns `true` if `val` is a string with at least one character
  */
 function hasContent(val) {
     return lodash_1.default.isString(val) && val !== '';
 }
 /**
- * return true if the the value is not `undefined`, `null`, or `NaN`.
+ * Type guard: returns true if 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>}
+ * @param val - Value to check
+ * @returns `true` if `val` is non-null and non-undefined (and not NaN for numbers)
  */
 function hasValue(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);
 }
 /**
- * Escape spaces in string, for commandline calls
- * @param {string} str - The string to escape spaces in
- * @returns {string} The string with escaped spaces
+ * Escapes spaces in a string for use in command-line arguments (e.g. ` ` → `\ `).
+ *
+ * @param str - String that may contain spaces
+ * @returns String with spaces escaped by a backslash
  */
 function escapeSpace(str) {
     return str.split(/ /).join('\\ ');
 }
 /**
- * Escape special characters in string
- * @param {string|any} str - The string to escape special characters in
- * @param {string} quoteEscape - Whether to escape quotes
- * @returns {string|any} The string with escaped special characters, or original value if not a string
+ * Escapes special characters in a string (backslash, slash, quotes, control chars).
+ * If `quoteEscape` is provided, that character is also escaped.
+ *
+ * @param str - String to escape, or non-string value (returned unchanged)
+ * @param quoteEscape - Optional character to escape, or `false` to skip
+ * @returns Escaped string, or original value if `str` is not a string
  */
 function escapeSpecialChars(str, quoteEscape) {
     if (typeof str !== 'string') {
         return str;
     }
-    if (typeof quoteEscape === 'undefined') {
-        // @ts-ignore to set false to mark no quote escaping
-        quoteEscape = false;
-    }
-    str = str
+    const result = str
         .replace(/[\\]/g, '\\\\')
-        .replace(/[\/]/g, '\\/') // eslint-disable-line no-useless-escape
+        .replace(/[/]/g, '\\/')
         .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, '\\"')
         .replace(/\\'/g, "\\'");
-    if (quoteEscape) {
-        const re = new RegExp(quoteEscape, 'g');
-        str = str.replace(re, `\\${quoteEscape}`);
+    if (!quoteEscape) {
+        return result;
     }
-    return str;
+    const re = new RegExp(quoteEscape, 'g');
+    return result.replace(re, `\\${quoteEscape}`);
 }
 /**
- * Get the local IP address of the machine
- * @returns {string|undefined} The local IP address of the first external IPv4 interface, or undefined if not found
+ * Returns the first non-internal IPv4 address of the machine, if any.
+ *
+ * @returns The local IPv4 address, or `undefined` if none found
  */
 function localIp() {
-    let ip = lodash_1.default.chain(os_1.default.networkInterfaces())
-        .values()
-        .flatten()
-        // @ts-ignore this filter works fine
-        .filter(({ family, internal }) => family === 'IPv4' && internal === false)
-        .map('address')
-        .first()
-        .value();
-    return ip;
+    const ifaces = node_os_1.default.networkInterfaces();
+    for (const addrs of Object.values(ifaces)) {
+        if (!addrs) {
+            continue;
+        }
+        for (const iface of addrs) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return undefined;
 }
-/*
- * Creates a promise that is cancellable, and will timeout
- * after `ms` delay
+/**
+ * Creates a promise that resolves after a delay and can be cancelled via `.cancel()`.
+ *
+ * @param ms - Delay in milliseconds before the promise resolves
+ * @returns A Bluebird promise with a `cancel()` method; cancel rejects with CancellationError
  */
+// TODO: replace with a native implementation in Appium 4
 function cancellableDelay(ms) {
     let timer;
     let resolve;
     let reject;
-    const delay = new bluebird_1.default.Promise((_resolve, _reject) => {
+    const delay = new bluebird_1.default((_resolve, _reject) => {
         resolve = _resolve;
         reject = _reject;
-        timer = setTimeout(function () {
-            resolve();
-        }, ms);
+        timer = setTimeout(() => 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);
-        // eslint-disable-next-line import/no-named-as-default-member
         reject(new bluebird_1.default.CancellationError());
     };
     return delay;
 }
+/**
+ * Resolves each root path with the given path segments, returning an array of absolute paths.
+ *
+ * @param roots - Base directory paths to resolve against
+ * @param args - Path segments to join with each root (e.g. 'foo', 'bar' → root/foo/bar)
+ * @returns Array of absolute paths, one per root
+ */
 function multiResolve(roots, ...args) {
-    return roots.map((root) => path_1.default.resolve(root, ...args));
+    return roots.map((root) => node_path_1.default.resolve(root, ...args));
 }
 /**
- * Parses an object if possible. Otherwise returns the object without parsing.
+ * Parses a value as JSON if it is a string; otherwise returns the value as-is.
  *
- * @param {any} obj
- * @returns {any}
+ * @param obj - String (to parse) or other value (returned unchanged)
+ * @returns Parsed object or original value
  */
 function safeJsonParse(obj) {
     try {
         return JSON.parse(obj);
     }
     catch {
-        // ignore: this is not json parsable
         return obj;
     }
 }
 /**
- * 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.
+ * Stringifies an object to JSON, converting Buffers to strings for readable output.
  *
- * @param {any} obj - the object to be serialized
- * @param {((key:any, value:any) => any)?} replacer - function to transform the properties added to the
- *                               serialized object
- * @param {number|string|undefined} 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
+ * @param obj - Object to serialize
+ * @param replacer - Optional replacer function (same as JSON.stringify)
+ * @param space - Indentation for pretty-printing. Defaults to 2
+ * @returns JSON string
  */
 function jsonStringify(obj, replacer = null, space = 2) {
-    // if no replacer is passed, or it is not a function, just use a pass-through
-    const replacerFunc = lodash_1.default.isFunction(replacer) ? replacer : (k, v) => v;
-    // Buffers cannot be serialized in a readable way
+    const replacerFunc = lodash_1.default.isFunction(replacer) ? replacer : (_k, v) => v;
     const bufferToJSON = Buffer.prototype.toJSON;
     delete Buffer.prototype.toJSON;
     try {
@@ -226,99 +227,100 @@ function jsonStringify(obj, replacer = null, space = 2) {
         }, space);
     }
     finally {
-        // restore the function, so as to not break further serialization
         Buffer.prototype.toJSON = bufferToJSON;
     }
 }
 /**
- * Removes the wrapper from element, if it exists.
- *   { ELEMENT: 4 } becomes 4
- *   { element-6066-11e4-a52e-4f735466cecf: 5 } becomes 5
- * @param {import('@appium/types').Element|string} el
- * @returns {string}
+ * Extracts the element ID from a W3C or JSONWP element object, or returns the string if already an ID.
+ *
+ * @param el - Element object (with ELEMENT or W3C identifier) or raw element ID string
+ * @returns The element ID string
  */
 function unwrapElement(el) {
-    for (const propName of [W3C_WEB_ELEMENT_IDENTIFIER, 'ELEMENT']) {
-        if (lodash_1.default.has(el, propName)) {
-            return /** @type {string} */ (el[propName]);
+    const elObj = el;
+    for (const propName of [exports.W3C_WEB_ELEMENT_IDENTIFIER, 'ELEMENT']) {
+        if (lodash_1.default.has(elObj, propName)) {
+            return elObj[propName];
         }
     }
-    return /** @type {string} */ (el);
+    return el;
 }
 /**
+ * Wraps an element ID string in an element object compatible with both W3C and JSONWP.
  *
- * @param {string} elementId
- * @returns {import('@appium/types').Element}
+ * @param elementId - The element ID to wrap
+ * @returns Element object with both ELEMENT and W3C identifier keys
  */
 function wrapElement(elementId) {
     return {
         ELEMENT: elementId,
-        [W3C_WEB_ELEMENT_IDENTIFIER]: elementId,
+        [exports.W3C_WEB_ELEMENT_IDENTIFIER]: elementId,
     };
 }
-/*
- * 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
+/**
+ * Returns a copy of the object containing only properties that pass the predicate.
+ * If the predicate is missing, removes properties whose values are undefined.
+ * If the predicate is a scalar, keeps only properties whose value equals that scalar.
+ * If the predicate is a function, calls it for each (value, obj) and keeps properties where it returns true.
+ *
+ * @param obj - Source object to filter
+ * @param predicate - Optional filter: undefined (drop undefined values), scalar (value match), or function
+ * @returns New object with only the properties that pass the predicate
  */
 function filterObject(obj, predicate) {
-    let newObj = lodash_1.default.clone(obj);
+    const newObj = lodash_1.default.clone(obj);
+    let pred;
     if (lodash_1.default.isUndefined(predicate)) {
-        // remove any element from the object whose value is undefined
-        predicate = (v) => !lodash_1.default.isUndefined(v);
+        pred = (v) => !lodash_1.default.isUndefined(v);
     }
     else if (!lodash_1.default.isFunction(predicate)) {
-        // make predicate into a function
         const valuePredicate = predicate;
-        predicate = (v) => v === valuePredicate;
+        pred = (v) => v === valuePredicate;
+    }
+    else {
+        pred = predicate;
     }
     for (const key of Object.keys(obj)) {
-        if (!predicate(obj[key], obj)) {
+        if (!pred(obj[key], obj)) {
             delete newObj[key];
         }
     }
     return newObj;
 }
 /**
- * Converts number of bytes to a readable size string.
+ * Converts a byte count to a human-readable size string (e.g. "1.50 MB").
  *
- * @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.
+ * @param bytes - Number of bytes (or string coercible to a number)
+ * @returns Formatted string like "123 B", "1.50 KB", "2.00 MB", "3.00 GB"
+ * @throws {Error} If bytes cannot be converted to a non-negative integer
  */
 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`;
+    if (intBytes >= exports.GiB) {
+        return `${(intBytes / (exports.GiB * 1.0)).toFixed(2)} GB`;
     }
-    else if (intBytes >= MiB) {
-        return `${(intBytes / (MiB * 1.0)).toFixed(2)} MB`;
+    else if (intBytes >= exports.MiB) {
+        return `${(intBytes / (exports.MiB * 1.0)).toFixed(2)} MB`;
     }
-    else if (intBytes >= KiB) {
-        return `${(intBytes / (KiB * 1.0)).toFixed(2)} KB`;
+    else if (intBytes >= exports.KiB) {
+        return `${(intBytes / (exports.KiB * 1.0)).toFixed(2)} KB`;
     }
     return `${intBytes} B`;
 }
 /**
- * Checks whether the given path is a subpath of the
- * particular root folder. Both paths can include .. and . specifiers
+ * Checks whether the given path is a subpath of the given root folder.
  *
- * @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
+ * @param originalPath - The absolute file or folder path to test
+ * @param root - The absolute root folder path
+ * @param forcePosix - If true, interpret paths in POSIX format (e.g. on Windows)
+ * @returns `true` if `originalPath` is under `root`
+ * @throws {Error} If either path is not absolute
  */
 function isSubPath(originalPath, root, forcePosix = null) {
-    const pathObj = forcePosix ? path_1.default.posix : path_1.default;
+    const pathObj = forcePosix ? node_path_1.default.posix : node_path_1.default;
     for (const p of [originalPath, root]) {
         if (!pathObj.isAbsolute(p)) {
             throw new Error(`'${p}' is expected to be an absolute path`);
@@ -329,41 +331,27 @@ function isSubPath(originalPath, root, forcePosix = null) {
     return normalizedPath.startsWith(normalizedRoot);
 }
 /**
- * Checks whether the given paths are pointing to the same file system
- * destination.
+ * Checks whether the given paths refer to the same file system entity (same inode).
+ * All paths must exist.
  *
- * @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
+ * @param path1 - First path
+ * @param path2 - Second path
+ * @param pathN - Additional paths to compare
+ * @returns `true` if all paths resolve to the same file/directory
  */
 async function isSameDestination(path1, path2, ...pathN) {
     const allPaths = [path1, path2, ...pathN];
-    if (!(await bluebird_1.default.reduce(allPaths, async (a, b) => a && (await fs_1.fs.exists(b)), true))) {
+    if (!(await (0, asyncbox_1.asyncmap)(allPaths, async (p) => fs_1.fs.exists(p))).every(Boolean)) {
         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.fs.stat(x, {
-        bigint: true,
-    })).ino;
-    return areAllItemsEqual(await bluebird_1.default.map(allPaths, mapCb));
+    const mapCb = async (x) => (await fs_1.fs.stat(x, { bigint: true })).ino;
+    return areAllItemsEqual(await (0, asyncbox_1.asyncmap)(allPaths, mapCb));
 }
-/**
- * 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)) {
-    // First try to parse as-is, then coerce if needed
+function coerceVersion(ver, strict = true) {
     let result = semver.valid(`${ver}`);
     if (!result) {
         result = semver.valid(semver.coerce(`${ver}`));
@@ -371,21 +359,17 @@ function coerceVersion(ver, strict = /** @type {Strict} */ (true)) {
     if (strict && !result) {
         throw new Error(`'${ver}' cannot be coerced to a valid version number`);
     }
-    return /** @type {Strict extends true ? string : string?} */ (result);
+    return result;
 }
 const SUPPORTED_OPERATORS = ['==', '!=', '>', '<', '>=', '<=', '='];
 /**
- * Compares two version strings
+ * Compares two version strings using the given operator.
  *
- * @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
+ * @param ver1 - First version string
+ * @param operator - One of: ==, !=, >, <, >=, <=, =
+ * @param ver2 - Second version string
+ * @returns `true` if ver1 operator ver2 holds (e.g. "2.0.0" >= "1.0.0")
+ * @throws {Error} If operator is unsupported or either version cannot be coerced
  */
 function compareVersions(ver1, operator, ver2) {
     if (!SUPPORTED_OPERATORS.includes(operator)) {
@@ -393,170 +377,131 @@ function compareVersions(ver1, operator, ver2) {
             `Only '${JSON.stringify(SUPPORTED_OPERATORS)}' operators are supported`);
     }
     const semverOperator = ['==', '!='].includes(operator) ? '=' : operator;
-    const result = semver.satisfies(coerceVersion(ver1), `${semverOperator}${coerceVersion(ver2)}`);
+    const v1 = coerceVersion(ver1, true);
+    const v2 = coerceVersion(ver2, true);
+    const result = semver.satisfies(v1, `${semverOperator}${v2}`);
     return operator === '!=' ? !result : result;
 }
 /**
- * Add appropriate quotes to command arguments. See https://github.com/substack/node-shell-quote
- * for more details
+ * Quotes and escapes command-line arguments so they can be safely passed to a shell.
  *
- * @param {string|string[]} args - The arguments that will be parsed
- * @returns {string} - The arguments, quoted
+ * @param args - Single argument or array of arguments to quote
+ * @returns Quoted string suitable for shell parsing
  */
 function quote(args) {
     return (0, shell_quote_1.quote)(lodash_1.default.castArray(args));
 }
 /**
- * @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
+ * Returns the plural or singular form of a word appropriate to the count (e.g. "duck" + 1 → "duck", + 2 → "ducks").
  *
- * @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
+ * @param word - The word to pluralize (or singularize when count is 1)
+ * @param count - The count used to choose singular vs plural
+ * @param options - Options object or boolean: use `inclusive: true` (or `true`) to prefix with the number (e.g. "3 ducks")
+ * @returns The correctly inflected word, optionally prefixed with the count
  */
 function pluralize(word, count, options = {}) {
     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);
 }
 /**
- * @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
+ * Reads a file and returns its contents as a base64-encoded buffer.
  *
- * @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
+ * @param srcPath - Full path to the file to encode
+ * @param opts - Encoding options (e.g. maxSize to cap buffer size)
+ * @returns Buffer containing the base64-encoded file content
+ * @throws {Error} If the file does not exist, is a directory, cannot be read, or exceeds maxSize
  */
 async function toInMemoryBase64(srcPath, opts = {}) {
     if (!(await fs_1.fs.exists(srcPath)) || (await fs_1.fs.stat(srcPath)).isDirectory()) {
         throw new Error(`No such file: ${srcPath}`);
     }
-    const { maxSize = 1 * GiB } = opts;
+    const { maxSize = 1 * exports.GiB } = opts;
     const resultBuffers = [];
     let resultBuffersSize = 0;
-    const resultWriteStream = new stream_1.default.Writable({
-        write: (buffer, encoding, next) => {
+    const resultWriteStream = new node_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)}`));
+                resultWriteStream.emit('error', new Error(`The size of the resulting buffer must not be greater than ${toReadableSizeString(maxSize)}`));
             }
             next();
         },
     });
     const readerStream = fs_1.fs.createReadStream(srcPath);
     const base64EncoderStream = new base64_stream_1.Base64Encode();
-    const resultWriteStreamPromise = new bluebird_1.default((resolve, reject) => {
+    const encoderWritable = base64EncoderStream;
+    const encoderReadable = base64EncoderStream;
+    const resultWriteStreamPromise = new Promise((resolve, reject) => {
         resultWriteStream.once('error', (e) => {
-            readerStream.unpipe(base64EncoderStream);
-            base64EncoderStream.unpipe(resultWriteStream);
+            readerStream.unpipe(encoderWritable);
+            encoderReadable.unpipe(resultWriteStream);
             readerStream.destroy();
             reject(e);
         });
-        resultWriteStream.once('finish', resolve);
+        resultWriteStream.once('finish', () => resolve());
     });
-    const readStreamPromise = new bluebird_1.default((resolve, reject) => {
-        readerStream.once('close', resolve);
+    const readStreamPromise = new Promise((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_1.default.all([readStreamPromise, resultWriteStreamPromise]);
+    readerStream.pipe(encoderWritable);
+    encoderReadable.pipe(resultWriteStream);
+    await Promise.all([readStreamPromise, resultWriteStreamPromise]);
     return Buffer.concat(resultBuffers);
 }
 /**
- * @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.
+ * Creates a guard that serializes access to a critical section using a lock file.
+ * The returned function acquires the lock, runs the given behavior, then releases the lock.
+ * Also exposes `.check()` to test whether the lock is currently held.
  *
- * @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
+ * @param lockFile - Full path to the lock file
+ * @param opts - Options (see {@link LockFileOptions})
+ * @returns Async function that accepts a callback to run under the lock, plus a `.check()` method
  */
 function getLockFileGuard(lockFile, opts = {}) {
     const { timeout = 120, tryRecovery = false } = opts;
-    const lock = /** @type {(lockfile: string, opts: import('lockfile').Options)=>B<void>} */ (bluebird_1.default.promisify(_lockfile.lock));
-    const check = bluebird_1.default.promisify(_lockfile.check);
-    const unlock = bluebird_1.default.promisify(_lockfile.unlock);
-    /**
-     * @param {(...args: any[]) => T} behavior
-     * @returns {Promise<T>}
-     */
-    const guard = async (behavior) => {
+    const lock = (0, node_util_1.promisify)(_lockfile.lock);
+    const checkLock = (0, node_util_1.promisify)(_lockfile.check);
+    const unlock = (0, node_util_1.promisify)(_lockfile.unlock);
+    const guard = Object.assign(async (behavior) => {
         let triedRecovery = false;
-        do {
+        let acquired = false;
+        while (!acquired) {
             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.checkSync(lockFile)) {
                     await lock(lockFile, { wait: timeout * 1000 });
                 }
                 else {
                     _lockfile.lockSync(lockFile);
                 }
-                break;
+                acquired = true;
             }
             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
+                const err = e;
+                if (lodash_1.default.includes(err.message, 'EEXIST') && tryRecovery && !triedRecovery) {
                     _lockfile.unlockSync(lockFile);
                     triedRecovery = true;
-                    continue;
                 }
-                throw new Error(`Could not acquire lock on '${lockFile}' after ${timeout}s. ` +
-                    `Original error: ${e.message}`);
+                else {
+                    throw new Error(`Could not acquire lock on '${lockFile}' after ${timeout}s. ` +
+                        `Original error: ${err.message}`);
+                }
             }
-            // eslint-disable-next-line no-constant-condition
-        } while (true);
+        }
         try {
             return await behavior();
         }
         finally {
-            // whether the behavior succeeded or not, get rid of the lock
             await unlock(lockFile);
         }
-    };
-    guard.check = async () => await check(lockFile);
+    }, { check: () => checkLock(lockFile) });
     return guard;
 }
-/**
- * A `string` which is never `''`.
- *
- * @template {string} T
- * @typedef {T extends '' ? never : T} NonEmptyString
- */
 //# sourceMappingURL=util.js.map