@donotuse/eas-cli 18.5.0-rc.1

package/build/utils/expodash/groupBy.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = groupBy;
+function groupBy(list, getKey) {
+    return list.reduce((previous, currentItem) => {
+        const group = getKey(currentItem);
+        if (!previous[group]) {
+            previous[group] = [];
+        }
+        previous[group].push(currentItem);
+        return previous;
+    }, {});
+}

package/build/utils/expodash/intersection.d.ts

@@ -0,0 +1 @@
+export default function intersection<T = any>(items1: T[], items2: T[]): T[];

package/build/utils/expodash/intersection.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = intersection;
+function intersection(items1, items2) {
+    const set1 = new Set(items1);
+    const set2 = new Set(items2);
+    return Array.from(new Set([...set1].filter(i => set2.has(i))));
+}

package/build/utils/expodash/mapMapAsync.d.ts

@@ -0,0 +1 @@
+export default function mapMapAsync<K, V, M>(map: ReadonlyMap<K, V>, mapper: (value: V, key: K) => Promise<M>): Promise<Map<K, M>>;

package/build/utils/expodash/mapMapAsync.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = mapMapAsync;
+async function mapMapAsync(map, mapper) {
+    const resultingMap = new Map();
+    await Promise.all(Array.from(map.keys()).map(async (k) => {
+        const initialValue = map.get(k);
+        const result = await mapper(initialValue, k);
+        resultingMap.set(k, result);
+    }));
+    return resultingMap;
+}

package/build/utils/expodash/memoize.d.ts

@@ -0,0 +1,2 @@
+/** `lodash.memoize` */
+export declare function memoize<T extends (...args: any[]) => any>(fn: T): T;

package/build/utils/expodash/memoize.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize = memoize;
+/** `lodash.memoize` */
+function memoize(fn) {
+    const cache = {};
+    return ((...args) => {
+        const key = JSON.stringify(args);
+        if (cache[key]) {
+            return cache[key];
+        }
+        const result = fn(...args);
+        cache[key] = result;
+        return result;
+    });
+}

package/build/utils/expodash/pick.d.ts

@@ -0,0 +1 @@
+export default function pick<T extends object, U extends keyof T>(object: T, keys: U[]): Pick<T, U>;

package/build/utils/expodash/pick.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = pick;
+function pick(object, keys) {
+    return keys.reduce((obj, key) => {
+        if (object && object.hasOwnProperty(key)) {
+            obj[key] = object[key];
+        }
+        return obj;
+    }, {});
+}

package/build/utils/expodash/sortBy.d.ts

@@ -0,0 +1 @@
+export default function sortBy<T extends any>(list: T[], what?: keyof T, order?: 'asc' | 'desc'): T[];

package/build/utils/expodash/sortBy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortBy;
+function sortBy(list, what, order = 'asc') {
+    const compareByFn = what &&
+        ((a, b) => {
+            const r = a[what] > b[what] ? 1 : b[what] > a[what] ? -1 : 0;
+            return order === 'asc' ? r : -r;
+        });
+    return list.concat().sort(compareByFn);
+}

package/build/utils/expodash/uniq.d.ts

@@ -0,0 +1 @@
+export default function uniq<T = any>(items: T[]): T[];

package/build/utils/expodash/uniq.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = uniq;
+function uniq(items) {
+    const set = new Set(items);
+    return [...set];
+}

package/build/utils/expodash/uniqBy.d.ts

@@ -0,0 +1 @@
+export default function uniqBy<T, K = any>(list: T[], getKey: (item: T) => K): T[];

package/build/utils/expodash/uniqBy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = uniqBy;
+function uniqBy(list, getKey) {
+    const uniqueValues = new Set();
+    const result = [];
+    for (const i of list) {
+        if (!uniqueValues.has(getKey(i))) {
+            result.push(i);
+            uniqueValues.add(getKey(i));
+        }
+    }
+    return result;
+}

package/build/utils/expodash/zipObject.d.ts

@@ -0,0 +1 @@
+export default function zipObject<T>(keys: string[], values: T[]): Record<string, T>;

package/build/utils/expodash/zipObject.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = zipObject;
+function zipObject(keys, values) {
+    if (keys.length !== values.length) {
+        throw new Error('The number of items does not match');
+    }
+    const result = {};
+    for (let i = 0; i < keys.length; i++) {
+        result[keys[i]] = values[i];
+    }
+    return result;
+}

package/build/utils/files.d.ts

@@ -0,0 +1,2 @@
+export declare function maybeRenameExistingFileAsync(projectDir: string, filename: string): Promise<void>;
+export declare function formatBytes(bytes: number): string;

package/build/utils/files.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeRenameExistingFileAsync = maybeRenameExistingFileAsync;
+exports.formatBytes = formatBytes;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+function getRenamedFilename(filename, num) {
+    const ext = path_1.default.extname(filename);
+    const basename = path_1.default.basename(filename, ext);
+    return `${basename}_OLD_${num}${ext}`;
+}
+async function maybeRenameExistingFileAsync(projectDir, filename) {
+    const desiredFilePath = path_1.default.resolve(projectDir, filename);
+    if (await fs_extra_1.default.pathExists(desiredFilePath)) {
+        let num = 1;
+        while (await fs_extra_1.default.pathExists(path_1.default.resolve(projectDir, getRenamedFilename(filename, num)))) {
+            num++;
+        }
+        log_1.default.log(`\nA file already exists at "${desiredFilePath}"\n  Renaming the existing file to ${getRenamedFilename(filename, num)}\n`);
+        await fs_extra_1.default.rename(desiredFilePath, path_1.default.resolve(projectDir, getRenamedFilename(filename, num)));
+    }
+}
+function formatBytes(bytes) {
+    if (bytes === 0) {
+        return `0`;
+    }
+    let multiplier = 1;
+    if (bytes < 1024 * multiplier) {
+        return `${Math.floor(bytes)} B`;
+    }
+    multiplier *= 1024;
+    if (bytes < 102.4 * multiplier) {
+        return `${(bytes / multiplier).toFixed(1)} KB`;
+    }
+    if (bytes < 1024 * multiplier) {
+        return `${Math.floor(bytes / 1024)} KB`;
+    }
+    multiplier *= 1024;
+    if (bytes < 102.4 * multiplier) {
+        return `${(bytes / multiplier).toFixed(1)} MB`;
+    }
+    if (bytes < 1024 * multiplier) {
+        return `${Math.floor(bytes / multiplier)} MB`;
+    }
+    multiplier *= 1024;
+    if (bytes < 102.4 * multiplier) {
+        return `${(bytes / multiplier).toFixed(1)} GB`;
+    }
+    return `${Math.floor(bytes / 1024)} GB`;
+}

package/build/utils/filterAsync.d.ts

@@ -0,0 +1,7 @@
+/**
+ * asynchronous array filter
+ * @param arr array to filter
+ * @param predicate a predicate function to run asynchronously
+ * @returns a promise resolving to a filtered array
+ */
+export declare const filterAsync: <T>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promise<boolean>) => Promise<T[]>;

package/build/utils/filterAsync.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterAsync = void 0;
+/**
+ * asynchronous array filter
+ * @param arr array to filter
+ * @param predicate a predicate function to run asynchronously
+ * @returns a promise resolving to a filtered array
+ */
+const filterAsync = async (arr, predicate) => await Promise.all(arr.map(predicate)).then(results => arr.filter((_v, index) => results[index]));
+exports.filterAsync = filterAsync;

package/build/utils/fingerprint.d.ts

@@ -0,0 +1,97 @@
+/**
+ * DO NOT EDIT unless the same change is made in `@expo/fingerprint`
+ */
+/// <reference types="node" />
+export interface HashSourceFile {
+    type: 'file';
+    filePath: string;
+    /**
+     * Reasons of this source coming from
+     */
+    reasons: string[];
+}
+export interface HashSourceDir {
+    type: 'dir';
+    filePath: string;
+    /**
+     * Reasons of this source coming from
+     */
+    reasons: string[];
+}
+export interface HashSourceContents {
+    type: 'contents';
+    id: string;
+    contents: string | Buffer;
+    /**
+     * Reasons of this source coming from
+     */
+    reasons: string[];
+}
+export type HashSource = HashSourceFile | HashSourceDir | HashSourceContents;
+export interface Fingerprint {
+    /**
+     * Sources and their hash values to generate a fingerprint
+     */
+    sources: FingerprintSource[];
+    /**
+     * The final hash value of the whole fingerprint
+     */
+    hash: string;
+}
+export interface DebugInfoFile {
+    path: string;
+    hash: string;
+}
+export interface DebugInfoDir {
+    path: string;
+    hash: string;
+    children: (DebugInfoFile | DebugInfoDir | undefined)[];
+}
+export interface DebugInfoContents {
+    hash: string;
+}
+export type DebugInfo = DebugInfoFile | DebugInfoDir | DebugInfoContents;
+export type FingerprintSource = HashSource & {
+    /**
+     * Hash value of the `source`.
+     * If the source is excluding by `Options.dirExcludes`, the value will be null.
+     */
+    hash: string | null;
+    /**
+     * Debug info from the hashing process. Differs based on source type. Designed to be consumed by humans
+     * as opposed to programmatically.
+     */
+    debugInfo?: DebugInfo;
+};
+export type FingerprintDiffItem = {
+    /**
+     * The operation type of the diff item.
+     */
+    op: 'added';
+    /**
+     * The added source.
+     */
+    addedSource: FingerprintSource;
+} | {
+    /**
+     * The operation type of the diff item.
+     */
+    op: 'removed';
+    /**
+     * The removed source.
+     */
+    removedSource: FingerprintSource;
+} | {
+    /**
+     * The operation type of the diff item.
+     */
+    op: 'changed';
+    /**
+     * The source before.
+     */
+    beforeSource: FingerprintSource;
+    /**
+     * The source after.
+     */
+    afterSource: FingerprintSource;
+};

package/build/utils/fingerprint.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * DO NOT EDIT unless the same change is made in `@expo/fingerprint`
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/utils/fingerprintCli.d.ts

@@ -0,0 +1,28 @@
+import { Env, Workflow } from '@expo/eas-build-job';
+import { Fingerprint, FingerprintDiffItem } from './fingerprint';
+export type FingerprintOptions = {
+    workflow: Workflow;
+    platforms: string[];
+    debug?: boolean;
+    env: Env | undefined;
+    cwd?: string;
+};
+export declare function diffFingerprint(projectDir: string, fingerprint1: Fingerprint, fingerprint2: Fingerprint): FingerprintDiffItem[] | null;
+export declare function createFingerprintAsync(projectDir: string, options: FingerprintOptions): Promise<(Fingerprint & {
+    isDebugSource: boolean;
+}) | null>;
+/**
+ * Computes project fingerprints based on provided options and returns a map of fingerprint data keyed by a string.
+ *
+ * @param projectDir - The root directory of the project.
+ * @param fingerprintOptionsByKey - A map where each key is associated with options for generating the fingerprint.
+ *   - **Key**: A unique identifier (`string`) for the fingerprint options.
+ *   - **Value**: An object containing options for generating a fingerprint.
+ *
+ * @returns A promise that resolves to a map where each key corresponds to the input keys, and each value is an object containing fingerprint data.
+ *
+ * @throws Will throw an error if fingerprint computation fails.
+ */
+export declare function createFingerprintsByKeyAsync(projectDir: string, fingerprintOptionsByKey: Map<string, FingerprintOptions>): Promise<Map<string, Fingerprint & {
+    isDebugSource: boolean;
+}>>;

package/build/utils/fingerprintCli.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFingerprintsByKeyAsync = exports.createFingerprintAsync = exports.diffFingerprint = void 0;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const resolve_from_1 = require("resolve-from");
+const mapMapAsync_1 = tslib_1.__importDefault(require("./expodash/mapMapAsync"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+const ora_1 = require("../ora");
+function diffFingerprint(projectDir, fingerprint1, fingerprint2) {
+    // @expo/fingerprint is exported in the expo package for SDK 52+
+    const fingerprintPath = (0, resolve_from_1.silent)(projectDir, 'expo/fingerprint');
+    if (!fingerprintPath) {
+        return null;
+    }
+    const Fingerprint = require(fingerprintPath);
+    return Fingerprint.diffFingerprints(fingerprint1, fingerprint2);
+}
+exports.diffFingerprint = diffFingerprint;
+async function createFingerprintAsync(projectDir, options) {
+    // @expo/fingerprint is exported in the expo package for SDK 52+
+    const fingerprintPath = (0, resolve_from_1.silent)(projectDir, 'expo/fingerprint');
+    if (!fingerprintPath) {
+        return null;
+    }
+    if (process.env.EAS_SKIP_AUTO_FINGERPRINT) {
+        log_1.default.log('Skipping project fingerprint');
+        return null;
+    }
+    const timeoutId = setTimeout(() => {
+        log_1.default.log('⌛️ Computing the project fingerprint is taking longer than expected...');
+        log_1.default.log('⏩ To skip this step, set the environment variable: EAS_SKIP_AUTO_FINGERPRINT=1');
+    }, 5000);
+    const spinner = (0, ora_1.ora)(`Computing project fingerprint`).start();
+    try {
+        const fingerprint = await createFingerprintWithoutLoggingAsync(projectDir, fingerprintPath, options);
+        spinner.succeed(`Computed project fingerprint`);
+        return fingerprint;
+    }
+    catch (e) {
+        spinner.fail(`Failed to compute project fingerprint`);
+        log_1.default.log('⏩ To skip this step, set the environment variable: EAS_SKIP_AUTO_FINGERPRINT=1');
+        throw e;
+    }
+    finally {
+        // Clear the timeout if the operation finishes before the time limit
+        clearTimeout(timeoutId);
+        spinner.stop();
+    }
+}
+exports.createFingerprintAsync = createFingerprintAsync;
+async function createFingerprintWithoutLoggingAsync(projectDir, fingerprintPath, options) {
+    const Fingerprint = require(fingerprintPath);
+    const fingerprintOptions = {};
+    if (options.platforms) {
+        fingerprintOptions.platforms = [...options.platforms];
+    }
+    if (options.workflow === eas_build_job_1.Workflow.MANAGED) {
+        fingerprintOptions.ignorePaths = ['android/**/*', 'ios/**/*'];
+    }
+    if (options.debug) {
+        fingerprintOptions.debug = true;
+    }
+    // eslint-disable-next-line @typescript-eslint/return-await
+    return await Fingerprint.createFingerprintAsync(projectDir, fingerprintOptions);
+}
+/**
+ * Computes project fingerprints based on provided options and returns a map of fingerprint data keyed by a string.
+ *
+ * @param projectDir - The root directory of the project.
+ * @param fingerprintOptionsByKey - A map where each key is associated with options for generating the fingerprint.
+ *   - **Key**: A unique identifier (`string`) for the fingerprint options.
+ *   - **Value**: An object containing options for generating a fingerprint.
+ *
+ * @returns A promise that resolves to a map where each key corresponds to the input keys, and each value is an object containing fingerprint data.
+ *
+ * @throws Will throw an error if fingerprint computation fails.
+ */
+async function createFingerprintsByKeyAsync(projectDir, fingerprintOptionsByKey) {
+    // @expo/fingerprint is exported in the expo package for SDK 52+
+    const fingerprintPath = (0, resolve_from_1.silent)(projectDir, 'expo/fingerprint');
+    if (!fingerprintPath) {
+        return new Map();
+    }
+    if (process.env.EAS_SKIP_AUTO_FINGERPRINT) {
+        log_1.default.log('Skipping project fingerprints');
+        return new Map();
+    }
+    const timeoutId = setTimeout(() => {
+        log_1.default.log('⌛️ Computing the project fingerprints is taking longer than expected...');
+        log_1.default.log('⏩ To skip this step, set the environment variable: EAS_SKIP_AUTO_FINGERPRINT=1');
+    }, 5000);
+    const spinner = (0, ora_1.ora)(`Computing project fingerprints`).start();
+    try {
+        const fingerprintsByKey = await (0, mapMapAsync_1.default)(fingerprintOptionsByKey, async (options) => await createFingerprintWithoutLoggingAsync(projectDir, fingerprintPath, options));
+        spinner.succeed(`Computed project fingerprints`);
+        return fingerprintsByKey;
+    }
+    catch (e) {
+        spinner.fail(`Failed to compute project fingerprints`);
+        log_1.default.log('⏩ To skip this step, set the environment variable: EAS_SKIP_AUTO_FINGERPRINT=1');
+        throw e;
+    }
+    finally {
+        // Clear the timeout if the operation finishes before the time limit
+        clearTimeout(timeoutId);
+        spinner.stop();
+    }
+}
+exports.createFingerprintsByKeyAsync = createFingerprintsByKeyAsync;

package/build/utils/fingerprintDiff.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Computes and prints a line-based diff between two strings, displaying changes as chunks.
+ *
+ * Each chunk contains lines that were added or removed, prefixed with contextual lines
+ * from the unchanged parts of the strings. The output is styled similarly to `git diff`
+ * with headers indicating line ranges for the changes in the original and modified strings.
+ *
+ * @param {string} str1 - The original string to compare.
+ * @param {string} str2 - The modified string to compare against the original.
+ * @param {number} [contextLines=2] - The number of unchanged lines to display before and after each chunk of changes.
+ *
+ * ### Output:
+ * - Each chunk begins with a header in the format `@@ -<original range> +<modified range> @@`.
+ * - Removed lines are prefixed with a red `-` and the original line number.
+ * - Added lines are prefixed with a green `+` and the modified line number.
+ * - Context lines are displayed in gray without a `+` or `-` prefix.
+ *
+ * ### Notes:
+ * - Consecutive changes are grouped into a single chunk if separated by no more than the specified number of context lines.
+ *
+ * ### Example:
+ * ```typescript
+ * abridgedDiff("Line1\nLine2\nLine3", "Line1\nLineX\nLine3", 1);
+ *
+ * Output:
+ * `@@ -2,1 +2,1 @@`
+ * Line1
+ * -Line2
+ * +LineX
+ * Line3
+ * ```
+ */
+export declare function abridgedDiff(str1: string, str2: string, contextLines?: number): void;

package/build/utils/fingerprintDiff.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abridgedDiff = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const diff_1 = require("diff");
+const log_1 = tslib_1.__importDefault(require("../log"));
+/**
+ * Computes and prints a line-based diff between two strings, displaying changes as chunks.
+ *
+ * Each chunk contains lines that were added or removed, prefixed with contextual lines
+ * from the unchanged parts of the strings. The output is styled similarly to `git diff`
+ * with headers indicating line ranges for the changes in the original and modified strings.
+ *
+ * @param {string} str1 - The original string to compare.
+ * @param {string} str2 - The modified string to compare against the original.
+ * @param {number} [contextLines=2] - The number of unchanged lines to display before and after each chunk of changes.
+ *
+ * ### Output:
+ * - Each chunk begins with a header in the format `@@ -<original range> +<modified range> @@`.
+ * - Removed lines are prefixed with a red `-` and the original line number.
+ * - Added lines are prefixed with a green `+` and the modified line number.
+ * - Context lines are displayed in gray without a `+` or `-` prefix.
+ *
+ * ### Notes:
+ * - Consecutive changes are grouped into a single chunk if separated by no more than the specified number of context lines.
+ *
+ * ### Example:
+ * ```typescript
+ * abridgedDiff("Line1\nLine2\nLine3", "Line1\nLineX\nLine3", 1);
+ *
+ * Output:
+ * `@@ -2,1 +2,1 @@`
+ * Line1
+ * -Line2
+ * +LineX
+ * Line3
+ * ```
+ */
+function abridgedDiff(str1, str2, contextLines = 2) {
+    const changes = (0, diff_1.diffLines)(str1, str2);
+    const output = [];
+    let lineNumberOriginal = 1;
+    let lineNumberModified = 1;
+    let currentChunk = [];
+    let currentChunkPriorContext = [];
+    let currentChunkAfterContext = [];
+    let startOriginal = null; // Start line in the original for the current chunk
+    let startModified = null; // Start line in the modified for the current chunk
+    let addedLines = 0;
+    let removedLines = 0;
+    const flushChunk = () => {
+        if (currentChunk.length > 0) {
+            const originalRange = `${startOriginal},${removedLines || 0}`;
+            const modifiedRange = `${startModified},${addedLines || 0}`;
+            // `git diff` style header
+            output.push(chalk_1.default.cyan(`@@ -${originalRange} +${modifiedRange} @@`));
+            output.push(...currentChunkPriorContext);
+            output.push(...currentChunk);
+            output.push(...currentChunkAfterContext);
+            currentChunk = [];
+            currentChunkPriorContext = [];
+            currentChunkAfterContext = [];
+            addedLines = 0;
+            removedLines = 0;
+        }
+    };
+    for (const change of changes) {
+        const lines = change.value.split('\n').filter(line => line);
+        if (change.added || change.removed) {
+            // Initialize start lines for the chunk if not already set
+            if (startOriginal === null) {
+                startOriginal = lineNumberOriginal;
+            }
+            if (startModified === null) {
+                startModified = lineNumberModified;
+            }
+            if (change.removed) {
+                lines.forEach(line => {
+                    currentChunk.push(`${chalk_1.default.red(`-${line}`)}`);
+                    lineNumberOriginal++;
+                    removedLines++;
+                });
+            }
+            if (change.added) {
+                lines.forEach(line => {
+                    currentChunk.push(`${chalk_1.default.green(`+${line}`)}`);
+                    lineNumberModified++;
+                    addedLines++;
+                });
+            }
+        }
+        else {
+            // Unchanged lines (context)
+            lines.forEach((line, i) => {
+                if (currentChunk.length > 0) {
+                    // Add leading context after a change
+                    if (i < contextLines) {
+                        currentChunkAfterContext.push(` ${chalk_1.default.gray(line)}`);
+                    }
+                }
+                else {
+                    // Add trailing context before a change
+                    if (lines.length - 1 - contextLines < i) {
+                        currentChunkPriorContext.push(` ${chalk_1.default.gray(line)}`);
+                    }
+                }
+                const isFinalLineOfAfterContext = i === contextLines - 1 || i === lines.length - 1;
+                if (currentChunk.length > 0 && isFinalLineOfAfterContext) {
+                    flushChunk();
+                }
+                lineNumberOriginal++;
+                lineNumberModified++;
+            });
+            startOriginal = null;
+            startModified = null;
+        }
+    }
+    flushChunk(); // Flush any remaining chunk
+    log_1.default.log(output.join('\n'));
+}
+exports.abridgedDiff = abridgedDiff;

package/build/utils/formatFields.d.ts

@@ -0,0 +1,9 @@
+type FormatFieldsOptions = {
+    labelFormat: (raw: string) => string;
+};
+export type FormatFieldsItem = {
+    label: string;
+    value: string;
+};
+export default function formatFields(fields: FormatFieldsItem[], options?: FormatFieldsOptions): string;
+export {};

package/build/utils/formatFields.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = formatFields;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+function formatFields(fields, options = { labelFormat: chalk_1.default.dim }) {
+    if (fields.length === 0) {
+        return '';
+    }
+    const columnWidth = fields.reduce((a, b) => (a.label.length > b.label.length ? a : b)).label
+        .length;
+    return fields
+        .map(({ label, value }) => {
+        // make all labels fixed-width
+        const formattedLabel = options.labelFormat(label.length < columnWidth ? `${label}${' '.repeat(columnWidth - label.length)}` : label);
+        return `${formattedLabel}  ${value}`;
+    })
+        .join('\n');
+}

package/build/utils/image.d.ts

@@ -0,0 +1,6 @@
+export declare class ImageNonPngError extends Error {
+}
+export declare class ImageTransparencyError extends Error {
+}
+export declare function ensurePNGIsNotTransparentAsync(imagePathOrURL: string): Promise<void>;
+export declare function isPNGAsync(imagePathOrURL: string): Promise<boolean>;