first commit

node_modules/@expo/xcpretty/build/ExpoRunFormatter.d.ts

@@ -0,0 +1,36 @@
+import { CopyFileProps, FileOperation, Formatter } from './Formatter';
+import { MetroParser } from './MetroParser';
+export type ExpoRunFormatterProps = {
+    projectRoot: string;
+    podfile?: Record<string, Record<string, string>>;
+    appName?: string;
+    isDebug?: boolean;
+};
+/**
+ * A superset of `Formatter` which adds support for Metro build errors and cleaner formatting for Node projects.
+ */
+export declare class ExpoRunFormatter extends Formatter {
+    props: ExpoRunFormatterProps;
+    static create(projectRoot: string, { xcodeProject, isDebug, }?: {
+        xcodeProject?: {
+            name: string;
+        };
+    } & Pick<ExpoRunFormatterProps, 'isDebug'>): ExpoRunFormatter;
+    private podfileTracer;
+    _parser: MetroParser | undefined;
+    get parser(): MetroParser;
+    constructor(props: ExpoRunFormatterProps);
+    formatMetroAssetCollectionError(errorContents: string): string;
+    shouldShowCompileWarning(filePath: string, lineNumber?: string, columnNumber?: string): boolean;
+    shouldShowLinkerWarning(methodName: string, collisions: {
+        filePath: string;
+        name: string;
+    }[]): boolean;
+    shouldShowWarningInTarget({ target }: {
+        target?: string;
+    }): boolean;
+    getNodeModuleName(filePath: string, target?: string): string | null;
+    formatFileOperation(props: FileOperation): string;
+    formatCopy({ from, to, target }: CopyFileProps): string;
+    formatPhaseScriptExecution(scriptName: string, target?: string, project?: string): string;
+}

node_modules/@expo/xcpretty/build/ExpoRunFormatter.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpoRunFormatter = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Formatter_1 = require("./Formatter");
+const MetroParser_1 = require("./MetroParser");
+const PodfileTracer_1 = require("./utils/PodfileTracer");
+const parsePodfileLock_1 = require("./utils/parsePodfileLock");
+const symbols_1 = require("./utils/symbols");
+/**
+ * A superset of `Formatter` which adds support for Metro build errors and cleaner formatting for Node projects.
+ */
+class ExpoRunFormatter extends Formatter_1.Formatter {
+    static create(projectRoot, { xcodeProject, isDebug, } = {}) {
+        var _a;
+        const appName = ((_a = xcodeProject === null || xcodeProject === void 0 ? void 0 : xcodeProject.name.match(/.*\/(.*)\.\w+/)) === null || _a === void 0 ? void 0 : _a[1]) || '';
+        const formatter = new ExpoRunFormatter({
+            projectRoot,
+            appName,
+            isDebug,
+        });
+        return formatter;
+    }
+    get parser() {
+        if (this._parser) {
+            return this._parser;
+        }
+        this._parser = new MetroParser_1.MetroParser(this);
+        return this._parser;
+    }
+    constructor(props) {
+        var _a;
+        super(props);
+        this.props = props;
+        let podfile = {};
+        const podfileLock = path_1.default.join(props.projectRoot, 'ios', 'Podfile.lock');
+        try {
+            const podfileContents = fs_1.default.readFileSync(podfileLock, 'utf8');
+            podfile = (_a = (0, parsePodfileLock_1.parsePodfileLock)(podfileContents)) !== null && _a !== void 0 ? _a : {};
+        }
+        catch { }
+        this.podfileTracer = new PodfileTracer_1.PodfileTracer({
+            ...props,
+            podfile,
+        });
+    }
+    formatMetroAssetCollectionError(errorContents) {
+        const results = `\n${chalk_1.default.red(symbols_1.ERROR +
+            // Provide proper attribution.
+            'Metro encountered an error:\n' +
+            errorContents)}\nLearn more: https://docs.expo.dev/build-reference/troubleshooting\n`;
+        this.errors.push(results);
+        return results;
+    }
+    shouldShowCompileWarning(filePath, lineNumber, columnNumber) {
+        if (this.props.isDebug) {
+            return true;
+        }
+        return (!filePath.match(/node_modules/) &&
+            !filePath.match(/\/ios\/Pods\//) &&
+            // Don't show warnings in the generated build folder.
+            !Formatter_1.Formatter.getAppRoot(filePath));
+    }
+    shouldShowLinkerWarning(methodName, collisions) {
+        if (this.props.isDebug) {
+            return true;
+        }
+        return (
+        // Don't show warnings from cocoapods that come from non-root target pods.
+        !collisions.some(({ filePath }) => {
+            const nodeModule = this.podfileTracer.getNodeModuleNameForTarget(path_1.default.dirname(filePath));
+            return !(nodeModule === null || nodeModule === void 0 ? void 0 : nodeModule.isRootTarget);
+        }));
+    }
+    shouldShowWarningInTarget({ target }) {
+        if (this.props.isDebug || !target) {
+            return true;
+        }
+        const nodeModule = this.podfileTracer.getNodeModuleNameForTarget(target);
+        return !nodeModule || nodeModule.isRootTarget;
+    }
+    getNodeModuleName(filePath, target) {
+        const results = this.podfileTracer.getNodeModuleName(filePath, target);
+        return (results === null || results === void 0 ? void 0 : results.name) ? chalk_1.default.cyan(results.name) : null;
+    }
+    formatFileOperation(props) {
+        const title = this.getFileOperationTitle(props.type);
+        const moduleNameTag = this.getNodeModuleName(props.filePath, props.target);
+        return Formatter_1.Formatter.format(title, [moduleNameTag, Formatter_1.Formatter.formatBreadCrumb(props.fileName, props.target, props.project)]
+            .filter(Boolean)
+            .join(' '));
+    }
+    formatCopy({ from, to, target }) {
+        let relativeFile = Formatter_1.Formatter.relativePath(this.props.projectRoot, from);
+        // If the relative file reaches outside of the project root, we
+        // should attempt to resolve relative to the app output directory.
+        if (relativeFile.startsWith('../../')) {
+            const appFileRoot = Formatter_1.Formatter.getAppRoot(from);
+            relativeFile = Formatter_1.Formatter.highlightLastPathComponent(Formatter_1.Formatter.relativePath(appFileRoot, from));
+        }
+        const appFileRoot = Formatter_1.Formatter.getAppRoot(to);
+        const relativeAppFile = Formatter_1.Formatter.highlightLastPathComponent(Formatter_1.Formatter.relativePath(appFileRoot, to));
+        const moduleNameTag = this.getNodeModuleName('', target);
+        return Formatter_1.Formatter.format('Copying  ', [moduleNameTag, [relativeFile, relativeAppFile].join(' ➜ ')].filter(Boolean).join(' '));
+    }
+    formatPhaseScriptExecution(scriptName, target, project) {
+        const moduleNameTag = this.getNodeModuleName('', target);
+        if (scriptName === 'Start Packager') {
+            const port = process.env.RCT_METRO_PORT || '8081';
+            const isDisabled = isTruthy(process.env.RCT_NO_LAUNCH_PACKAGER);
+            const status = isDisabled ? 'disabled' : `http://localhost:${port}`;
+            // Add some insight into if the bundler was started or not, and which port was used.
+            if (isDisabled) {
+                scriptName = chalk_1.default.gray(`${scriptName} (disabled)`);
+            }
+            else {
+                scriptName = scriptName + chalk_1.default.gray(` on ${status}`);
+            }
+        }
+        return Formatter_1.Formatter.format('Executing', [moduleNameTag, Formatter_1.Formatter.formatBreadCrumb(scriptName, target, project)]
+            .filter(Boolean)
+            .join(' '));
+    }
+}
+exports.ExpoRunFormatter = ExpoRunFormatter;
+function isTruthy(value) {
+    return value === 'true' || value === 1 || value === '1';
+}
+//# sourceMappingURL=ExpoRunFormatter.js.map

node_modules/@expo/xcpretty/build/Formatter.d.ts

@@ -0,0 +1,196 @@
+import { Failure, Parser } from './Parser';
+declare function highlightLastPathComponent(filePath: string): string;
+declare function format(command: string, argumentText?: string, success?: boolean): string;
+declare function relativePath(projectRoot: string, filePath: string): string;
+declare function formatBreadCrumb(fileName: string, target?: string, project?: string): string;
+declare function getAppRoot(filePath: string): string;
+export type FileOperation = {
+    type: 'Analyze' | 'GenerateDSYMFile' | 'Ld' | 'Libtool' | 'ProcessPCH' | 'ProcessInfoPlistFile' | 'CodeSign' | 'Touch' | 'CompileC' | 'CompileSwift' | 'CompileXIB' | 'CompileStoryboard';
+    filePath: string;
+    fileName: string;
+    arch?: string;
+    linkType?: string;
+    target?: string;
+    project?: string;
+};
+export type ConfigurationOperation = {
+    type: 'Analyze' | 'Aggregate' | 'Build' | 'Clean';
+    configuration: string;
+    target?: string;
+    project?: string;
+};
+export type CopyFileProps = {
+    type: 'CpResource' | 'CopyStringsFile' | 'CopyPlistFile' | 'CpHeader';
+    from: string;
+    to: string;
+    target?: string;
+    project?: string;
+};
+export declare class Formatter {
+    props: {
+        projectRoot: string;
+        /** Sets the max character length for a warning before cropping the preview. Useful for minified files that can be upwards of a thousand characters long. */
+        maxWarningLineLength?: number;
+    };
+    static format: typeof format;
+    static formatBreadCrumb: typeof formatBreadCrumb;
+    static getAppRoot: typeof getAppRoot;
+    static highlightLastPathComponent: typeof highlightLastPathComponent;
+    static relativePath: typeof relativePath;
+    _parser: Parser | undefined;
+    get parser(): Parser;
+    errors: string[];
+    warnings: string[];
+    constructor(props: {
+        projectRoot: string;
+        /** Sets the max character length for a warning before cropping the preview. Useful for minified files that can be upwards of a thousand characters long. */
+        maxWarningLineLength?: number;
+    });
+    pipe(data: string): string[];
+    private dimConfiguration;
+    getTitleForConfigurationType(type: ConfigurationOperation['type']): string;
+    formatTarget(props: ConfigurationOperation): string;
+    formatCopy({ from, to }: CopyFileProps): string;
+    getFileOperationTitle(type: FileOperation['type']): string;
+    formatFileOperation(props: FileOperation): string;
+    formatPhaseSuccess(phaseName: string, duration?: string): string;
+    formatPhaseScriptExecution(scriptName: string, target?: string, project?: string): string;
+    formatPreprocess(file: string): string;
+    formatShellCommand(command: string, args: string): string;
+    formatCompileCommand(compilerCommand: string, filePath: string): string;
+    formatProcessPchCommand(filePath: string): string;
+    formatWriteFile(file: string): string;
+    formatOther(text: string): string;
+    formatSingleLineCompileIssue(type: 'warning' | 'error', filePathAndLocation: string, fileName: string, reason: string, target: string, project: string): string;
+    formatRemark(msg: string): string;
+    formatEmitSwiftModule(type: 'normal' | string, arch: 'x86_64' | string, target?: string, project?: string): string;
+    formatCompileSwiftSources(type: 'normal' | string, arch: 'x86_64' | string, pkg: string | 'com.apple.xcode.tools.swift.compiler', target?: string, project?: string): string;
+    formatCleanRemove(msg: string): string;
+    formatWriteAuxiliaryFiles(text: string): string;
+    formatTiffutil(file: string): string;
+    formatCheckDependencies(text: string): string;
+    formatWillNotBeCodeSigned(message: string): string;
+    /**
+     *
+     * @param fileName 'SampleTest.m',
+     * @param filePathAndLocation '/Users/foo/bar.m:12:59',
+     * @param reason 'expected identifier',
+     * @param line '                [[thread should] equal:thread.];',
+     * @param cursor '                                           ^'
+     */
+    formatCompileError(fileName: string, filePathAndLocation: string, reason: string, line: string, cursor: string): string;
+    formatError(message: string): string;
+    /**
+     * In: `error: Provisioning profile "iOS Team Provisioning Profile: *" doesn't support the Push Notifications capability. (in target 'yolo90' from project 'yolo90')`
+     * Out: `❌  yolo90/yolo90: Provisioning Profile "iOS Team Provisioning Profile: *" does not support the Push Notifications capability.`
+     *
+     * In: `error: Provisioning profile "iOS Team Provisioning Profile: *" doesn't include the aps-environment entitlement. (in target 'yolo90' from project 'yolo90')`
+     * Out: `❌  yolo90/yolo90: Entitlements file defines the value "aps-environment" which is not registered for profile "iOS Team Provisioning Profile: *".`
+     *
+     * @param profileName `"iOS Team Provisioning Profile: *"`
+     * @param entitlementName `Push Notifications` | `aps-environment`
+     * @param entitlementType `capability` | `entitlement`
+     * @param target boost-for-react-native
+     * @param project Pods
+     */
+    formatUnsupportedEntitlementError(profileName: string, entitlementName: string, entitlementType: 'capability' | 'entitlement', target?: string, project?: string): string;
+    formatFileMissingError(reason: string, filePath: string): string;
+    formatLdWarning(reason: string): string;
+    formatUndefinedSymbols(message: string, symbol: string, reference: string): string;
+    formatLdMethodOverride(methodName: string, collisions: {
+        filePath: string;
+        name: string;
+    }[]): string;
+    formatDuplicateSymbols(message: string, filePaths: string[], isWarning: boolean): string;
+    /**
+     * In: `The iOS Simulator deployment target 'IPHONEOS_DEPLOYMENT_TARGET' is set to 8.0, but the range of supported deployment target versions is 9.0 to 14.3.99. (in target 'boost-for-react-native' from project 'Pods')`
+     * Out: `⚠️ Pods/boost-for-react-native: iOS@8.0 version mismatch. Expected >= 9.0 < 14.3.99`
+     *
+     * @param os iOS
+     * @param deploymentTarget IPHONEOS_DEPLOYMENT_TARGET
+     * @param version 8.0
+     * @param minVersion 9.0
+     * @param maxVersion 14.3.99
+     * @param target boost-for-react-native
+     * @param project Pods
+     */
+    formatVersionMismatchWarning(os: string, deploymentTarget: string, version: string, minVersion: string, maxVersion: string, target: string, project: string): string;
+    /**
+     * In: `warning: [CP] Vendored binary '/Users/evanbacon/Library/Developer/Xcode/DerivedData/yolo67-hcjsxsdqyxnsgdednlbpylgeffja/Build/Intermediates.noindex/Pods.build/Debug-iphonesimulator/hermes-engine.build/DerivedSources/hermes.framework.dSYM/Contents/Resources/DWARF/hermes' contains architectures (armv7 armv7s arm64) none of which match the current build architectures (x86_64).`
+     * Out: `⚠️  Vendored binary '[app]/hermes-engine.build/DerivedSources/hermes.framework.dSYM/Contents/Resources/DWARF/hermes' does not support current build architecture (x86_64). Supported architectures: armv7, armv7s, arm64.`
+     *
+     * @param os iOS
+     * @param deploymentTarget IPHONEOS_DEPLOYMENT_TARGET
+     * @param version 8.0
+     * @param minVersion 9.0
+     * @param maxVersion 14.3.99
+     * @param target boost-for-react-native
+     * @param project Pods
+     */
+    formatMissingArchitectureWarning(binaryPath: string, architectures: string[], currentArchitectures: string[]): string;
+    /**
+     * In: `Skipping duplicate build file in Compile Sources build phase: /Users/evanbacon/Documents/GitHub/expo/ios/Exponent/Kernel/ReactAppManager/EXReactAppManager.mm (in target 'Exponent' from project 'Exponent')`
+     * Out:
+     * `⚠️ Skipping duplicate file: Exponent/Kernel/ReactAppManager/EXReactAppManager.mm:
+     *    Remove: Exponent » Exponent » Build Phases » Compile Sources » EXReactAppManager.mm`
+     *
+     * @param filePath
+     * @param buildPhase 'Compile Sources'
+     * @param target Exponent-watch-app
+     * @param project Exponent
+     */
+    formatDuplicateFileCompilerWarning(filePath: string, buildPhase: string, target: string, project: string): string;
+    /**
+     * In: `The Copy Bundle Resources build phase contains this target's Info.plist file '/Users/evanbacon/Documents/GitHub/expo/ios/Exponent/Supporting/Info.plist'. (in target 'Exponent' from project 'Exponent')`
+     * Out:
+     * `⚠️ Target's Info.plist file is incorrectly linked: Exponent/Supporting/Info.plist:
+     *    Remove: Exponent » Exponent » Build Phases » Copy Bundle Resources » Info.plist`
+     *
+     * @param filePath
+     * @param reservedFileDescription 'entitlements'
+     * @param target Exponent-watch-app
+     * @param project Exponent
+     */
+    formatReservedFileInCopyBundleResourcesCompilerWarning(filePath: string, reservedFileDescription: string, target: string, project: string): string;
+    /**
+     * In: `Run script build phase '[CP-User] [Hermes] Replace Hermes for the right configuration, if needed' will be run during every build because it does not specify any outputs. To address this warning, either add output dependencies to the script phase, or configure it to run in every build by unchecking "Based on dependency analysis" in the script phase. (in target 'hermes-engine' from project 'Pods')`
+     * Out:
+     * `⚠️ Script has ambiguous dependencies causing it to run on every build.
+     *    To fix, go to: Xcode » Pods/hermes-engine » Build Phases » [CP-User] [Hermes] Replace Hermes for the right configuration, if needed
+     *    Either: Uncheck "Based on dependency analysis", or select output files to trigger the script`
+     *
+     * @param script [CP-User] [Hermes] Replace Hermes for the right configuration, if needed
+     * @param target Exponent-watch-app
+     * @param project Exponent
+     */
+    formatAmbiguousRunScriptOutputsWarning(script: string, target: string, project: string): string;
+    formatMissingFileCompilerWarning(filePath: string): string;
+    formatGenericError(message: string): string;
+    formatGenericWarning(message: string): string;
+    formatWarning(message: string): string;
+    formatCompileWarning(fileName: string, filePathAndLocation: string, reason: string, line?: string, cursor?: string): string;
+    shouldShowWarningInTarget(props: {
+        target?: string;
+    }): boolean;
+    shouldShowCompileWarning(filePath: string, lineNumber?: string, columnNumber?: string): boolean;
+    shouldShowLinkerWarning(methodName: string, collisions: {
+        filePath: string;
+        name: string;
+    }[]): boolean;
+    formatPendingTest(suite: string, test: string): string;
+    formatPassingTest(suite: string, test: string, time: string): string;
+    formatMeasuringTest(suite: string, test: string, time: string): string;
+    formatFailingTest(suite: string, test: string, reason: string, filePath: string): string;
+    formatTestRunStarted(name: string): string;
+    formatTestSuiteStarted(name: string): string;
+    formatTestRunFinished(name: string, time: string): string;
+    formatTestSummary(executedMessage: string, failuresPerSuite: Record<string, Failure[]>): string;
+    formatFailures(failuresPerSuite: Record<string, Failure[]>): string;
+    formatFailure(f: Failure): string;
+    finish(): void;
+    prettyFormat(text: string): string | void;
+    optionalNewline(): string;
+    getBuildSummary(): string;
+    checkForBundlingErrors(lines: string | string[]): void;
+}
+export {};

node_modules/@expo/xcpretty/build/Formatter.js

@@ -0,0 +1,836 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formatter = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const Matchers_1 = require("./Matchers");
+const Parser_1 = require("./Parser");
+const switchRegex_1 = require("./switchRegex");
+const symbols_1 = require("./utils/symbols");
+var Status;
+(function (Status) {
+    Status["Pass"] = "pass";
+    Status["Fail"] = "fail";
+    Status["Pending"] = "pending";
+    Status["Error"] = "error";
+    Status["Completion"] = "completion";
+    Status["Measure"] = "measure";
+})(Status || (Status = {}));
+function highlightLastPathComponent(filePath) {
+    return chalk_1.default.dim(path.dirname(filePath) + '/') + path.basename(filePath);
+}
+function format(command, argumentText = '', success = true) {
+    const symbol = statusSymbol(success ? Status.Completion : Status.Fail);
+    return [symbol, chalk_1.default.bold(command), argumentText].join(' ').trim();
+}
+function formatTest(testCase, status) {
+    return [statusSymbol(status), testCase].join(' ').trim();
+}
+function heading(prefix, text, description) {
+    return [prefix, chalk_1.default.white(text), description].join(' ').trim();
+}
+function statusSymbol(status) {
+    switch (status) {
+        case Status.Pass:
+            return chalk_1.default.green(symbols_1.PASS);
+        case Status.Fail:
+            return chalk_1.default.red(symbols_1.FAIL);
+        case Status.Pending:
+            return chalk_1.default.cyan(symbols_1.PENDING);
+        case Status.Error:
+            return chalk_1.default.red(symbols_1.ERROR);
+        case Status.Completion:
+            return chalk_1.default.white(symbols_1.COMPLETION);
+        case Status.Measure:
+            return chalk_1.default.magenta(symbols_1.MEASURE);
+        default:
+            return '';
+    }
+}
+function coloredTime(time) {
+    const flt = parseFloat(time);
+    if (flt >= 0 && flt <= 0.025) {
+        return time;
+    }
+    else if (flt >= 0.026 && flt <= 0.1) {
+        return chalk_1.default.yellow(time);
+    }
+    return chalk_1.default.red(time);
+}
+function capitalize(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+}
+function relativePath(projectRoot, filePath) {
+    return slash(path.relative(projectRoot, filePath));
+}
+function formatBreadCrumb(fileName, target, project) {
+    // TODO: Simplify
+    return [project === target ? project : [project, target].filter(Boolean).join(`/`), fileName]
+        .filter(Boolean)
+        .join(` ${symbols_1.BREADCRUMB} `);
+}
+function getAppRoot(filePath) {
+    let appRoot = filePath;
+    const isBuildFolder = (path) => /((Debug|Release)-[^/\s\d]*$)|(.app$)/.test(path);
+    while (!isBuildFolder(appRoot) && appRoot.length > 1) {
+        appRoot = path.dirname(appRoot);
+    }
+    return isBuildFolder(appRoot) ? appRoot : '';
+}
+class Formatter {
+    get parser() {
+        if (this._parser) {
+            return this._parser;
+        }
+        this._parser = new Parser_1.Parser(this);
+        return this._parser;
+    }
+    constructor(props) {
+        this.props = props;
+        this.errors = [];
+        this.warnings = [];
+    }
+    pipe(data) {
+        const lines = [];
+        data.split(os.EOL).forEach(line => {
+            const results = this.parser.parse(line);
+            if (typeof results === 'string' && results.trim()) {
+                lines.push(results);
+            }
+        });
+        this.checkForBundlingErrors(lines);
+        return lines;
+    }
+    dimConfiguration(configuration) {
+        return chalk_1.default.dim(`(${configuration})`);
+    }
+    getTitleForConfigurationType(type) {
+        switch (type) {
+            case 'Clean':
+                return 'Cleaning';
+            case 'Aggregate':
+                return 'Aggregate';
+            case 'Analyze':
+                return 'Analyzing';
+            case 'Build':
+                return 'Building';
+            default:
+                return 'Unknown';
+        }
+    }
+    formatTarget(props) {
+        return format(this.getTitleForConfigurationType(props.type), this.dimConfiguration(formatBreadCrumb(props.configuration, props.target, props.project)));
+    }
+    formatCopy({ from, to }) {
+        const relativeFile = relativePath(this.props.projectRoot, from);
+        const appFileRoot = getAppRoot(to);
+        const relativeAppFile = relativePath(appFileRoot, to);
+        return format('Copying  ', [relativeFile, relativeAppFile].join(' ➜ '));
+    }
+    getFileOperationTitle(type) {
+        switch (type) {
+            case 'Analyze':
+                return 'Analyzing';
+            case 'GenerateDSYMFile':
+                return `Generating debug`;
+            case 'Ld':
+                return 'Linking  ';
+            case 'Libtool':
+                return 'Packaging';
+            case 'ProcessPCH':
+                return 'Precompiling';
+            case 'ProcessInfoPlistFile':
+                return 'Preparing';
+            case 'CodeSign':
+                return 'Signing  ';
+            case 'Touch':
+                return 'Creating ';
+            case 'CompileC':
+            case 'CompileSwift':
+            case 'CompileXIB':
+            case 'CompileStoryboard':
+                return 'Compiling';
+            default:
+                // Unknown file operation
+                return '';
+        }
+    }
+    formatFileOperation(props) {
+        const title = this.getFileOperationTitle(props.type);
+        switch (props.type) {
+            case 'Analyze':
+                return format(title, formatBreadCrumb(props.fileName, props.target, props.project));
+            case 'GenerateDSYMFile':
+                return format(title, formatBreadCrumb(`'${props.fileName}'`, props.target, props.project));
+            case 'Ld':
+                return format(title, formatBreadCrumb(props.fileName, props.target, props.project));
+            case 'Libtool':
+                return format(title, formatBreadCrumb(props.fileName, props.target, props.project));
+            case 'ProcessPCH':
+                return format(title, formatBreadCrumb(props.fileName, props.target, props.project));
+            case 'ProcessInfoPlistFile':
+                return format(title, formatBreadCrumb(props.fileName, props.target, props.project));
+            case 'CodeSign':
+                return format(title, formatBreadCrumb(props.fileName, props.target, props.project));
+            case 'Touch':
+                return format(title, props.fileName);
+            case 'CompileC':
+            case 'CompileSwift':
+            case 'CompileXIB':
+            case 'CompileStoryboard':
+                return format(title, formatBreadCrumb(props.fileName, props.target, props.project));
+            default:
+                // Unknown file operation
+                return '';
+        }
+    }
+    formatPhaseSuccess(phaseName, duration) {
+        return format(capitalize(phaseName.toLowerCase()), `Succeeded${duration ? ` (${duration})` : ''}`, true);
+    }
+    formatPhaseScriptExecution(scriptName, target, project) {
+        // TODO: Track (scriptName === '[CP] Copy XCFrameworks')
+        return format('Executing', formatBreadCrumb(`'${scriptName}'`, target, project));
+    }
+    formatPreprocess(file) {
+        return format('Preprocessing', file);
+    }
+    formatShellCommand(command, args) {
+        return '';
+    }
+    formatCompileCommand(compilerCommand, filePath) {
+        return '';
+    }
+    formatProcessPchCommand(filePath) {
+        return '';
+    }
+    formatWriteFile(file) {
+        return '';
+    }
+    formatOther(text) {
+        return '';
+    }
+    formatSingleLineCompileIssue(type, filePathAndLocation, fileName, reason, target, project) {
+        // Allow disabling this warning.
+        const { filePath, lineNumber, columnNumber } = splitPathInfo(filePathAndLocation);
+        if (type === 'warning') {
+            if (!this.shouldShowCompileWarning(filePath, lineNumber, columnNumber)) {
+                return '';
+            }
+        }
+        // Prevent `/foo/bar:1:1` instead using `/foo/bar` since it's a bit more focused.
+        const sanitizedFilePath = lineNumber === '1' && columnNumber === '1' ? filePath : filePathAndLocation;
+        // Get the `Project/Target` prefix.
+        const packageName = [project, target].join('/');
+        // Choose a color.
+        const color = type === 'warning' ? chalk_1.default.yellow : chalk_1.default.red;
+        const platform = color.bold(`${packageName}:`);
+        // Choose a symbol.
+        const symbol = type === 'warning' ? symbols_1.WARNING : symbols_1.ERROR;
+        // Get a more concise file path when the issue is inside the build folder.
+        const appFileRoot = getAppRoot(sanitizedFilePath);
+        const relativeAppFile = appFileRoot
+            ? chalk_1.default.gray('[app]/') + relativePath(appFileRoot, sanitizedFilePath)
+            : sanitizedFilePath;
+        // Create the message.
+        const results = (0, chalk_1.default) `${symbol} ${platform} ${reason.trim()}\n   {gray └─${relativeAppFile}}`;
+        // Ensure we track the message
+        if (type === 'warning') {
+            this.warnings.push(results);
+        }
+        else {
+            this.errors.push(results);
+        }
+        return results;
+    }
+    // These are like comments but for Xcode logs.
+    formatRemark(msg) {
+        return '';
+    }
+    formatEmitSwiftModule(type, arch, target, project) {
+        return '';
+    }
+    formatCompileSwiftSources(type, arch, pkg, target, project) {
+        return '';
+    }
+    formatCleanRemove(msg) {
+        return '';
+    }
+    formatWriteAuxiliaryFiles(text) {
+        return '';
+    }
+    formatTiffutil(file) {
+        return format('Validating', file);
+    }
+    formatCheckDependencies(text) {
+        return format('Check Dependencies');
+    }
+    formatWillNotBeCodeSigned(message) {
+        const results = `${chalk_1.default.yellow(symbols_1.WARNING + ' ' + message)}`;
+        this.warnings.push(results);
+        return results;
+    }
+    // COMPILER / LINKER ERRORS AND WARNINGS
+    /**
+     *
+     * @param fileName 'SampleTest.m',
+     * @param filePathAndLocation '/Users/foo/bar.m:12:59',
+     * @param reason 'expected identifier',
+     * @param line '                [[thread should] equal:thread.];',
+     * @param cursor '                                           ^'
+     */
+    formatCompileError(fileName, filePathAndLocation, reason, line, cursor) {
+        const { filePath, lineNumber, columnNumber } = splitPathInfo(filePathAndLocation);
+        const results = formatWarningOrError({
+            isError: true,
+            filePath,
+            reason,
+            cursor,
+            lineText: line,
+            lineNumber,
+            columnNumber,
+            projectRoot: this.props.projectRoot,
+            maxWarningLineLength: this.props.maxWarningLineLength,
+        });
+        this.errors.push(results);
+        return results;
+    }
+    formatError(message) {
+        const results = (0, switchRegex_1.switchRegex)(message, [
+            [
+                Matchers_1.Matchers.Errors.UNSUPPORTED_ENTITLEMENT_MATCHER,
+                ([, $1, $2, $3, $4, $5]) => {
+                    return this.formatUnsupportedEntitlementError($1, $2, $3, $4, $5);
+                },
+            ],
+            [null, () => this.formatGenericError(message)],
+        ]);
+        this.errors.push(results);
+        return results;
+    }
+    /**
+     * In: `error: Provisioning profile "iOS Team Provisioning Profile: *" doesn't support the Push Notifications capability. (in target 'yolo90' from project 'yolo90')`
+     * Out: `❌  yolo90/yolo90: Provisioning Profile "iOS Team Provisioning Profile: *" does not support the Push Notifications capability.`
+     *
+     * In: `error: Provisioning profile "iOS Team Provisioning Profile: *" doesn't include the aps-environment entitlement. (in target 'yolo90' from project 'yolo90')`
+     * Out: `❌  yolo90/yolo90: Entitlements file defines the value "aps-environment" which is not registered for profile "iOS Team Provisioning Profile: *".`
+     *
+     * @param profileName `"iOS Team Provisioning Profile: *"`
+     * @param entitlementName `Push Notifications` | `aps-environment`
+     * @param entitlementType `capability` | `entitlement`
+     * @param target boost-for-react-native
+     * @param project Pods
+     */
+    formatUnsupportedEntitlementError(profileName, entitlementName, entitlementType, target, project) {
+        const packageName = [project, target].join('/');
+        const platform = chalk_1.default.red.bold(`${packageName}:`);
+        if (entitlementType === 'capability') {
+            return (0, chalk_1.default) `${symbols_1.ERROR} ${platform} Provisioning Profile ${profileName} does not support the {red ${entitlementName}} capability.`;
+        }
+        return (0, chalk_1.default) `${symbols_1.ERROR} ${platform} Entitlements file defines the value {red "${entitlementName}"} which is not registered for profile ${profileName}.`;
+    }
+    formatFileMissingError(reason, filePath) {
+        const results = `\n${chalk_1.default.red(symbols_1.ERROR + ' ' + reason)} ${filePath}\n\n`;
+        this.errors.push(results);
+        return results;
+    }
+    formatLdWarning(reason) {
+        const results = (0, switchRegex_1.switchRegex)(reason, [
+            [
+                Matchers_1.Matchers.Warnings.LINKER_METHOD_OVERRIDE,
+                ([, $1, $2, $3, $4, $5]) => {
+                    return this.formatLdMethodOverride($1, [
+                        { filePath: $2, name: $3 },
+                        { filePath: $4, name: $5 },
+                    ]);
+                },
+            ],
+            [
+                Matchers_1.Matchers.Warnings.LINKER_METHOD_SINGLE_OVERRIDE,
+                ([, $1, $2, $3]) => {
+                    return this.formatLdMethodOverride($1, [{ filePath: $2, name: $3 }]);
+                },
+            ],
+            [null, () => `${chalk_1.default.yellow(symbols_1.WARNING + ' ' + reason)}`],
+        ]);
+        if (results) {
+            this.warnings.push(results);
+        }
+        return results;
+    }
+    formatUndefinedSymbols(message, symbol, reference) {
+        const symbols = chalk_1.default.gray(`┌─ Symbol: ${symbol}\n└─ Referenced from: ${reference}`);
+        const results = `${chalk_1.default.red(symbols_1.ERROR + ' ' + message)}\n${symbols}\n`;
+        this.errors.push(results);
+        return results;
+    }
+    formatLdMethodOverride(methodName, collisions) {
+        if (!this.shouldShowLinkerWarning(methodName, collisions)) {
+            return '';
+        }
+        const formattedMessage = chalk_1.default.yellow(symbols_1.WARNING + ` ld: duplicate method '${chalk_1.default.bold(methodName)}' in`);
+        const types = ['category', 'class'];
+        const symbols = chalk_1.default.gray(collisions
+            .map(({ filePath, name }, i) => {
+            const appFileRoot = getAppRoot(filePath);
+            const relativeAppFile = relativePath(appFileRoot, filePath);
+            const branch = i === collisions.length - 1 ? '└─' : i === 0 ? '┌─' : '├─';
+            return `${branch}${`[${types[i]}]`}: ${name} ${chalk_1.default.dim(relativeAppFile)}`;
+        })
+            .join('\n'));
+        return `${formattedMessage}\n${symbols}\n`;
+    }
+    formatDuplicateSymbols(message, filePaths, isWarning) {
+        const formattedMessage = isWarning
+            ? chalk_1.default.yellow(symbols_1.WARNING + ' ' + message)
+            : chalk_1.default.red(symbols_1.ERROR + ' ' + message);
+        const symbols = chalk_1.default.gray(filePaths
+            .map((p, i) => {
+            const branch = i === filePaths.length - 1 ? '└─' : i === 0 ? '┌─' : '├─';
+            return `${branch} ${path.basename(p)}`;
+        })
+            .join('\n'));
+        const results = `${formattedMessage}\n${symbols}\n`;
+        if (isWarning) {
+            this.warnings.push(results);
+        }
+        else {
+            this.errors.push(results);
+        }
+        return results;
+    }
+    /**
+     * In: `The iOS Simulator deployment target 'IPHONEOS_DEPLOYMENT_TARGET' is set to 8.0, but the range of supported deployment target versions is 9.0 to 14.3.99. (in target 'boost-for-react-native' from project 'Pods')`
+     * Out: `⚠️ Pods/boost-for-react-native: iOS@8.0 version mismatch. Expected >= 9.0 < 14.3.99`
+     *
+     * @param os iOS
+     * @param deploymentTarget IPHONEOS_DEPLOYMENT_TARGET
+     * @param version 8.0
+     * @param minVersion 9.0
+     * @param maxVersion 14.3.99
+     * @param target boost-for-react-native
+     * @param project Pods
+     */
+    formatVersionMismatchWarning(os, deploymentTarget, version, minVersion, maxVersion, target, project) {
+        const packageName = [project, target].join('/');
+        const platform = chalk_1.default.bold(`${packageName}:`);
+        const packageNameWithVersion = chalk_1.default.greenBright(os) + chalk_1.default.cyan `@` + chalk_1.default.magenta(version);
+        const expectedRange = `>= ${minVersion} <= ${maxVersion}`;
+        return `${symbols_1.WARNING} ${platform} ${packageNameWithVersion} deployment version mismatch, expected ${expectedRange}`;
+    }
+    /**
+     * In: `warning: [CP] Vendored binary '/Users/evanbacon/Library/Developer/Xcode/DerivedData/yolo67-hcjsxsdqyxnsgdednlbpylgeffja/Build/Intermediates.noindex/Pods.build/Debug-iphonesimulator/hermes-engine.build/DerivedSources/hermes.framework.dSYM/Contents/Resources/DWARF/hermes' contains architectures (armv7 armv7s arm64) none of which match the current build architectures (x86_64).`
+     * Out: `⚠️  Vendored binary '[app]/hermes-engine.build/DerivedSources/hermes.framework.dSYM/Contents/Resources/DWARF/hermes' does not support current build architecture (x86_64). Supported architectures: armv7, armv7s, arm64.`
+     *
+     * @param os iOS
+     * @param deploymentTarget IPHONEOS_DEPLOYMENT_TARGET
+     * @param version 8.0
+     * @param minVersion 9.0
+     * @param maxVersion 14.3.99
+     * @param target boost-for-react-native
+     * @param project Pods
+     */
+    formatMissingArchitectureWarning(binaryPath, architectures, currentArchitectures) {
+        const appFileRoot = getAppRoot(binaryPath);
+        const relativeAppFile = appFileRoot
+            ? chalk_1.default.gray('[app]/') + relativePath(appFileRoot, binaryPath)
+            : binaryPath;
+        const architectureString = currentArchitectures.length === 1 ? 'architecture' : 'architectures';
+        const supportedString = chalk_1.default.dim(`Supported architectures: ${architectures.join(', ')}.`);
+        return (chalk_1.default.yellow(`${symbols_1.WARNING} Vendored binary '${relativeAppFile}' does not support current build ${architectureString} (${chalk_1.default.bold(currentArchitectures.join(', '))}). `) + supportedString);
+    }
+    /**
+     * In: `Skipping duplicate build file in Compile Sources build phase: /Users/evanbacon/Documents/GitHub/expo/ios/Exponent/Kernel/ReactAppManager/EXReactAppManager.mm (in target 'Exponent' from project 'Exponent')`
+     * Out:
+     * `⚠️ Skipping duplicate file: Exponent/Kernel/ReactAppManager/EXReactAppManager.mm:
+     *    Remove: Exponent » Exponent » Build Phases » Compile Sources » EXReactAppManager.mm`
+     *
+     * @param filePath
+     * @param buildPhase 'Compile Sources'
+     * @param target Exponent-watch-app
+     * @param project Exponent
+     */
+    formatDuplicateFileCompilerWarning(filePath, buildPhase, target, project) {
+        const message = `${chalk_1.default.yellow `Skipping duplicate file:`} ${relativePath(this.props.projectRoot, filePath)}`;
+        const fileName = path.basename(filePath);
+        const crumbs = chalk_1.default.gray('Remove: ' +
+            ['Xcode', `${project}/${target}`, 'Build Phases', buildPhase, fileName].join(` ${symbols_1.BREADCRUMB} `));
+        return `${symbols_1.WARNING} ${message}\n   ${crumbs}\n`;
+    }
+    /**
+     * In: `The Copy Bundle Resources build phase contains this target's Info.plist file '/Users/evanbacon/Documents/GitHub/expo/ios/Exponent/Supporting/Info.plist'. (in target 'Exponent' from project 'Exponent')`
+     * Out:
+     * `⚠️ Target's Info.plist file is incorrectly linked: Exponent/Supporting/Info.plist:
+     *    Remove: Exponent » Exponent » Build Phases » Copy Bundle Resources » Info.plist`
+     *
+     * @param filePath
+     * @param reservedFileDescription 'entitlements'
+     * @param target Exponent-watch-app
+     * @param project Exponent
+     */
+    formatReservedFileInCopyBundleResourcesCompilerWarning(filePath, reservedFileDescription, target, project) {
+        const message = `${chalk_1.default.yellow `Target's ${chalk_1.default.bold(reservedFileDescription)} file is incorrectly linked:`} ${relativePath(this.props.projectRoot, filePath)}`;
+        const fileName = path.basename(filePath);
+        const crumbs = chalk_1.default.gray('Remove: ' +
+            ['Xcode', `${project}/${target}`, 'Build Phases', 'Copy Bundle Resources', fileName].join(` ${symbols_1.BREADCRUMB} `));
+        return `${symbols_1.WARNING} ${message}\n   ${crumbs}\n`;
+    }
+    /**
+     * In: `Run script build phase '[CP-User] [Hermes] Replace Hermes for the right configuration, if needed' will be run during every build because it does not specify any outputs. To address this warning, either add output dependencies to the script phase, or configure it to run in every build by unchecking "Based on dependency analysis" in the script phase. (in target 'hermes-engine' from project 'Pods')`
+     * Out:
+     * `⚠️ Script has ambiguous dependencies causing it to run on every build.
+     *    To fix, go to: Xcode » Pods/hermes-engine » Build Phases » [CP-User] [Hermes] Replace Hermes for the right configuration, if needed
+     *    Either: Uncheck "Based on dependency analysis", or select output files to trigger the script`
+     *
+     * @param script [CP-User] [Hermes] Replace Hermes for the right configuration, if needed
+     * @param target Exponent-watch-app
+     * @param project Exponent
+     */
+    formatAmbiguousRunScriptOutputsWarning(script, target, project) {
+        if (!this.shouldShowWarningInTarget({ target })) {
+            return '';
+        }
+        const message = chalk_1.default.yellow `Script has ambiguous dependencies causing it to run on every build.`;
+        const crumbs = chalk_1.default.gray('To fix, go to: ' +
+            ['Xcode', `${project}/${target}`, 'Build Phases', `'${script}'`].join(` ${symbols_1.BREADCRUMB} `));
+        const solution = chalk_1.default.gray(`Either: Uncheck "Based on dependency analysis", or select output files to trigger the script`);
+        return `${symbols_1.WARNING} ${message}\n   ${crumbs}\n   ${solution}\n`;
+    }
+    formatMissingFileCompilerWarning(filePath) {
+        return `${symbols_1.WARNING} ${chalk_1.default.yellow `No such file or directory:`} ${filePath}`;
+    }
+    formatGenericError(message) {
+        return `\n${chalk_1.default.red(symbols_1.ERROR + ' ' + message)}\n\n`;
+    }
+    formatGenericWarning(message) {
+        return symbols_1.INDENT + chalk_1.default.yellow(message);
+    }
+    formatWarning(message) {
+        const results = (0, switchRegex_1.switchRegex)(message, [
+            [
+                Matchers_1.Matchers.Warnings.MISSING_ARCHITECTURE,
+                ([, $1, $2, $3]) => {
+                    return this.formatMissingArchitectureWarning($1, $2 === null || $2 === void 0 ? void 0 : $2.split(' ').map(value => value.trim()), $3 === null || $3 === void 0 ? void 0 : $3.split(' ').map(value => value.trim()));
+                },
+            ],
+            [
+                Matchers_1.Matchers.Warnings.VERSION_MISMATCH,
+                ([, $1, $2, $3, $4, $5, $6, $7]) => {
+                    return this.formatVersionMismatchWarning($1, $2, $3, $4, $5, $6, $7);
+                },
+            ],
+            [
+                Matchers_1.Matchers.Warnings.MISSING_FILE_COMPILER_WARNING_MATCHER,
+                ([, $1]) => {
+                    return this.formatMissingFileCompilerWarning($1);
+                },
+            ],
+            [
+                Matchers_1.Matchers.Warnings.SKIPPING_DUPLICATE_FILE,
+                ([, $1, $2, $3, $4]) => {
+                    return this.formatDuplicateFileCompilerWarning($2, $1, $3, $4);
+                },
+            ],
+            [
+                Matchers_1.Matchers.Warnings.TARGETS_FILE_INCLUDED,
+                ([, $1, $2, $3, $4]) => {
+                    return this.formatReservedFileInCopyBundleResourcesCompilerWarning($2, $1, $3, $4);
+                },
+            ],
+            [
+                Matchers_1.Matchers.Warnings.AMBIGUOUS_RUN_SCRIPT,
+                ([, $1, $2, $3, $4]) => {
+                    return this.formatAmbiguousRunScriptOutputsWarning($1, $2, $3);
+                },
+            ],
+            [null, () => this.formatGenericWarning(message)],
+        ]);
+        // If the warning wasn't skipped then add it.
+        if (results) {
+            this.warnings.push(results);
+        }
+        return results;
+    }
+    // TODO: see how we can unify formatError and formatCompileError,
+    //       the same for warnings
+    formatCompileWarning(fileName, filePathAndLocation, reason, line, cursor) {
+        const { filePath, lineNumber, columnNumber } = splitPathInfo(filePathAndLocation);
+        if (this.shouldShowCompileWarning(filePath, lineNumber, columnNumber)) {
+            const results = formatWarningOrError({
+                isError: false,
+                filePath,
+                reason,
+                cursor,
+                lineText: line,
+                lineNumber,
+                columnNumber,
+                projectRoot: this.props.projectRoot,
+                maxWarningLineLength: this.props.maxWarningLineLength,
+            });
+            if (results) {
+                this.warnings.push(results);
+            }
+            return results;
+        }
+        return '';
+    }
+    shouldShowWarningInTarget(props) {
+        return true;
+    }
+    shouldShowCompileWarning(filePath, lineNumber, columnNumber) {
+        return true;
+    }
+    shouldShowLinkerWarning(methodName, collisions) {
+        return true;
+    }
+    formatPendingTest(suite, test) {
+        return symbols_1.INDENT + formatTest(`${test} [PENDING]`, Status.Pending);
+    }
+    formatPassingTest(suite, test, time) {
+        return symbols_1.INDENT + formatTest(`${test} (${coloredTime(time)} seconds)`, Status.Pass);
+    }
+    formatMeasuringTest(suite, test, time) {
+        return symbols_1.INDENT + formatTest(`${test} measured (${coloredTime(time)} seconds)`, Status.Measure);
+    }
+    formatFailingTest(suite, test, reason, filePath) {
+        return symbols_1.INDENT + formatTest(`${test}, ${reason}`, Status.Fail);
+    }
+    formatTestRunStarted(name) {
+        return heading('Test Suite', name, 'started');
+    }
+    formatTestSuiteStarted(name) {
+        return heading('', name, '');
+    }
+    formatTestRunFinished(name, time) {
+        return '';
+    }
+    // Will be printed by default. Override with '' if you don't want summary
+    formatTestSummary(executedMessage, failuresPerSuite) {
+        const failures = this.formatFailures(failuresPerSuite);
+        let finalMessage = '';
+        if (!failures) {
+            finalMessage = chalk_1.default.green(executedMessage);
+        }
+        else {
+            finalMessage = chalk_1.default.red(executedMessage);
+        }
+        const text = [failures, finalMessage].join('\n\n\n').trim();
+        return `\n\n${text}`;
+    }
+    formatFailures(failuresPerSuite) {
+        return Object.entries(failuresPerSuite)
+            .map(([suite, failures]) => {
+            const formattedFailures = failures.map(failure => this.formatFailure(failure)).join('\n\n');
+            return `\n${suite}\n${formattedFailures}`;
+        })
+            .join('\n');
+    }
+    formatFailure(f) {
+        const { filePath, lineNumber, columnNumber } = splitPathInfo(f.filePath);
+        return formatWarningOrError({
+            isError: true,
+            testName: f.testCase,
+            filePath,
+            reason: f.reason,
+            // cursor,
+            lineNumber,
+            columnNumber,
+            projectRoot: this.props.projectRoot,
+            maxWarningLineLength: this.props.maxWarningLineLength,
+        });
+    }
+    finish() { }
+    // Override if you want to catch something specific with your regex
+    prettyFormat(text) {
+        return this.parser.parse(text);
+    }
+    // If you want to print inline, override #optionalNewline with ''
+    optionalNewline() {
+        return '\n';
+    }
+    getBuildSummary() {
+        return `\n\u203A ${this.errors.length} error(s), and ${this.warnings.length} warning(s)\n`;
+    }
+    checkForBundlingErrors(lines) {
+        lines = Array.isArray(lines) ? lines : lines.split('\n');
+        // Find the last line beginning with `Error:` in the logs
+        const lastErrorIndex = findLastIndex(lines);
+        // Unless we find an error, we don't need to do anything
+        if (lastErrorIndex === -1) {
+            return;
+        }
+        // Take 12 lines from the `Error:` line forwards
+        const block = lines.slice(lastErrorIndex, lastErrorIndex + 11).join('\n');
+        const result = this.formatError(block);
+        this.errors.push(result);
+    }
+}
+exports.Formatter = Formatter;
+Formatter.format = format;
+Formatter.formatBreadCrumb = formatBreadCrumb;
+Formatter.getAppRoot = getAppRoot;
+Formatter.highlightLastPathComponent = highlightLastPathComponent;
+Formatter.relativePath = relativePath;
+function findLastIndex(arr) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        if (arr[i].startsWith('Error:')) {
+            return i;
+        }
+    }
+    return -1;
+}
+function formatPaths(config) {
+    const filePath = chalk_1.default.reset.cyan(config.filePath);
+    return (chalk_1.default.dim('(') +
+        filePath +
+        chalk_1.default.dim(`:${[config.line, config.col].filter(Boolean).join(':')})`));
+}
+/**
+ * Split a string like `/Users/foo/bar.m:420:68` into its components.
+ *
+ * @param filePath '/Users/foo/bar.m:420:68'
+ */
+function splitPathInfo(filePathAndLocation) {
+    const [path, line, column] = filePathAndLocation.split(':');
+    return {
+        filePath: path || filePathAndLocation,
+        lineNumber: line,
+        columnNumber: column,
+    };
+}
+function parseOptionalInt(text) {
+    if (!text)
+        return undefined;
+    try {
+        const result = parseInt(text, 10);
+        return isNaN(result) ? undefined : result;
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatWarningOrError({ projectRoot, filePath, reason, cursor, lineText, lineNumber, columnNumber, isError, maxWarningLineLength = 200, }) {
+    var _a;
+    const line = parseOptionalInt(lineNumber) || 0;
+    const column = parseOptionalInt(columnNumber);
+    const color = isError ? chalk_1.default.red : chalk_1.default.yellow;
+    const icon = color(isError ? symbols_1.ERROR : symbols_1.WARNING);
+    const displayFilePath = !filePath
+        ? // If no file path, use null
+            null
+        : // If the file path is inside of the build folder (Hermes), then use absolute path.
+            getAppRoot(filePath)
+                ? filePath
+                : // Otherwise, use relative path
+                    slash(path.relative(projectRoot, filePath));
+    const formattedPath = formatPaths({
+        filePath: displayFilePath,
+        col: column,
+        line,
+    });
+    const pathWithPrefix = `${icon} ${formattedPath}`;
+    const formattedReason = color(grayOutMatch(reason, /(\[-.*?\])/).replace(/(\(.*?\)\s?)/, ''));
+    // Add special case for .jsbundle files that are parsed with Hermes.
+    const isHermes = filePath.endsWith('.jsbundle');
+    const isPreviewTooLong = isHermes || (lineText && lineText.length > maxWarningLineLength);
+    // When the preview is too long, we skip reading the file and attempting to apply
+    // code coloring, this is because it can get very slow.
+    if (isPreviewTooLong) {
+        let previewLine = '';
+        let cursorLine = formattedReason;
+        // Create a curtailed preview line like:
+        // `...transition:'fade'},k._updatePropsStack=function(){clearImmediate(k._updateImmediate),k._updateImmediate...`
+        // If there is no text preview or column number, we can't do anything.
+        if (lineText && column != null) {
+            const rangeWindow = Math.round(Math.max((_a = displayFilePath === null || displayFilePath === void 0 ? void 0 : displayFilePath.length) !== null && _a !== void 0 ? _a : 0, 80) / 2);
+            let minBounds = Math.max(0, column - rangeWindow);
+            const maxBounds = Math.min(minBounds + rangeWindow * 2, lineText.length);
+            previewLine = lineText.slice(minBounds, maxBounds);
+            // If we splice content off the start, then we should append `...`.
+            // This is unlikely to happen since we limit the activation size.
+            if (minBounds > 0) {
+                // Adjust the min bounds so the cursor is aligned after we add the "..."
+                minBounds -= 3;
+                previewLine = chalk_1.default.dim('...') + previewLine;
+            }
+            if (maxBounds < lineText.length) {
+                previewLine += chalk_1.default.dim('...');
+            }
+            // If the column property could be found, then use that to fix the cursor location which is often broken in regex.
+            cursorLine =
+                (column == null ? chalk_1.default.reset(cursor) : fill(column) + chalk_1.default.reset('^')).slice(minBounds) +
+                    ' ' +
+                    formattedReason;
+        }
+        return ['', pathWithPrefix, '', previewLine, cursorLine, chalk_1.default.dim('(warning truncated)')].join('\n');
+    }
+    const { codeFrameColumns } = require('@babel/code-frame');
+    try {
+        const raw = fs.readFileSync(filePath, 'utf8');
+        const location = { start: { line, column } };
+        const framed = codeFrameColumns(raw, location, {
+            // TODO: Support iOS languages: C++, Objc, swift, Ruby, Bash
+            // Maybe something like prism but for terminals?
+            highlightCode: false,
+            // Remove `(_Nonnull, _Nullable, or _Null_unspecified)` options
+            message: formattedReason,
+        });
+        return `\n${pathWithPrefix}\n\n${framed}\n`;
+    }
+    catch {
+        // If the column property could be found, then use that to fix the cursor location which is often broken in regex.
+        const customCursor = column == null ? chalk_1.default.reset(cursor) : fill(column) + chalk_1.default.reset('^');
+        const framed = `${lineText}\n${customCursor} ${formattedReason}`;
+        return `\n${pathWithPrefix}\n\n${framed}\n`;
+    }
+}
+function fill(width) {
+    return width >= 0 ? Array(width).join(' ') : '';
+}
+// Dim values like `[-Wnullability-completeness]`
+function grayOutMatch(text, reg) {
+    return replaceMatch(text, reg, chalk_1.default.gray.dim);
+}
+function replaceMatch(text, reg, callback) {
+    const match = text.match(reg);
+    if (match === null || match === void 0 ? void 0 : match.length) {
+        return text.replace(reg, callback(match[0]));
+    }
+    return text;
+}
+function slash(path) {
+    const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+    const hasNonAscii = /[^\u0000-\u0080]+/.test(path); // eslint-disable-line no-control-regex
+    if (isExtendedLengthPath || hasNonAscii) {
+        return path;
+    }
+    return path.replace(/\\/g, '/');
+}
+//# sourceMappingURL=Formatter.js.map

node_modules/@expo/xcpretty/build/Matchers.d.ts

@@ -0,0 +1,420 @@
+export declare const Matchers: {
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     * `$2` fileName
+     */
+    ANALYZE_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` target
+     * `$2` project
+     * `$3` configuration
+     */
+    BUILD_TARGET_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` target
+     * `$2` project
+     * `$3` configuration
+     */
+    AGGREGATE_TARGET_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` target
+     * `$2` project
+     * `$3` configuration
+     */
+    ANALYZE_TARGET_MATCHER: RegExp;
+    CHECK_DEPENDENCIES_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` command path
+     * `$2` arguments
+     */
+    SHELL_COMMAND_MATCHER: RegExp;
+    /**
+     * @regex Nothing returned here for now
+     */
+    CLEAN_REMOVE_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` target
+     * `$2` project
+     * `$3` configuration
+     */
+    CLEAN_TARGET_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     * `$2` fileName (e.g. Exponent.app)
+     * `$3` target (e.g. ABI39_0_0EXAdsFacebook)
+     * `$4` project (e.g. ABI39_0_0)
+     */
+    CODESIGN_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     */
+    CODESIGN_FRAMEWORK_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` type
+     * `$2` filePath
+     * `$3` fileName (e.g. KWNull.m)
+     * `$4` target (e.g. ABI39_0_0EXAdsFacebook)
+     * `$5` project (e.g. ABI39_0_0)
+     *
+     * The order of extensions is important in order to make alternation greedier.
+     */
+    COMPILE_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` compiler_command
+     * `$2` filePath
+     */
+    COMPILE_COMMAND_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     * `$2` fileName (e.g. MainMenu.xib)
+     */
+    COMPILE_XIB_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     * `$2` fileName (e.g. Main.storyboard)
+     */
+    COMPILE_STORYBOARD_MATCHER: RegExp;
+    /**
+     * `$1` type of copy
+     * `$2` file path 1
+     * `$3` file path 2
+     * `$4` target
+     * `$5` project
+     */
+    ANY_COPY_MATCHER: RegExp;
+    /**
+     * `CompileSwiftSources normal x86_64 com.apple.xcode.tools.swift.compiler (in target 'expo-dev-menu-interface' from project 'Pods')`
+     */
+    COMPILE_SWIFT_SOURCES_MATCHER: RegExp;
+    /**
+     * `EmitSwiftModule normal x86_64 (in target 'expo-dev-menu-interface' from project 'Pods')`
+     */
+    EMIT_SWIFT_MODULE_MATCHER: RegExp;
+    EXECUTED_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = whole message.
+     *
+     * `remark: Incremental compilation has been disabled: it is not compatible with whole module optimization`
+     */
+    REMARK_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     * `$2` = test_suite
+     * `$3` = test_case
+     * `$4` = reason
+     */
+    FAILING_TEST_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     * `$2` = reason
+     */
+    UI_FAILING_TEST_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     */
+    RESTARTING_TESTS_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = dsym
+     */
+    GENERATE_DSYM_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = library
+     */
+    LIBTOOL_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = targetName
+     * `$2` = build_variants (normal, profile, debug)
+     * `$3` = architecture
+     */
+    LINKING_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = test_case
+     * `$3` = time
+     */
+    TEST_CASE_PASSED_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = test_case
+     */
+    TEST_CASE_STARTED_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = test_case
+     */
+    TEST_CASE_PENDING_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = test_case
+     * `$3` = time
+     */
+    TEST_CASE_MEASURED_MATCHER: RegExp;
+    PHASE_SUCCESS_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = script_name
+     */
+    PHASE_SCRIPT_EXECUTION_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     * `$1` = target
+     * `$1` = project
+     */
+    PROCESS_PCH_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     */
+    PROCESS_PCH_COMMAND_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     */
+    PREPROCESS_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     */
+    PBXCP_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     */
+    PROCESS_INFO_PLIST_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = time
+     */
+    TESTS_RUN_COMPLETION_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = time
+     */
+    TEST_SUITE_STARTED_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` test suite name
+     */
+    TEST_SUITE_START_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` fileName
+     */
+    TIFFUTIL_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     * `$2` fileName
+     */
+    TOUCH_MATCHER: RegExp;
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     */
+    WRITE_FILE_MATCHER: RegExp;
+    WRITE_AUXILIARY_FILES: RegExp;
+    Warnings: {
+        /**
+         * @regex Captured groups
+         * `$1` = filePath
+         * `$2` = fileName
+         * `$3` = reason
+         */
+        COMPILE_WARNING_MATCHER: RegExp;
+        COMPILE_WARNING_INLINE_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = ld prefix
+         * `$2` = warning message
+         */
+        LD_WARNING_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole warning
+         */
+        GENERIC_WARNING_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = filePath
+         */
+        MISSING_FILE_COMPILER_WARNING_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` filePath
+         * `$2` fileName
+         */
+        VERSION_MISMATCH: RegExp;
+        /**
+         * @regex Captured groups
+         */
+        MISSING_ARCHITECTURE: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` buildPhase
+         * `$2` filePath
+         * `$3` target
+         * `$4` project
+         */
+        SKIPPING_DUPLICATE_FILE: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` reservedFileDescription (Info.plist or entitlements)
+         * `$2` filePath
+         * `$3` target
+         * `$4` project
+         */
+        TARGETS_FILE_INCLUDED: RegExp;
+        /**
+         * Run script build phase '[CP-User] [Hermes] Replace Hermes for the right configuration, if needed' will be run during every build because it does not specify any outputs. To address this warning, either add output dependencies to the script phase, or configure it to run in every build by unchecking "Based on dependency analysis" in the script phase. (in target 'hermes-engine' from project 'Pods')
+         *
+         * @regex Captured groups
+         * `$1` script name
+         * `$2` target
+         * `$3` project
+         */
+        AMBIGUOUS_RUN_SCRIPT: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole warning
+         */
+        WILL_NOT_BE_CODE_SIGNED_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole warning
+         */
+        LINKER_METHOD_OVERRIDE: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole warning
+         */
+        LINKER_METHOD_SINGLE_OVERRIDE: RegExp;
+    };
+    Errors: {
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        CLANG_ERROR_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        CHECK_DEPENDENCIES_ERRORS_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$0` = whole error
+         * `$1` = profile name
+         * `$2` = entitlement name
+         * `$3` = entitlement type <capability|entitlement>
+         * `$4` = native target
+         * `$5` = native project
+         */
+        UNSUPPORTED_ENTITLEMENT_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        PROVISIONING_PROFILE_REQUIRED_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        NO_CERTIFICATE_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = filePath
+         * `$2` = fileName
+         * `$3` = reason
+         */
+        COMPILE_ERROR_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` cursor (with whitespaces and tildes)
+         */
+        CURSOR_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole error.
+         *
+         * Appears to be related to the installation of files on the connected device
+         */
+        RSYNC_ERROR_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole error.
+         * it varies a lot, not sure if it makes sense to catch everything separately
+         */
+        FATAL_ERROR_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole error.
+         * `$2` = file path
+         */
+        FILE_MISSING_ERROR_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        LD_ERROR_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` file path
+         */
+        LINKER_DUPLICATE_SYMBOLS_LOCATION_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` reason
+         */
+        LINKER_DUPLICATE_SYMBOLS_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` symbol location
+         */
+        LINKER_UNDEFINED_SYMBOL_LOCATION_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` reason
+         */
+        LINKER_UNDEFINED_SYMBOLS_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` reason
+         */
+        PODS_ERROR_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = reference
+         */
+        SYMBOL_REFERENCED_FROM_MATCHER: RegExp;
+        /**
+         * @regex Captured groups
+         * `$1` = error reason
+         */
+        MODULE_INCLUDES_ERROR_MATCHER: RegExp;
+    };
+};

node_modules/@expo/xcpretty/build/Matchers.js

@@ -0,0 +1,424 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Matchers = void 0;
+exports.Matchers = {
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     * `$2` fileName
+     */
+    ANALYZE_MATCHER: /^Analyze(?:Shallow)?\s(.*\/(.*\.(?:m|mm|cc|cpp|c|cxx)))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` target
+     * `$2` project
+     * `$3` configuration
+     */
+    BUILD_TARGET_MATCHER: /^=== BUILD TARGET\s(.*)\sOF PROJECT\s(.*)\sWITH.*CONFIGURATION\s(.*)\s===/m,
+    /**
+     * @regex Captured groups
+     * `$1` target
+     * `$2` project
+     * `$3` configuration
+     */
+    AGGREGATE_TARGET_MATCHER: /^=== BUILD AGGREGATE TARGET\s(.*)\sOF PROJECT\s(.*)\sWITH.*CONFIGURATION\s(.*)\s===/m,
+    /**
+     * @regex Captured groups
+     * `$1` target
+     * `$2` project
+     * `$3` configuration
+     */
+    ANALYZE_TARGET_MATCHER: /^=== ANALYZE TARGET\s(.*)\sOF PROJECT\s(.*)\sWITH.*CONFIGURATION\s(.*)\s===/m,
+    CHECK_DEPENDENCIES_MATCHER: /^Check dependencies/m,
+    /**
+     * @regex Captured groups
+     * `$1` command path
+     * `$2` arguments
+     */
+    SHELL_COMMAND_MATCHER: /^\s{4}(cd|setenv|(?:[\w/:\\\s\-.]+?\/)?[\w-]+)\s(.*)$/m,
+    /**
+     * @regex Nothing returned here for now
+     */
+    CLEAN_REMOVE_MATCHER: /^Clean.Remove/m,
+    /**
+     * @regex Captured groups
+     * `$1` target
+     * `$2` project
+     * `$3` configuration
+     */
+    CLEAN_TARGET_MATCHER: /^=== CLEAN TARGET\s(.*)\sOF PROJECT\s(.*)\sWITH CONFIGURATION\s(.*)\s===/m,
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     * `$2` fileName (e.g. Exponent.app)
+     * `$3` target (e.g. ABI39_0_0EXAdsFacebook)
+     * `$4` project (e.g. ABI39_0_0)
+     */
+    CODESIGN_MATCHER: /^CodeSign\s((?:\\.|[^ ])+\/((?:\\.|[^ ])+\.(?:\w+)))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     */
+    CODESIGN_FRAMEWORK_MATCHER: /^CodeSign\s((?:\\.|[^ ])+\/((?:\\.|[^ ])+\.framework))\/Versions\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` type
+     * `$2` filePath
+     * `$3` fileName (e.g. KWNull.m)
+     * `$4` target (e.g. ABI39_0_0EXAdsFacebook)
+     * `$5` project (e.g. ABI39_0_0)
+     *
+     * The order of extensions is important in order to make alternation greedier.
+     */
+    COMPILE_MATCHER: /^(Compile[\w]+)\s.+?\s((?:\\.|[^ ])+\/((?:\\.|[^ ])+\.(?:mm|m|cpp|cxx|cc|c|swift)))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` compiler_command
+     * `$2` filePath
+     */
+    COMPILE_COMMAND_MATCHER: /^\s*(.*clang\s.*\s-c\s(.*\.(?:m|mm|c|cc|cpp|cxx))\s.*\.o)$/m,
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     * `$2` fileName (e.g. MainMenu.xib)
+     */
+    COMPILE_XIB_MATCHER: /^CompileXIB\s(.*\/(.*\.xib))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     * `$2` fileName (e.g. Main.storyboard)
+     */
+    COMPILE_STORYBOARD_MATCHER: /^CompileStoryboard\s(.*\/([^/].*\.storyboard))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * `$1` type of copy
+     * `$2` file path 1
+     * `$3` file path 2
+     * `$4` target
+     * `$5` project
+     */
+    ANY_COPY_MATCHER: /^(CpResource|CopyStringsFile|CopyPlistFile|CpHeader|PBXCp)\s(\/?.*\/(?:.*\.\w+))\s(\/?.*\/(?:.*\.\w+))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\))?/m,
+    /**
+     * `CompileSwiftSources normal x86_64 com.apple.xcode.tools.swift.compiler (in target 'expo-dev-menu-interface' from project 'Pods')`
+     */
+    COMPILE_SWIFT_SOURCES_MATCHER: /^(CompileSwiftSources)\s([^\s]+) ([^\s]+) ([^\s]+) (?:\(in\s.*target '([^']*)'.*project '([^']*)'\))?/m,
+    /**
+     * `EmitSwiftModule normal x86_64 (in target 'expo-dev-menu-interface' from project 'Pods')`
+     */
+    EMIT_SWIFT_MODULE_MATCHER: /^(EmitSwiftModule)\s([^\s]+) ([^\s]+) (?:\(in\s.*target '([^']*)'.*project '([^']*)'\))?/m,
+    EXECUTED_MATCHER: /^\s*Executed/m,
+    /**
+     * @regex Captured groups
+     * `$1` = whole message.
+     *
+     * `remark: Incremental compilation has been disabled: it is not compatible with whole module optimization`
+     */
+    REMARK_MATCHER: /^remark: (.*)$/m,
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     * `$2` = test_suite
+     * `$3` = test_case
+     * `$4` = reason
+     */
+    FAILING_TEST_MATCHER: /^\s*(.+:\d+):\serror:\s[+-]\[(.*)\s(.*)\]\s:(?:\s'.*'\s\[FAILED\],)?\s(.*)/m,
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     * `$2` = reason
+     */
+    UI_FAILING_TEST_MATCHER: /^\s{4}t = \s+\d+\.\d+s\s+Assertion Failure: (.*:\d+): (.*)$/m,
+    /**
+     * @regex Captured groups
+     */
+    RESTARTING_TESTS_MATCHER: /^Restarting after unexpected exit or crash in.+$/m,
+    /**
+     * @regex Captured groups
+     * `$1` = dsym
+     */
+    GENERATE_DSYM_MATCHER: /^GenerateDSYMFile (\/.*\/(.*\.dSYM))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` = library
+     */
+    LIBTOOL_MATCHER: /^Libtool\s(.*\/(.*\.a))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` = targetName
+     * `$2` = build_variants (normal, profile, debug)
+     * `$3` = architecture
+     */
+    LINKING_MATCHER: /^Ld (\/?.*\/(.+?(?:[^\\](?=\s)))) ([^(|\s]*)(?:\s([^(|\s]*)\s)?\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = test_case
+     * `$3` = time
+     */
+    TEST_CASE_PASSED_MATCHER: /^\s*Test Case\s'-\[(.*)\s(.*)\]'\spassed\s\((\d*\.\d{3})\sseconds\)/m,
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = test_case
+     */
+    TEST_CASE_STARTED_MATCHER: /^Test Case '-\[(.*) (.*)\]' started.$/m,
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = test_case
+     */
+    TEST_CASE_PENDING_MATCHER: /^Test Case\s'-\[(.*)\s(.*)PENDING\]'\spassed/m,
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = test_case
+     * `$3` = time
+     */
+    TEST_CASE_MEASURED_MATCHER: /^[^:]*:[^:]*:\sTest Case\s'-\[(.*)\s(.*)\]'\smeasured\s\[Time,\sseconds\]\saverage:\s(\d*\.\d{3}),/m,
+    PHASE_SUCCESS_MATCHER: /^\*\*\s(.*)\sSUCCEEDED\s\*\*(?:\s+\[(.*)\])?/m,
+    /**
+     * @regex Captured groups
+     * `$1` = script_name
+     */
+    PHASE_SCRIPT_EXECUTION_MATCHER: /^PhaseScriptExecution\s((?:\\ |\S)*)\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\))?/m,
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     * `$1` = target
+     * `$1` = project
+     */
+    PROCESS_PCH_MATCHER: /^ProcessPCH(?:\+\+)? (\/?.*\/([^(|\s|\n]*(?:.pch.(?:g|p)ch)))(?:\s(.*.pch))? ([^(|\s]*)(?:\s([^(|\s]*)\s)?\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     */
+    PROCESS_PCH_COMMAND_MATCHER: /^\s*.*\/usr\/bin\/clang\s.*\s-c\s(.*)\s-o\s.*/m,
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     */
+    PREPROCESS_MATCHER: /^Preprocess\s(?:(?:\\ |[^ ])*)\s((?:\\ |[^ ])*)$/m,
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     */
+    PBXCP_MATCHER: /^PBXCp\s((?:\\ |[^ ])*)/m,
+    /**
+     * @regex Captured groups
+     * `$1` = file
+     */
+    PROCESS_INFO_PLIST_MATCHER: /^ProcessInfoPlistFile\s.*\.plist\s(.*\/+(.*\.plist))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = time
+     */
+    TESTS_RUN_COMPLETION_MATCHER: /^\s*Test Suite '(?:.*\/)?(.*[ox]ctest.*)' (finished|passed|failed) at (.*)/m,
+    /**
+     * @regex Captured groups
+     * `$1` = suite
+     * `$2` = time
+     */
+    TEST_SUITE_STARTED_MATCHER: /^\s*Test Suite '(?:.*\/)?(.*[ox]ctest.*)' started at(.*)/m,
+    /**
+     * @regex Captured groups
+     * `$1` test suite name
+     */
+    TEST_SUITE_START_MATCHER: /^\s*Test Suite '(.*)' started at/m,
+    /**
+     * @regex Captured groups
+     * `$1` fileName
+     */
+    TIFFUTIL_MATCHER: /^TiffUtil\s(.*)/m,
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     * `$2` fileName
+     */
+    TOUCH_MATCHER: /^Touch\s(.*\/([^(|\n]+))\s?[^(]+(?:\(in\s.*target '([^']*)'.*project '([^']*)'\))?/m,
+    /**
+     * @regex Captured groups
+     * `$1` filePath
+     */
+    WRITE_FILE_MATCHER: /^write-file\s(.*)/m,
+    WRITE_AUXILIARY_FILES: /^Write auxiliary files/m,
+    Warnings: {
+        /**
+         * @regex Captured groups
+         * `$1` = filePath
+         * `$2` = fileName
+         * `$3` = reason
+         */
+        COMPILE_WARNING_MATCHER: /^(\/.+\/(.*):.*:.*):\swarning:\s(.+?(?=\(in)?)(?:\(in target '([^']*)' from project '([^']*)'\))?$/m,
+        COMPILE_WARNING_INLINE_MATCHER: /^(\/.+\/(.*):.*:.*):\swarning:\s(.+?(?=\(in)?)(?:\(in target '([^']*)' from project '([^']*)'\))$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = ld prefix
+         * `$2` = warning message
+         */
+        LD_WARNING_MATCHER: /^(ld: )warning: (.*)/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole warning
+         */
+        GENERIC_WARNING_MATCHER: /^warning:\s(.*)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = filePath
+         */
+        MISSING_FILE_COMPILER_WARNING_MATCHER: /(.*): No such file or directory$/m,
+        /**
+         * @regex Captured groups
+         * `$1` filePath
+         * `$2` fileName
+         */
+        VERSION_MISMATCH: /^The\s(\w*)\s.*'([^']*)'.*to (\d+\.?\d+\.?\d*),.*(\d+\.?\d+\.?\d*) to (\d+\.?\d+\.?\d*).\s.*target '([^']*)'.*project '([^']*)'/m,
+        /**
+         * @regex Captured groups
+         */
+        MISSING_ARCHITECTURE: /^\[CP\] Vendored binary\s'([^']*)'.*contains architectures \(([\w\d\s]+)\) none of which match the current build architectures \(([\w\d\s]+)\)/m,
+        /**
+         * @regex Captured groups
+         * `$1` buildPhase
+         * `$2` filePath
+         * `$3` target
+         * `$4` project
+         */
+        SKIPPING_DUPLICATE_FILE: /^Skipping duplicate build file in ([A-Za-z\s]+) build phase: (.*) \(in\s.*target '([^']*)'.*project '([^']*)'/m,
+        /**
+         * @regex Captured groups
+         * `$1` reservedFileDescription (Info.plist or entitlements)
+         * `$2` filePath
+         * `$3` target
+         * `$4` project
+         */
+        TARGETS_FILE_INCLUDED: /^The Copy Bundle Resources build phase contains this target's (.*) file\s?'(.*)'. \(in\s.*target '([^']*)'.*project '([^']*)'/m,
+        /**
+         * Run script build phase '[CP-User] [Hermes] Replace Hermes for the right configuration, if needed' will be run during every build because it does not specify any outputs. To address this warning, either add output dependencies to the script phase, or configure it to run in every build by unchecking "Based on dependency analysis" in the script phase. (in target 'hermes-engine' from project 'Pods')
+         *
+         * @regex Captured groups
+         * `$1` script name
+         * `$2` target
+         * `$3` project
+         */
+        AMBIGUOUS_RUN_SCRIPT: /^Run script build phase '(.+)' will be run during every build because it does not specify any outputs\. To address this warning, either add output dependencies to the script phase, or configure it to run in every build by unchecking "Based on dependency analysis" in the script phase\. \(in\s.*target '([^']*)'.*project '([^']*)'/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole warning
+         */
+        WILL_NOT_BE_CODE_SIGNED_MATCHER: /^(.* will not be code signed because .*)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole warning
+         */
+        LINKER_METHOD_OVERRIDE: /method '(.*)' in category from (?:(.*\/(?:.*\.\w))(?:\((.*\.\w)\)))\soverrides method from class in (?:(.*\/(?:.*\.\w))(?:\((.*\.\w)\)))/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole warning
+         */
+        LINKER_METHOD_SINGLE_OVERRIDE: /method '(.*)' in category from (?:(.*\/(?:.*\.\w))(?:\((.*\.\w)\)))\sconflicts with same method from another category/m,
+    },
+    Errors: {
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        CLANG_ERROR_MATCHER: /^(clang: error:.*)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        CHECK_DEPENDENCIES_ERRORS_MATCHER: /^(Code\s?Sign error:.*|Code signing is required for product type .* in SDK .*|No profile matching .* found:.*|Provisioning profile .* doesn't .*|Swift is unavailable on .*|.?Use Legacy Swift Language Version.*)$/m,
+        /**
+         * @regex Captured groups
+         * `$0` = whole error
+         * `$1` = profile name
+         * `$2` = entitlement name
+         * `$3` = entitlement type <capability|entitlement>
+         * `$4` = native target
+         * `$5` = native project
+         */
+        UNSUPPORTED_ENTITLEMENT_MATCHER: /^error: Provisioning profile (.*) doesn't (?:support|include) the (.*) (capability|entitlement)\.(?:\s\(in\s.*target '([^']*)'.*project '([^']*)'\)$)?/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        PROVISIONING_PROFILE_REQUIRED_MATCHER: /^(.*requires a provisioning profile.*)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        NO_CERTIFICATE_MATCHER: /^(No certificate matching.*)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = filePath
+         * `$2` = fileName
+         * `$3` = reason
+         */
+        COMPILE_ERROR_MATCHER: /^(\/.+\/(.*):.*:.*):\s(?:fatal\s)?error:\s(.+?(?=\(in)?)(?:\(in target '([^']*)' from project '([^']*)'\))?$/m,
+        /**
+         * @regex Captured groups
+         * `$1` cursor (with whitespaces and tildes)
+         */
+        CURSOR_MATCHER: /^(?:\s+\|)?([\s~]*\^[\s~]*)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole error.
+         *
+         * Appears to be related to the installation of files on the connected device
+         */
+        RSYNC_ERROR_MATCHER: /^(rsync error:.*)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole error.
+         * it varies a lot, not sure if it makes sense to catch everything separately
+         */
+        FATAL_ERROR_MATCHER: /^(fatal error:.*)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole error.
+         * `$2` = file path
+         */
+        FILE_MISSING_ERROR_MATCHER: /^<unknown>:0:\s(error:\s.*)\s'(\/.+\/.*\..*)'$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = whole error
+         */
+        LD_ERROR_MATCHER: /^(ld:.*)/m,
+        /**
+         * @regex Captured groups
+         * `$1` file path
+         */
+        LINKER_DUPLICATE_SYMBOLS_LOCATION_MATCHER: /^\s+(\/.*\.o[)]?)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` reason
+         */
+        LINKER_DUPLICATE_SYMBOLS_MATCHER: /^((duplicate symbol|ld: warning: duplicate symbol) .*):$/m,
+        /**
+         * @regex Captured groups
+         * `$1` symbol location
+         */
+        LINKER_UNDEFINED_SYMBOL_LOCATION_MATCHER: /^(.* in .*\.o[)]?)$/m,
+        /**
+         * @regex Captured groups
+         * `$1` reason
+         */
+        LINKER_UNDEFINED_SYMBOLS_MATCHER: /^(Undefined symbols for architecture .*):$/m,
+        /**
+         * @regex Captured groups
+         * `$1` reason
+         */
+        PODS_ERROR_MATCHER: /^(error:\s.*)/m,
+        /**
+         * @regex Captured groups
+         * `$1` = reference
+         */
+        SYMBOL_REFERENCED_FROM_MATCHER: /\s+"(.*)", referenced from:$/m,
+        /**
+         * @regex Captured groups
+         * `$1` = error reason
+         */
+        MODULE_INCLUDES_ERROR_MATCHER: /^<module-includes>:.*?:.*?:\s(?:fatal\s)?(error:\s.*)$/m,
+    },
+};
+//# sourceMappingURL=Matchers.js.map

node_modules/@expo/xcpretty/build/MetroParser.d.ts

@@ -0,0 +1,10 @@
+import { Formatter } from './Formatter';
+import { Parser } from './Parser';
+export declare class MetroParser extends Parser {
+    formatter: Formatter;
+    private isCollectingMetroError;
+    private metroError;
+    constructor(formatter: Formatter);
+    parse(text: string): void | string;
+    checkMetroError(text: string): string;
+}

node_modules/@expo/xcpretty/build/MetroParser.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetroParser = void 0;
+const Parser_1 = require("./Parser");
+const switchRegex_1 = require("./switchRegex");
+class MetroParser extends Parser_1.Parser {
+    constructor(formatter) {
+        super(formatter);
+        this.formatter = formatter;
+        this.isCollectingMetroError = false;
+        this.metroError = [];
+    }
+    parse(text) {
+        const results = this.checkMetroError(text);
+        if (results) {
+            return results;
+        }
+        return super.parse(text);
+    }
+    // Error for the build script wrapper in expo-updates that catches metro bundler errors.
+    // This can be repro'd by importing a file that doesn't exist, then building.
+    // Metro will fail to generate the JS bundle, and throw an error that should be caught here.
+    checkMetroError(text) {
+        // In expo-updates, we wrap the bundler script and add regex around the error message so we can present it nicely to the user.
+        return (0, switchRegex_1.switchRegex)(text, [
+            [
+                /@build-script-error-begin/m,
+                () => {
+                    this.isCollectingMetroError = true;
+                },
+            ],
+            [
+                /@build-script-error-end/m,
+                () => {
+                    const results = this.metroError.join('\n');
+                    // Reset the metro collection error array (should never need this).
+                    this.isCollectingMetroError = false;
+                    this.metroError = [];
+                    if ('formatMetroAssetCollectionError' in this.formatter) {
+                        return this.formatter.formatMetroAssetCollectionError(results);
+                    }
+                    throw new Error('Current `@expo/xcpretty` formatter cannot handle Metro errors');
+                },
+            ],
+            [
+                null,
+                () => {
+                    // Collect all the lines in the metro build error
+                    if (this.isCollectingMetroError) {
+                        let results = text;
+                        if (!this.metroError.length) {
+                            const match = text.match(/Error loading assets JSON from Metro.*steps correctly.((.|\n)*)/m);
+                            if (match && match[1]) {
+                                results = match[1].trim();
+                            }
+                        }
+                        this.metroError.push(results);
+                    }
+                },
+            ],
+        ]);
+    }
+}
+exports.MetroParser = MetroParser;
+//# sourceMappingURL=MetroParser.js.map

node_modules/@expo/xcpretty/build/MetroParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetroParser.js","sourceRoot":"","sources":["../src/MetroParser.ts"],"names":[],"mappings":";;;AACA,qCAAkC;AAClC,+CAA4C;AAE5C,MAAa,WAAY,SAAQ,eAAM;IAIrC,YAAmB,SAAoB;QACrC,KAAK,CAAC,SAAS,CAAC,CAAC;QADA,cAAS,GAAT,SAAS,CAAW;QAH/B,2BAAsB,GAAG,KAAK,CAAC;QAC/B,eAAU,GAAa,EAAE,CAAC;IAIlC,CAAC;IAED,KAAK,CAAC,IAAY;QAChB,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED,wFAAwF;IACxF,6EAA6E;IAC7E,4FAA4F;IAC5F,eAAe,CAAC,IAAY;QAC1B,8HAA8H;QAC9H,OAAO,IAAA,yBAAW,EAAC,IAAI,EAAE;YACvB;gBACE,4BAA4B;gBAC5B,GAAG,EAAE;oBACH,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;gBACrC,CAAC;aACF;YACD;gBACE,0BAA0B;gBAC1B,GAAG,EAAE;oBACH,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC3C,mEAAmE;oBACnE,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;oBACpC,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;oBACrB,IAAI,iCAAiC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;wBACxD,OAAQ,IAAI,CAAC,SAAiB,CAAC,+BAA+B,CAAC,OAAO,CAAC,CAAC;oBAC1E,CAAC;oBACD,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;gBACnF,CAAC;aACF;YACD;gBACE,IAAI;gBACJ,GAAG,EAAE;oBACH,iDAAiD;oBACjD,IAAI,IAAI,CAAC,sBAAsB,EAAE,CAAC;wBAChC,IAAI,OAAO,GAAG,IAAI,CAAC;wBACnB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;4BAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CACtB,kEAAkE,CACnE,CAAC;4BACF,IAAI,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;gCACtB,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;4BAC5B,CAAC;wBACH,CAAC;wBACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBAChC,CAAC;gBACH,CAAC;aACF;SACF,CAAC,CAAC;IACL,CAAC;CACF;AA7DD,kCA6DC","sourcesContent":["import { Formatter } from './Formatter';\nimport { Parser } from './Parser';\nimport { switchRegex } from './switchRegex';\n\nexport class MetroParser extends Parser {\n  private isCollectingMetroError = false;\n  private metroError: string[] = [];\n\n  constructor(public formatter: Formatter) {\n    super(formatter);\n  }\n\n  parse(text: string): void | string {\n    const results = this.checkMetroError(text);\n    if (results) {\n      return results;\n    }\n    return super.parse(text);\n  }\n\n  // Error for the build script wrapper in expo-updates that catches metro bundler errors.\n  // This can be repro'd by importing a file that doesn't exist, then building.\n  // Metro will fail to generate the JS bundle, and throw an error that should be caught here.\n  checkMetroError(text: string) {\n    // In expo-updates, we wrap the bundler script and add regex around the error message so we can present it nicely to the user.\n    return switchRegex(text, [\n      [\n        /@build-script-error-begin/m,\n        () => {\n          this.isCollectingMetroError = true;\n        },\n      ],\n      [\n        /@build-script-error-end/m,\n        () => {\n          const results = this.metroError.join('\\n');\n          // Reset the metro collection error array (should never need this).\n          this.isCollectingMetroError = false;\n          this.metroError = [];\n          if ('formatMetroAssetCollectionError' in this.formatter) {\n            return (this.formatter as any).formatMetroAssetCollectionError(results);\n          }\n          throw new Error('Current `@expo/xcpretty` formatter cannot handle Metro errors');\n        },\n      ],\n      [\n        null,\n        () => {\n          // Collect all the lines in the metro build error\n          if (this.isCollectingMetroError) {\n            let results = text;\n            if (!this.metroError.length) {\n              const match = text.match(\n                /Error loading assets JSON from Metro.*steps correctly.((.|\\n)*)/m\n              );\n              if (match && match[1]) {\n                results = match[1].trim();\n              }\n            }\n            this.metroError.push(results);\n          }\n        },\n      ],\n    ]);\n  }\n}\n"]}

node_modules/@expo/xcpretty/build/Parser.d.ts

@@ -0,0 +1,52 @@
+import { Formatter } from './Formatter';
+export type Failure = {
+    filePath: string;
+    testCase: string;
+    reason: string;
+};
+interface TestIssue {
+    reason?: string;
+    cursor?: string;
+    line?: string;
+    filePath?: string;
+    fileName?: string;
+}
+interface LinkerFailure {
+    message?: string;
+    symbol?: string;
+    reference?: string;
+    files: string[];
+    isWarning?: boolean;
+}
+export declare class Parser {
+    formatter: Formatter;
+    testSuite?: string;
+    testCase?: string;
+    testsDone?: boolean;
+    formattedSummary: boolean;
+    failures: Record<string, Failure[]>;
+    formattingLinkerFailure?: boolean;
+    formattingWarning?: boolean;
+    formattingError?: boolean;
+    linkerFailure: LinkerFailure;
+    currentIssue: TestIssue;
+    constructor(formatter: Formatter);
+    parse(text: string): void | string;
+    private updateTestState;
+    private updateErrorState;
+    private updateLinkerFailureState;
+    private shouldFormatError;
+    private shouldFormatWarning;
+    private errorOrWarningIsPresent;
+    private shouldFormatUndefinedSymbols;
+    private shouldFormatDuplicateSymbols;
+    private formatCompileError;
+    private formatCompileWarning;
+    private formatUndefinedSymbols;
+    private formatDuplicateSymbols;
+    private resetLinkerFormatState;
+    private storeFailure;
+    private formatSummaryIfNeeded;
+    private shouldFormatSummary;
+}
+export {};

node_modules/@expo/xcpretty/build/Parser.js

@@ -0,0 +1,549 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const path_1 = require("path");
+const Matchers_1 = require("./Matchers");
+const switchRegex_1 = require("./switchRegex");
+function unescaped(args) {
+    return args.map(v => v.replace(/\\/g, ''));
+}
+class Parser {
+    constructor(formatter) {
+        this.formatter = formatter;
+        this.formattedSummary = false;
+        this.failures = {};
+        this.linkerFailure = {
+            files: [],
+        };
+        this.currentIssue = {};
+    }
+    parse(text) {
+        const matchedErrorResults = this.updateErrorState(text);
+        if (this.shouldFormatWarning()) {
+            return this.formatCompileWarning();
+        }
+        if (this.shouldFormatError()) {
+            return this.formatCompileError();
+        }
+        if (matchedErrorResults) {
+            return '';
+        }
+        const matchedLinkerResults = this.updateLinkerFailureState(text);
+        if (this.shouldFormatUndefinedSymbols()) {
+            return this.formatUndefinedSymbols();
+        }
+        if (this.shouldFormatDuplicateSymbols()) {
+            return this.formatDuplicateSymbols();
+        }
+        if (matchedLinkerResults) {
+            return '';
+        }
+        this.updateTestState(text);
+        const { formatter } = this;
+        return (0, switchRegex_1.switchRegex)(text, [
+            [
+                Matchers_1.Matchers.ANALYZE_MATCHER,
+                ([, $1, $2, $3, $4]) => formatter.formatFileOperation({
+                    type: 'Analyze',
+                    filePath: $1,
+                    fileName: $2,
+                    target: $3,
+                    project: $4,
+                }),
+            ],
+            [
+                Matchers_1.Matchers.BUILD_TARGET_MATCHER,
+                ([, $1, $2, $3]) => formatter.formatTarget({
+                    type: 'Build',
+                    configuration: $3,
+                    target: $1,
+                    project: $2,
+                }),
+            ],
+            [
+                Matchers_1.Matchers.AGGREGATE_TARGET_MATCHER,
+                ([, $1, $2, $3]) => formatter.formatTarget({
+                    type: 'Aggregate',
+                    configuration: $3,
+                    target: $1,
+                    project: $2,
+                }),
+            ],
+            [
+                Matchers_1.Matchers.ANALYZE_TARGET_MATCHER,
+                ([, $1, $2, $3]) => formatter.formatTarget({
+                    type: 'Analyze',
+                    configuration: $3,
+                    target: $1,
+                    project: $2,
+                }),
+            ],
+            [Matchers_1.Matchers.CLEAN_REMOVE_MATCHER, ([$0]) => formatter.formatCleanRemove($0)],
+            [
+                Matchers_1.Matchers.CLEAN_TARGET_MATCHER,
+                ([, $1, $2, $3]) => formatter.formatTarget({
+                    type: 'Clean',
+                    configuration: $3,
+                    target: $1,
+                    project: $2,
+                }),
+            ],
+            [
+                Matchers_1.Matchers.ANY_COPY_MATCHER,
+                ([, $1, $2, $3, $4, $5]) => {
+                    let from = $3;
+                    let to = $2;
+                    // Flipped with CpResource and CpHeader
+                    if ($1.startsWith('Cp')) {
+                        from = $2;
+                        to = $3;
+                    }
+                    return formatter.formatCopy({ type: $1, from, to, target: $4, project: $5 });
+                },
+            ],
+            [Matchers_1.Matchers.CHECK_DEPENDENCIES_MATCHER, ([$0]) => formatter.formatCheckDependencies($0)],
+            [Matchers_1.Matchers.Errors.CLANG_ERROR_MATCHER, ([, $1]) => formatter.formatError($1)],
+            [
+                Matchers_1.Matchers.CODESIGN_FRAMEWORK_MATCHER,
+                ([, $1, $2, $3, $4]) => formatter.formatFileOperation({
+                    type: 'CodeSign',
+                    fileName: $2,
+                    filePath: $1,
+                    target: $3,
+                    project: $4,
+                }),
+            ],
+            [
+                Matchers_1.Matchers.CODESIGN_MATCHER,
+                ([, $1, $2, $3, $4]) => formatter.formatFileOperation({
+                    type: 'CodeSign',
+                    fileName: $2,
+                    filePath: $1,
+                    target: $3,
+                    project: $4,
+                }),
+            ],
+            [Matchers_1.Matchers.Errors.CHECK_DEPENDENCIES_ERRORS_MATCHER, ([, $1]) => formatter.formatError($1)],
+            [
+                Matchers_1.Matchers.Errors.PROVISIONING_PROFILE_REQUIRED_MATCHER,
+                ([, $1]) => formatter.formatError($1),
+            ],
+            [Matchers_1.Matchers.Errors.NO_CERTIFICATE_MATCHER, ([, $1]) => formatter.formatError($1)],
+            [
+                Matchers_1.Matchers.COMPILE_MATCHER,
+                ([, $1, $2, $3, $4, $5]) => formatter.formatFileOperation({
+                    type: $1,
+                    fileName: $3,
+                    filePath: $2,
+                    target: $4,
+                    project: $5,
+                }),
+            ],
+            [Matchers_1.Matchers.COMPILE_COMMAND_MATCHER, ([, $1, $2]) => formatter.formatCompileCommand($1, $2)],
+            [
+                Matchers_1.Matchers.COMPILE_XIB_MATCHER,
+                ([, $1, $2, $3, $4]) => formatter.formatFileOperation({
+                    type: 'CompileXIB',
+                    fileName: $2,
+                    filePath: $1,
+                    target: $3,
+                    project: $4,
+                }),
+            ],
+            [
+                Matchers_1.Matchers.COMPILE_STORYBOARD_MATCHER,
+                ([, $1, $2, $3, $4]) => formatter.formatFileOperation({
+                    type: 'CompileStoryboard',
+                    fileName: $2,
+                    filePath: $1,
+                    target: $3,
+                    project: $4,
+                }),
+            ],
+            [Matchers_1.Matchers.EXECUTED_MATCHER, () => this.formatSummaryIfNeeded(text)],
+            [Matchers_1.Matchers.REMARK_MATCHER, ([, $1]) => formatter.formatRemark($1)],
+            [
+                Matchers_1.Matchers.COMPILE_SWIFT_SOURCES_MATCHER,
+                ([, , $2, $3, $4, $5, $6]) => formatter.formatCompileSwiftSources($2, $3, $4, $5, $6),
+            ],
+            [
+                Matchers_1.Matchers.EMIT_SWIFT_MODULE_MATCHER,
+                ([, , $2, $3, $4, $5]) => formatter.formatEmitSwiftModule($2, $3, $4, $5),
+            ],
+            [
+                Matchers_1.Matchers.RESTARTING_TESTS_MATCHER,
+                () => formatter.formatFailingTest(this.testSuite, this.testCase, 'Test crashed', 'n/a'),
+            ],
+            [
+                Matchers_1.Matchers.UI_FAILING_TEST_MATCHER,
+                ([, $1, $2]) => formatter.formatFailingTest(this.testSuite, this.testCase, $2, $1),
+            ],
+            [
+                Matchers_1.Matchers.FAILING_TEST_MATCHER,
+                ([, $1, $2, $3, $4]) => formatter.formatFailingTest($2, $3, $4, $1),
+            ],
+            [Matchers_1.Matchers.Errors.FATAL_ERROR_MATCHER, ([, $1]) => formatter.formatError($1)],
+            [Matchers_1.Matchers.Errors.RSYNC_ERROR_MATCHER, ([, $1]) => formatter.formatError($1)],
+            [
+                Matchers_1.Matchers.Errors.FILE_MISSING_ERROR_MATCHER,
+                ([, $1, $2]) => formatter.formatFileMissingError($1, $2),
+            ],
+            [
+                Matchers_1.Matchers.GENERATE_DSYM_MATCHER,
+                ([, $1, $2, $3, $4]) => formatter.formatFileOperation({
+                    type: 'GenerateDSYMFile',
+                    filePath: $1,
+                    fileName: $2,
+                    target: $3,
+                    project: $4,
+                }),
+            ],
+            [
+                Matchers_1.Matchers.Warnings.LD_WARNING_MATCHER,
+                ([, $1, $2]) => {
+                    // Skip printing ld warnings when we're collecting multiline ld duplicate symbol warnings.
+                    if (this.linkerFailure.isWarning) {
+                        return '';
+                    }
+                    return formatter.formatLdWarning($1 + $2);
+                },
+            ],
+            [Matchers_1.Matchers.Errors.LD_ERROR_MATCHER, ([, $1]) => formatter.formatError($1)],
+            [
+                Matchers_1.Matchers.LIBTOOL_MATCHER,
+                ([, $1, $2, $3, $4]) => formatter.formatFileOperation({
+                    type: 'Libtool',
+                    filePath: $1,
+                    fileName: $2,
+                    target: $3,
+                    project: $4,
+                }),
+            ],
+            [
+                Matchers_1.Matchers.LINKING_MATCHER,
+                ([, $1, $2, $3, $4, $5, $6]) => formatter.formatFileOperation({
+                    type: 'Ld',
+                    filePath: $1,
+                    fileName: $2,
+                    linkType: $3,
+                    arch: $4,
+                    target: $5,
+                    project: $6,
+                }),
+            ],
+            [Matchers_1.Matchers.Errors.MODULE_INCLUDES_ERROR_MATCHER, ([, $1]) => formatter.formatError($1)],
+            [
+                Matchers_1.Matchers.TEST_CASE_MEASURED_MATCHER,
+                ([, $1, $2, $3]) => formatter.formatMeasuringTest($1, $2, $3),
+            ],
+            [Matchers_1.Matchers.TEST_CASE_PENDING_MATCHER, ([, $1, $2]) => formatter.formatPendingTest($1, $2)],
+            [
+                Matchers_1.Matchers.TEST_CASE_PASSED_MATCHER,
+                ([, $1, $2, $3]) => formatter.formatPassingTest($1, $2, $3),
+            ],
+            [Matchers_1.Matchers.Errors.PODS_ERROR_MATCHER, ([, $1]) => formatter.formatError($1)],
+            [
+                Matchers_1.Matchers.PROCESS_INFO_PLIST_MATCHER,
+                ([, $1, $2, $3, $4]) => {
+                    const [filePath, fileName] = unescaped([$1, $2]);
+                    return formatter.formatFileOperation({
+                        type: 'ProcessInfoPlistFile',
+                        fileName,
+                        filePath,
+                        target: $3,
+                        project: $4,
+                    });
+                },
+            ],
+            [
+                Matchers_1.Matchers.PHASE_SCRIPT_EXECUTION_MATCHER,
+                // @ts-ignore: spread
+                ([, $1, $2, $3]) => formatter.formatPhaseScriptExecution(...unescaped([$1]), $2, $3),
+            ],
+            [Matchers_1.Matchers.PHASE_SUCCESS_MATCHER, ([, $1, $2]) => formatter.formatPhaseSuccess($1, $2)],
+            [
+                Matchers_1.Matchers.PROCESS_PCH_MATCHER,
+                ([, 
+                // pch / gch
+                $1, 
+                // filename
+                $2, 
+                // extra pch
+                $3, 
+                // type
+                $4, 
+                // arch
+                $5, $6, $7,]) => formatter.formatFileOperation({
+                    type: 'ProcessPCH',
+                    filePath: $1,
+                    fileName: $2,
+                    linkType: $4,
+                    arch: $5,
+                    target: $6,
+                    project: $7,
+                }),
+            ],
+            [Matchers_1.Matchers.PROCESS_PCH_COMMAND_MATCHER, ([, $1]) => formatter.formatProcessPchCommand($1)],
+            [Matchers_1.Matchers.PREPROCESS_MATCHER, ([, $1]) => formatter.formatPreprocess($1)],
+            [
+                Matchers_1.Matchers.TESTS_RUN_COMPLETION_MATCHER,
+                ([, $1, , $3]) => formatter.formatTestRunFinished($1, $3),
+            ],
+            [Matchers_1.Matchers.TEST_SUITE_STARTED_MATCHER, ([, $1]) => formatter.formatTestRunStarted($1)],
+            [Matchers_1.Matchers.TEST_SUITE_START_MATCHER, ([, $1]) => formatter.formatTestSuiteStarted($1)],
+            [Matchers_1.Matchers.TIFFUTIL_MATCHER, ([, $1]) => formatter.formatTiffutil($1)],
+            [
+                Matchers_1.Matchers.TOUCH_MATCHER,
+                ([, $1, $2, $3, $4]) => formatter.formatFileOperation({
+                    type: 'Touch',
+                    filePath: $1,
+                    // file name is undefined in newer projects
+                    fileName: $2 || (0, path_1.basename)($1 || ''),
+                    target: $3,
+                    project: $4,
+                }),
+            ],
+            [Matchers_1.Matchers.WRITE_FILE_MATCHER, ([, $1]) => formatter.formatWriteFile($1)],
+            [Matchers_1.Matchers.WRITE_AUXILIARY_FILES, ([$0]) => formatter.formatWriteAuxiliaryFiles($0)],
+            [Matchers_1.Matchers.SHELL_COMMAND_MATCHER, ([, $1, $2]) => formatter.formatShellCommand($1, $2)],
+            [Matchers_1.Matchers.Warnings.GENERIC_WARNING_MATCHER, ([, $1]) => formatter.formatWarning($1)],
+            [
+                Matchers_1.Matchers.Warnings.WILL_NOT_BE_CODE_SIGNED_MATCHER,
+                ([, $1]) => formatter.formatWillNotBeCodeSigned($1),
+            ],
+            [
+                Matchers_1.Matchers.Errors.COMPILE_ERROR_MATCHER,
+                ([, $1, $2, $3, $4, $5]) => {
+                    return formatter.formatSingleLineCompileIssue('error', $1, $2, $3, $4, $5);
+                },
+            ],
+            [
+                Matchers_1.Matchers.Warnings.COMPILE_WARNING_INLINE_MATCHER,
+                ([, $1, $2, $3, $4, $5]) => {
+                    return formatter.formatSingleLineCompileIssue('warning', $1, $2, $3, $4, $5);
+                },
+            ],
+            [null, () => formatter.formatOther(text)],
+        ]);
+    }
+    updateTestState(text) {
+        return (0, switchRegex_1.switchRegex)(text, [
+            [
+                Matchers_1.Matchers.TEST_SUITE_STARTED_MATCHER,
+                () => {
+                    this.testsDone = false;
+                    this.formattedSummary = false;
+                    this.failures = {};
+                },
+            ],
+            [
+                Matchers_1.Matchers.TEST_CASE_STARTED_MATCHER,
+                ([, $1, $2]) => {
+                    this.testSuite = $1;
+                    this.testCase = $2;
+                },
+            ],
+            [
+                Matchers_1.Matchers.TESTS_RUN_COMPLETION_MATCHER,
+                () => {
+                    this.testsDone = true;
+                },
+            ],
+            [
+                Matchers_1.Matchers.FAILING_TEST_MATCHER,
+                ([, $1, $2, $3, $4]) => this.storeFailure({ file: $1, testSuite: $2, testCase: $3, reason: $4 }),
+            ],
+            [
+                Matchers_1.Matchers.UI_FAILING_TEST_MATCHER,
+                ([, $1, $2]) => this.storeFailure({
+                    file: $1,
+                    testSuite: this.testSuite,
+                    testCase: this.testCase,
+                    reason: $2,
+                }),
+            ],
+            [
+                Matchers_1.Matchers.RESTARTING_TESTS_MATCHER,
+                () => this.storeFailure({
+                    file: 'n/a',
+                    testSuite: this.testSuite,
+                    testCase: this.testCase,
+                    reason: 'Test crashed',
+                }),
+            ],
+        ], true);
+    }
+    updateErrorState(text) {
+        const updateError = ([, $1, $2, $3]) => {
+            this.currentIssue.reason = $3;
+            this.currentIssue.filePath = $1;
+            this.currentIssue.fileName = $2;
+        };
+        const results = (0, switchRegex_1.switchRegex)(text, [
+            [
+                Matchers_1.Matchers.Errors.COMPILE_ERROR_MATCHER,
+                matches => {
+                    // Prevent matching a one-liner error.
+                    if (matches === null || matches === void 0 ? void 0 : matches[4]) {
+                        return 'unmatched';
+                    }
+                    this.formattingError = true;
+                    updateError(matches);
+                    return null;
+                },
+            ],
+            [
+                Matchers_1.Matchers.Warnings.COMPILE_WARNING_MATCHER,
+                matches => {
+                    // Prevent matching a one-liner warning.
+                    if (matches === null || matches === void 0 ? void 0 : matches[4]) {
+                        return 'unmatched';
+                    }
+                    this.formattingWarning = true;
+                    updateError(matches);
+                    return null;
+                },
+            ],
+            [
+                Matchers_1.Matchers.Errors.CURSOR_MATCHER,
+                ([, $1]) => {
+                    // is trim === chomp ?
+                    this.currentIssue.cursor = $1;
+                },
+            ],
+            [
+                null,
+                () => {
+                    var _a, _b;
+                    if (this.formattingError || this.formattingWarning) {
+                        // Framework compile errors can have formatting like babel now:
+                        // '  305 |     std::__construct_at(__p, std::forward<_Args>(__args)...);'
+                        // So we need to strip the prefix ('  305 |') portion.
+                        this.currentIssue.line = (_b = (_a = text.match(/^(?:[\s]+\d+ \|\s)?(.*)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : text;
+                    }
+                    return 'unmatched';
+                },
+            ],
+        ]);
+        return results !== 'unmatched';
+    }
+    updateLinkerFailureState(text) {
+        const handleLinkerFail = ([, $1]) => {
+            this.linkerFailure.message = $1;
+            // Some linker failures can be warnings...
+            const messageMatch = this.linkerFailure.message.match(/^(ld: )warning: (.*)/m);
+            if (messageMatch && messageMatch[2]) {
+                // Format like: `ld: duplicate symbol` to match other ld warnings.
+                this.linkerFailure.message = messageMatch[1] + messageMatch[2];
+                this.linkerFailure.isWarning = true;
+            }
+            this.formattingLinkerFailure = true;
+        };
+        (0, switchRegex_1.switchRegex)(text, [
+            [Matchers_1.Matchers.Errors.LINKER_UNDEFINED_SYMBOLS_MATCHER, handleLinkerFail],
+            [Matchers_1.Matchers.Errors.LINKER_DUPLICATE_SYMBOLS_MATCHER, handleLinkerFail],
+        ]);
+        if (!this.formattingLinkerFailure) {
+            return false;
+        }
+        const results = (0, switchRegex_1.switchRegex)(text, [
+            [
+                Matchers_1.Matchers.Errors.SYMBOL_REFERENCED_FROM_MATCHER,
+                ([, $1]) => {
+                    this.linkerFailure.symbol = $1;
+                },
+            ],
+            [
+                Matchers_1.Matchers.Errors.LINKER_UNDEFINED_SYMBOL_LOCATION_MATCHER,
+                () => {
+                    // TODO: trim === strip ?
+                    this.linkerFailure.reference = text.trim();
+                },
+            ],
+            [
+                Matchers_1.Matchers.Errors.LINKER_DUPLICATE_SYMBOLS_LOCATION_MATCHER,
+                ([, $1]) => {
+                    // TODO: trim === strip ?
+                    this.linkerFailure.files.push($1);
+                },
+            ],
+            [
+                null,
+                () => {
+                    return 'unmatched';
+                },
+            ],
+        ]);
+        return results !== 'unmatched';
+    }
+    // TODO: clean up the mess around all this
+    shouldFormatError() {
+        return !!this.formattingError && this.errorOrWarningIsPresent();
+    }
+    shouldFormatWarning() {
+        return this.formattingWarning && this.errorOrWarningIsPresent();
+    }
+    errorOrWarningIsPresent() {
+        var _a, _b, _c;
+        return !!((_a = this.currentIssue) === null || _a === void 0 ? void 0 : _a.reason) && !!((_b = this.currentIssue) === null || _b === void 0 ? void 0 : _b.cursor) && !!((_c = this.currentIssue) === null || _c === void 0 ? void 0 : _c.line);
+    }
+    shouldFormatUndefinedSymbols() {
+        var _a, _b, _c;
+        return (((_a = this.linkerFailure) === null || _a === void 0 ? void 0 : _a.message) && ((_b = this.linkerFailure) === null || _b === void 0 ? void 0 : _b.symbol) && ((_c = this.linkerFailure) === null || _c === void 0 ? void 0 : _c.reference));
+    }
+    shouldFormatDuplicateSymbols() {
+        var _a, _b, _c;
+        return ((_a = this.linkerFailure) === null || _a === void 0 ? void 0 : _a.message) && ((_c = (_b = this.linkerFailure) === null || _b === void 0 ? void 0 : _b.files) === null || _c === void 0 ? void 0 : _c.length) > 1;
+    }
+    formatCompileError() {
+        const error = { ...this.currentIssue };
+        this.currentIssue = {};
+        this.formattingError = false;
+        return this.formatter.formatCompileError(error.fileName, error.filePath, error.reason, error.line, error.cursor);
+    }
+    formatCompileWarning() {
+        const warning = { ...this.currentIssue };
+        this.currentIssue = {};
+        this.formattingWarning = false;
+        return this.formatter.formatCompileWarning(warning.fileName, warning.filePath, warning.reason, warning.line, warning.cursor);
+    }
+    formatUndefinedSymbols() {
+        const result = this.formatter.formatUndefinedSymbols(this.linkerFailure.message, this.linkerFailure.symbol, this.linkerFailure.reference);
+        this.resetLinkerFormatState();
+        return result;
+    }
+    formatDuplicateSymbols() {
+        const result = this.formatter.formatDuplicateSymbols(this.linkerFailure.message, this.linkerFailure.files, !!this.linkerFailure.isWarning);
+        this.resetLinkerFormatState();
+        return result;
+    }
+    resetLinkerFormatState() {
+        this.linkerFailure = { files: [] };
+        this.formattingLinkerFailure = false;
+    }
+    storeFailure({ file, testCase, testSuite, reason, }) {
+        if (!this.failures) {
+            this.failures = {};
+        }
+        if (!Array.isArray(this.failures[testSuite])) {
+            this.failures[testSuite] = [];
+        }
+        this.failures[testSuite].push({
+            filePath: file,
+            reason,
+            testCase,
+        });
+    }
+    formatSummaryIfNeeded(executedMessage) {
+        if (!this.shouldFormatSummary()) {
+            return '';
+        }
+        this.formattedSummary = true;
+        return this.formatter.formatTestSummary(executedMessage, this.failures);
+    }
+    shouldFormatSummary() {
+        return !!this.testsDone && !this.formattedSummary;
+    }
+}
+exports.Parser = Parser;
+//# sourceMappingURL=Parser.js.map

node_modules/@expo/xcpretty/build/Runner.d.ts

@@ -0,0 +1,14 @@
+export declare function formatXcodeBuildPipeProcessAsync(projectRoot: string, { xcodeProjectName }?: {
+    xcodeProjectName?: string;
+}): Promise<string>;
+export declare function createXcodeBuildHooks(projectRoot: string, { xcodeProjectName, resolve, reject, }: {
+    xcodeProjectName?: string;
+    resolve: (buildOutput: string) => void;
+    reject: (error: Error) => void;
+}): {
+    onData: (data: Buffer) => void;
+    onErr: (data: Buffer) => void;
+    onEnd: (code: number) => void;
+};
+export declare function writeBuildLogs(projectRoot: string, buildOutput: string, errorOutput: string): string;
+export declare function getErrorLogFilePath(projectRoot: string): [string, string];

node_modules/@expo/xcpretty/build/Runner.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatXcodeBuildPipeProcessAsync = formatXcodeBuildPipeProcessAsync;
+exports.createXcodeBuildHooks = createXcodeBuildHooks;
+exports.writeBuildLogs = writeBuildLogs;
+exports.getErrorLogFilePath = getErrorLogFilePath;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const ExpoRunFormatter_1 = require("./ExpoRunFormatter");
+function formatXcodeBuildPipeProcessAsync(projectRoot, { xcodeProjectName } = {}) {
+    return new Promise(async (resolve, reject) => {
+        const hooks = createXcodeBuildHooks(projectRoot, { xcodeProjectName, resolve, reject });
+        process.stdin.on('data', hooks.onData);
+        process.stdin.on('end', () => {
+            hooks.onEnd(0);
+        });
+    });
+}
+function createXcodeBuildHooks(projectRoot, { xcodeProjectName, resolve, reject, }) {
+    const formatter = ExpoRunFormatter_1.ExpoRunFormatter.create(projectRoot, {
+        xcodeProject: xcodeProjectName ? { name: xcodeProjectName } : undefined,
+        isDebug: isTruthy(process.env.EXPO_DEBUG),
+    });
+    let buildOutput = '';
+    let errorOutput = '';
+    let currentBuffer = '';
+    // Data can be sent in chunks that would have no relevance to our regex
+    // this can cause massive slowdowns, so we need to ensure the data is complete before attempting to parse it.
+    function flushBuffer() {
+        if (!currentBuffer) {
+            return;
+        }
+        const data = currentBuffer;
+        currentBuffer = '';
+        const lines = formatter.pipe(data);
+        for (const line of lines) {
+            console.log(line);
+        }
+    }
+    const onData = (data) => {
+        const stringData = data.toString();
+        buildOutput += stringData;
+        currentBuffer += stringData;
+        if (currentBuffer.endsWith(os_1.default.EOL)) {
+            flushBuffer();
+        }
+    };
+    const onErr = (data) => {
+        flushBuffer();
+        const stringData = data instanceof Buffer ? data.toString() : data;
+        errorOutput += stringData;
+    };
+    const onEnd = (code) => {
+        flushBuffer();
+        console.log(formatter.getBuildSummary());
+        const logFilePath = writeBuildLogs(projectRoot, buildOutput, errorOutput);
+        if (code !== 0) {
+            // Determine if the logger found any errors;
+            const wasErrorPresented = !!formatter.errors.length;
+            const errorTitle = `Failed to build iOS project. "xcodebuild" exited with error code ${code}.`;
+            if (wasErrorPresented) {
+                // This has a flaw, if the user is missing a file, and there is a script error, only the missing file error will be shown.
+                // They will only see the script error if they fix the missing file and rerun.
+                // The flaw can be fixed by catching script errors in the custom logger.
+                reject(new Error(errorTitle));
+                return;
+            }
+            // Show all the log info because often times the error is coming from a shell script,
+            // that invoked a node script, that started metro, which threw an error.
+            reject(new Error(`${errorTitle}\nTo view more error logs, try building the app with Xcode directly, by opening ${'unknown'}.\n\n` +
+                buildOutput +
+                '\n\n' +
+                errorOutput +
+                `Build logs written to ${chalk_1.default.underline(logFilePath)}`));
+            return;
+        }
+        resolve(buildOutput);
+    };
+    return { onData, onErr, onEnd };
+}
+function writeBuildLogs(projectRoot, buildOutput, errorOutput) {
+    const [logFilePath, errorFilePath] = getErrorLogFilePath(projectRoot);
+    fs_1.default.writeFileSync(logFilePath, buildOutput);
+    fs_1.default.writeFileSync(errorFilePath, errorOutput);
+    return logFilePath;
+}
+function getErrorLogFilePath(projectRoot) {
+    const folder = path_1.default.join(projectRoot, '.expo');
+    fs_1.default.mkdirSync(folder, { recursive: true });
+    return [path_1.default.join(folder, 'xcodebuild.log'), path_1.default.join(folder, 'xcodebuild-error.log')];
+}
+function isTruthy(value) {
+    const str = String(value).toLowerCase();
+    return str === 'true' || str === '1';
+}
+//# sourceMappingURL=Runner.js.map

node_modules/@expo/xcpretty/build/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

node_modules/@expo/xcpretty/build/cli.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const Runner_1 = require("./Runner");
+const projectRoot = path_1.default.resolve(process.argv[2] || '.');
+(0, Runner_1.formatXcodeBuildPipeProcessAsync)(projectRoot);
+//# sourceMappingURL=cli.js.map

node_modules/@expo/xcpretty/build/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";;;;;;AACA,gDAAwB;AAExB,qCAA4D;AAE5D,MAAM,WAAW,GAAG,cAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;AAEzD,IAAA,yCAAgC,EAAC,WAAW,CAAC,CAAC","sourcesContent":["#!/usr/bin/env node\nimport path from 'path';\n\nimport { formatXcodeBuildPipeProcessAsync } from './Runner';\n\nconst projectRoot = path.resolve(process.argv[2] || '.');\n\nformatXcodeBuildPipeProcessAsync(projectRoot);\n"]}

node_modules/@expo/xcpretty/build/index.d.ts

@@ -0,0 +1,8 @@
+import * as Runner from './Runner';
+export { Parser } from './Parser';
+export { MetroParser } from './MetroParser';
+export { PodfileTracer } from './utils/PodfileTracer';
+export { ExpoRunFormatter, ExpoRunFormatterProps } from './ExpoRunFormatter';
+export * from './Formatter';
+export { switchRegex } from './switchRegex';
+export { Runner };

node_modules/@expo/xcpretty/build/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runner = exports.switchRegex = exports.ExpoRunFormatter = exports.PodfileTracer = exports.MetroParser = exports.Parser = void 0;
+const Runner = __importStar(require("./Runner"));
+exports.Runner = Runner;
+var Parser_1 = require("./Parser");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return Parser_1.Parser; } });
+var MetroParser_1 = require("./MetroParser");
+Object.defineProperty(exports, "MetroParser", { enumerable: true, get: function () { return MetroParser_1.MetroParser; } });
+var PodfileTracer_1 = require("./utils/PodfileTracer");
+Object.defineProperty(exports, "PodfileTracer", { enumerable: true, get: function () { return PodfileTracer_1.PodfileTracer; } });
+var ExpoRunFormatter_1 = require("./ExpoRunFormatter");
+Object.defineProperty(exports, "ExpoRunFormatter", { enumerable: true, get: function () { return ExpoRunFormatter_1.ExpoRunFormatter; } });
+__exportStar(require("./Formatter"), exports);
+var switchRegex_1 = require("./switchRegex");
+Object.defineProperty(exports, "switchRegex", { enumerable: true, get: function () { return switchRegex_1.switchRegex; } });
+//# sourceMappingURL=index.js.map

node_modules/@expo/xcpretty/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAAmC;AAQ1B,wBAAM;AANf,mCAAkC;AAAzB,gGAAA,MAAM,OAAA;AACf,6CAA4C;AAAnC,0GAAA,WAAW,OAAA;AACpB,uDAAsD;AAA7C,8GAAA,aAAa,OAAA;AACtB,uDAA6E;AAApE,oHAAA,gBAAgB,OAAA;AACzB,8CAA4B;AAC5B,6CAA4C;AAAnC,0GAAA,WAAW,OAAA","sourcesContent":["import * as Runner from './Runner';\n\nexport { Parser } from './Parser';\nexport { MetroParser } from './MetroParser';\nexport { PodfileTracer } from './utils/PodfileTracer';\nexport { ExpoRunFormatter, ExpoRunFormatterProps } from './ExpoRunFormatter';\nexport * from './Formatter';\nexport { switchRegex } from './switchRegex';\nexport { Runner };\n"]}

node_modules/@expo/xcpretty/build/switchRegex.d.ts

@@ -0,0 +1 @@
+export declare function switchRegex(text: string, cases: [RegExp | null, (matches: RegExpMatchArray) => string | void][], isAll?: boolean): string;

node_modules/@expo/xcpretty/build/switchRegex.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.switchRegex = switchRegex;
+function switchRegex(text, cases, isAll = false) {
+    for (const [reg, callback] of cases) {
+        if (!reg) {
+            return callback(['']) || '';
+        }
+        const results = text.match(reg);
+        if (results) {
+            const res = callback(results);
+            if (!isAll) {
+                return res || '';
+            }
+        }
+    }
+    return '';
+}
+//# sourceMappingURL=switchRegex.js.map

node_modules/@expo/xcpretty/build/switchRegex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"switchRegex.js","sourceRoot":"","sources":["../src/switchRegex.ts"],"names":[],"mappings":";;AAAA,kCAkBC;AAlBD,SAAgB,WAAW,CACzB,IAAY,EACZ,KAAsE,EACtE,QAAiB,KAAK;IAEtB,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,KAAK,EAAE,CAAC;QACpC,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,OAAO,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QAC9B,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;YAC9B,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,OAAO,GAAG,IAAI,EAAE,CAAC;YACnB,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC","sourcesContent":["export function switchRegex(\n  text: string,\n  cases: [RegExp | null, (matches: RegExpMatchArray) => string | void][],\n  isAll: boolean = false\n): string {\n  for (const [reg, callback] of cases) {\n    if (!reg) {\n      return callback(['']) || '';\n    }\n    const results = text.match(reg);\n    if (results) {\n      const res = callback(results);\n      if (!isAll) {\n        return res || '';\n      }\n    }\n  }\n  return '';\n}\n"]}

node_modules/@expo/xcpretty/build/utils/PodfileTracer.d.ts

@@ -0,0 +1,50 @@
+import { PodfileLock } from './parsePodfileLock';
+/**
+ * A utility for tracing dependencies from a Podfile.lock.
+ */
+export declare class PodfileTracer {
+    props: {
+        projectRoot: string;
+        rootTargetName?: string;
+        podfile: PodfileLock;
+    };
+    static create(projectRoot: string, { xcodeProject }?: {
+        xcodeProject?: {
+            name: string;
+        };
+    }): PodfileTracer;
+    get podfile(): PodfileLock;
+    constructor(props: {
+        projectRoot: string;
+        rootTargetName?: string;
+        podfile: PodfileLock;
+    });
+    getNodeModuleNameForTarget: (key: string) => {
+        name: string;
+        isRootTarget: boolean;
+    } | null;
+    getNodeModuleNameForTargetWithoutCache(target: string): {
+        name: string;
+        isRootTarget: boolean;
+    } | null;
+    isRootTarget(target: string): boolean | "" | undefined;
+    getNodeModuleName(filePath: string, target?: string): {
+        name: string;
+        isRootTarget: boolean;
+    } | null;
+    getExternalSourceForPod: (key: string) => {
+        pod: string;
+        source: string;
+    } | null;
+    getExternalSourceForPodWithoutCache(pod?: string): {
+        pod: string;
+        source: string;
+    } | null;
+    private memoizedGetPackageJsonAnyFilePathInModule;
+    /** This can be a path like `/app/node_modules/expo-camera/ios` or `/app/node_modules/react-native-webrtc` depending on where the podspec is. */
+    getPackageJsonAnyFilePathInModule(props: {
+        target: string;
+        filePath: string;
+    }): Record<string, any> | null;
+    getPackageJsonAnyFilePathInModuleWithoutCache(filePath: string): Record<string, any> | null;
+}

node_modules/@expo/xcpretty/build/utils/PodfileTracer.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodfileTracer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const getFirstExternalSourceForPod_1 = require("./getFirstExternalSourceForPod");
+const getNodeModuleName_1 = require("./getNodeModuleName");
+const getPackageJsonForPath_1 = require("./getPackageJsonForPath");
+const parsePodfileLock_1 = require("./parsePodfileLock");
+/**
+ * A utility for tracing dependencies from a Podfile.lock.
+ */
+class PodfileTracer {
+    static create(projectRoot, { xcodeProject } = {}) {
+        var _a, _b;
+        const podfileLock = path_1.default.join(projectRoot, 'ios', 'Podfile.lock');
+        const podfileContents = fs_1.default.readFileSync(podfileLock, 'utf8');
+        const rootTargetName = ((_a = xcodeProject === null || xcodeProject === void 0 ? void 0 : xcodeProject.name.match(/.*\/(.*)\.\w+/)) === null || _a === void 0 ? void 0 : _a[1]) || '';
+        const formatter = new PodfileTracer({
+            projectRoot,
+            rootTargetName,
+            podfile: (_b = (0, parsePodfileLock_1.parsePodfileLock)(podfileContents)) !== null && _b !== void 0 ? _b : {},
+        });
+        return formatter;
+    }
+    get podfile() {
+        return this.props.podfile || {};
+    }
+    constructor(props) {
+        this.props = props;
+        // Wrap the expensive method in a cache
+        this.getNodeModuleNameForTarget = memoize(this.getNodeModuleNameForTargetWithoutCache.bind(this));
+        this.getExternalSourceForPod = memoize(this.getExternalSourceForPodWithoutCache.bind(this));
+        this.memoizedGetPackageJsonAnyFilePathInModule = memoizeTrigger(this.getPackageJsonAnyFilePathInModuleWithoutCache.bind(this));
+    }
+    getNodeModuleNameForTargetWithoutCache(target) {
+        if (!target) {
+            return null;
+        }
+        // Check the list of known pods that are hardcoded into the system.
+        if (target in knownPackages) {
+            return { name: knownPackages[target], isRootTarget: false };
+        }
+        // Check if the target matches the root project.
+        if (this.isRootTarget(target)) {
+            // Get the root package.json
+            const pkg = this.getPackageJsonAnyFilePathInModule({
+                target,
+                filePath: this.props.projectRoot,
+            });
+            return pkg ? { name: pkg.name, isRootTarget: true } : null;
+        }
+        // Otherwise, start tracing for dependencies.
+        let source = this.getExternalSourceForPod(target);
+        if (!source) {
+            // Some modules are formatted incorrectly in Xcode like `EXUpdates-EXUpdates` or `EXConstants-EXConstants`
+            // here we'll attempt to split the value, ensure there's more than one copy, and that all copies are the same, then we'll check against that new value.
+            const parts = target.split('-');
+            if (!!parts[0] && parts.length > 1 && parts.every(s => s === parts[0])) {
+                source = this.getExternalSourceForPod(parts[0]);
+            }
+        }
+        if (source === null || source === void 0 ? void 0 : source.source) {
+            // Finally attempt to trace the podspec file.
+            const pkg = this.getPackageJsonAnyFilePathInModule({
+                target: source.pod,
+                filePath: source.source,
+            });
+            if (pkg) {
+                return { name: pkg.name, isRootTarget: false };
+            }
+        }
+        return null;
+    }
+    isRootTarget(target) {
+        return (this.props.rootTargetName &&
+            (target === this.props.rootTargetName || target === `Pods-${this.props.rootTargetName}`));
+    }
+    getNodeModuleName(filePath, target) {
+        const moduleName = (0, getNodeModuleName_1.getNodeModuleName)(filePath);
+        if (moduleName) {
+            return { name: moduleName, isRootTarget: false };
+        }
+        else if (!target) {
+            return null;
+        }
+        return this.getNodeModuleNameForTarget(target);
+    }
+    getExternalSourceForPodWithoutCache(pod) {
+        var _a, _b;
+        if (!pod) {
+            return null;
+        }
+        const results = (0, getFirstExternalSourceForPod_1.getFirstExternalSourceForPod)(this.podfile, { name: pod });
+        // Keep tracing until we get to a development pod with a local file reference.
+        const filePath = (_b = (_a = results === null || results === void 0 ? void 0 : results.source[':podspec']) !== null && _a !== void 0 ? _a : results === null || results === void 0 ? void 0 : results.source[':path']) !== null && _b !== void 0 ? _b : null;
+        if (results && filePath) {
+            return { pod: results.pod, source: filePath };
+        }
+        return null;
+    }
+    /** This can be a path like `/app/node_modules/expo-camera/ios` or `/app/node_modules/react-native-webrtc` depending on where the podspec is. */
+    getPackageJsonAnyFilePathInModule(props) {
+        return this.memoizedGetPackageJsonAnyFilePathInModule({
+            key: props.target,
+            args: [props.filePath],
+        });
+    }
+    getPackageJsonAnyFilePathInModuleWithoutCache(filePath) {
+        if (!this.props.projectRoot || !filePath) {
+            return null;
+        }
+        const nativeProjectRoot = path_1.default.join(this.props.projectRoot, 'ios');
+        // In the case of the root level podspec file.
+        try {
+            const rootLevelPkgJsonPath = path_1.default.join(nativeProjectRoot, 'package.json');
+            return require(rootLevelPkgJsonPath);
+        }
+        catch {
+            return (0, getPackageJsonForPath_1.getPackageJsonForPath)(path_1.default.join(nativeProjectRoot, filePath));
+        }
+    }
+}
+exports.PodfileTracer = PodfileTracer;
+function memoize(func) {
+    const cache = {};
+    return function (key) {
+        if (key in cache) {
+            return cache[key];
+        }
+        const result = func(key);
+        cache[key] = result;
+        return result;
+    };
+}
+function memoizeTrigger(func) {
+    const cache = {};
+    return function ({ key, args }) {
+        if (key in cache) {
+            return cache[key];
+        }
+        // @ts-ignore
+        const result = func(...args);
+        cache[key] = result;
+        return result;
+    };
+}
+// A list of packages that aren't linked through cocoapods directly.
+const knownPackages = {
+    // Added to ReactCore as a `resource_bundle`
+    'React-Core-AccessibilityResources': 'react-native',
+    YogaKit: 'react-native',
+    // flipper
+    'Flipper-DoubleConversion': 'react-native',
+    'Flipper-Folly': 'react-native',
+    'OpenSSL-Universal': 'react-native',
+    FlipperKit: 'react-native',
+    Flipper: 'react-native',
+    'Flipper-RSocket': 'react-native',
+};
+//# sourceMappingURL=PodfileTracer.js.map

node_modules/@expo/xcpretty/build/utils/getFirstExternalSourceForPod.d.ts

@@ -0,0 +1,20 @@
+import { ExternalSource, PodfileLock } from './parsePodfileLock';
+export declare function getDependentPods(podfileLock: PodfileLock, { name, version }: {
+    name: string;
+    version?: string;
+}): string[];
+/**
+ * Find the first "external source" (local file path reference) for a given pod.
+ *
+ * @param podfileLock
+ * @param props.name The pod name to search for.
+ * @param props.checked A recursive parameter to prevent infinite recursion, not for public use.
+ * @returns
+ */
+export declare function getFirstExternalSourceForPod(podfileLock: PodfileLock, { name, checked }: {
+    name: string;
+    checked?: string[];
+}): {
+    pod: string;
+    source: ExternalSource;
+} | null;

node_modules/@expo/xcpretty/build/utils/getFirstExternalSourceForPod.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependentPods = getDependentPods;
+exports.getFirstExternalSourceForPod = getFirstExternalSourceForPod;
+function getDependentPods(podfileLock, { name, version }) {
+    if (!podfileLock.pods) {
+        return [];
+    }
+    const hasPodDependency = (pods) => {
+        for (const podDependency of pods) {
+            if (podDependency.name === name) {
+                return !version || podDependency.version === version;
+            }
+            if (podDependency.dependencies && hasPodDependency(podDependency.dependencies)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    return podfileLock.pods.reduce((prev, curr) => {
+        if (curr.name !== name && curr.dependencies && hasPodDependency(curr.dependencies)) {
+            return [...prev, curr.name];
+        }
+        return prev;
+    }, []);
+}
+/**
+ * Find the first "external source" (local file path reference) for a given pod.
+ *
+ * @param podfileLock
+ * @param props.name The pod name to search for.
+ * @param props.checked A recursive parameter to prevent infinite recursion, not for public use.
+ * @returns
+ */
+function getFirstExternalSourceForPod(podfileLock, { name, checked }) {
+    if (!podfileLock.externalSources) {
+        return null;
+    }
+    if (podfileLock.externalSources[name]) {
+        return { pod: name, source: podfileLock.externalSources[name] };
+    }
+    else if (name.includes('/')) {
+        // Short cut for pods with a path
+        const possibleName = name.split('/')[0];
+        if (podfileLock.externalSources[possibleName]) {
+            return { pod: possibleName, source: podfileLock.externalSources[possibleName] };
+        }
+    }
+    if (!checked) {
+        checked = [];
+    }
+    checked.push(name);
+    const dependents = getDependentPods(podfileLock, { name });
+    for (const dependent of dependents) {
+        // Prevent pods with cyclic dependencies from causing infinite loops.
+        if (!checked.includes(dependent)) {
+            const results = getFirstExternalSourceForPod(podfileLock, { name: dependent, checked });
+            if (results) {
+                return results;
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=getFirstExternalSourceForPod.js.map

node_modules/@expo/xcpretty/build/utils/getFirstExternalSourceForPod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFirstExternalSourceForPod.js","sourceRoot":"","sources":["../../src/utils/getFirstExternalSourceForPod.ts"],"names":[],"mappings":";;AAEA,4CA2BC;AAUD,oEAmCC;AAxED,SAAgB,gBAAgB,CAC9B,WAAwB,EACxB,EAAE,IAAI,EAAE,OAAO,EAAsC;IAErD,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;QACtB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,gBAAgB,GAAG,CAAC,IAAqB,EAAE,EAAE;QACjD,KAAK,MAAM,aAAa,IAAI,IAAI,EAAE,CAAC;YACjC,IAAI,aAAa,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBAChC,OAAO,CAAC,OAAO,IAAI,aAAa,CAAC,OAAO,KAAK,OAAO,CAAC;YACvD,CAAC;YACD,IAAI,aAAa,CAAC,YAAY,IAAI,gBAAgB,CAAC,aAAa,CAAC,YAAY,CAAC,EAAE,CAAC;gBAC/E,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,OAAO,WAAW,CAAC,IAAI,CAAC,MAAM,CAAW,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;QACtD,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,YAAY,IAAI,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;YACnF,OAAO,CAAC,GAAG,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,4BAA4B,CAC1C,WAAwB,EACxB,EAAE,IAAI,EAAE,OAAO,EAAwC;IAEvD,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,WAAW,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;IAClE,CAAC;SAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9B,iCAAiC;QACjC,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACxC,IAAI,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,CAAC;YAC9C,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,CAAC;QAClF,CAAC;IACH,CAAC;IAED,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,GAAG,EAAE,CAAC;IACf,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEnB,MAAM,UAAU,GAAG,gBAAgB,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;IAE3D,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,qEAAqE;QACrE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;YACjC,MAAM,OAAO,GAAG,4BAA4B,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;YACxF,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,OAAO,CAAC;YACjB,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["import { ExternalSource, PodDependency, PodfileLock } from './parsePodfileLock';\n\nexport function getDependentPods(\n  podfileLock: PodfileLock,\n  { name, version }: { name: string; version?: string }\n): string[] {\n  if (!podfileLock.pods) {\n    return [];\n  }\n\n  const hasPodDependency = (pods: PodDependency[]) => {\n    for (const podDependency of pods) {\n      if (podDependency.name === name) {\n        return !version || podDependency.version === version;\n      }\n      if (podDependency.dependencies && hasPodDependency(podDependency.dependencies)) {\n        return true;\n      }\n    }\n    return false;\n  };\n\n  return podfileLock.pods.reduce<string[]>((prev, curr) => {\n    if (curr.name !== name && curr.dependencies && hasPodDependency(curr.dependencies)) {\n      return [...prev, curr.name];\n    }\n\n    return prev;\n  }, []);\n}\n\n/**\n * Find the first \"external source\" (local file path reference) for a given pod.\n *\n * @param podfileLock\n * @param props.name The pod name to search for.\n * @param props.checked A recursive parameter to prevent infinite recursion, not for public use.\n * @returns\n */\nexport function getFirstExternalSourceForPod(\n  podfileLock: PodfileLock,\n  { name, checked }: { name: string; checked?: string[] }\n): { pod: string; source: ExternalSource } | null {\n  if (!podfileLock.externalSources) {\n    return null;\n  }\n\n  if (podfileLock.externalSources[name]) {\n    return { pod: name, source: podfileLock.externalSources[name] };\n  } else if (name.includes('/')) {\n    // Short cut for pods with a path\n    const possibleName = name.split('/')[0];\n    if (podfileLock.externalSources[possibleName]) {\n      return { pod: possibleName, source: podfileLock.externalSources[possibleName] };\n    }\n  }\n\n  if (!checked) {\n    checked = [];\n  }\n  checked.push(name);\n\n  const dependents = getDependentPods(podfileLock, { name });\n\n  for (const dependent of dependents) {\n    // Prevent pods with cyclic dependencies from causing infinite loops.\n    if (!checked.includes(dependent)) {\n      const results = getFirstExternalSourceForPod(podfileLock, { name: dependent, checked });\n      if (results) {\n        return results;\n      }\n    }\n  }\n  return null;\n}\n"]}

node_modules/@expo/xcpretty/build/utils/getNodeModuleName.d.ts

@@ -0,0 +1 @@
+export declare function getNodeModuleName(filePath: string): string | null;

node_modules/@expo/xcpretty/build/utils/getNodeModuleName.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeModuleName = getNodeModuleName;
+function moduleNameFromPath(modulePath) {
+    if (modulePath.startsWith('@')) {
+        const [org, packageName] = modulePath.split('/');
+        if (org && packageName) {
+            return [org, packageName].join('/');
+        }
+        return modulePath;
+    }
+    const [packageName] = modulePath.split('/');
+    return packageName ? packageName : modulePath;
+}
+const NODE_MODULE_PATTERN = /node_modules(\/\.(pnpm|store)\/.*\/node_modules)?\//i;
+function getNodeModuleName(filePath) {
+    // '/<project>/node_modules/react-native/ReactCommon/react/renderer/components/rncore/EventEmitters.cpp'
+    // '/<project>/node_modules/.pnpm/react-native@0.73.1_@babel+core@7.20.2_react@18.2.0/node_modules/react-native/ReactCommon/react/renderer/components/rncore/EventEmitters.cpp'
+    // '/<project>/node_modules/.store/react-native@0.73.1-OKL2xQk6utgOIuOl3VvO_g/node_modules/react-native/ReactCommon/react/renderer/components/rncore/EventEmitters.cpp'
+    const [, , , modulePath] = filePath.split(NODE_MODULE_PATTERN);
+    if (modulePath) {
+        return moduleNameFromPath(modulePath);
+    }
+    return null;
+}
+//# sourceMappingURL=getNodeModuleName.js.map

node_modules/@expo/xcpretty/build/utils/getNodeModuleName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNodeModuleName.js","sourceRoot":"","sources":["../../src/utils/getNodeModuleName.ts"],"names":[],"mappings":";;AAcA,8CASC;AAvBD,SAAS,kBAAkB,CAAC,UAAkB;IAC5C,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/B,MAAM,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACjD,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC;YACvB,OAAO,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,MAAM,CAAC,WAAW,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC5C,OAAO,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC;AAChD,CAAC;AAED,MAAM,mBAAmB,GAAG,sDAAsD,CAAC;AAEnF,SAAgB,iBAAiB,CAAC,QAAgB;IAChD,wGAAwG;IACxG,+KAA+K;IAC/K,uKAAuK;IACvK,MAAM,CAAC,EAAE,AAAD,EAAG,AAAD,EAAG,UAAU,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAC/D,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["function moduleNameFromPath(modulePath: string) {\n  if (modulePath.startsWith('@')) {\n    const [org, packageName] = modulePath.split('/');\n    if (org && packageName) {\n      return [org, packageName].join('/');\n    }\n    return modulePath;\n  }\n  const [packageName] = modulePath.split('/');\n  return packageName ? packageName : modulePath;\n}\n\nconst NODE_MODULE_PATTERN = /node_modules(\\/\\.(pnpm|store)\\/.*\\/node_modules)?\\//i;\n\nexport function getNodeModuleName(filePath: string): string | null {\n  // '/<project>/node_modules/react-native/ReactCommon/react/renderer/components/rncore/EventEmitters.cpp'\n  // '/<project>/node_modules/.pnpm/react-native@0.73.1_@babel+core@7.20.2_react@18.2.0/node_modules/react-native/ReactCommon/react/renderer/components/rncore/EventEmitters.cpp'\n  // '/<project>/node_modules/.store/react-native@0.73.1-OKL2xQk6utgOIuOl3VvO_g/node_modules/react-native/ReactCommon/react/renderer/components/rncore/EventEmitters.cpp'\n  const [, , , modulePath] = filePath.split(NODE_MODULE_PATTERN);\n  if (modulePath) {\n    return moduleNameFromPath(modulePath);\n  }\n  return null;\n}\n"]}

node_modules/@expo/xcpretty/build/utils/getPackageJsonForPath.d.ts

@@ -0,0 +1 @@
+export declare const getPackageJsonForPath: (root: string) => any;

node_modules/@expo/xcpretty/build/utils/getPackageJsonForPath.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJsonForPath = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const getPackageJsonForPath = (root) => {
+    for (let dir = root; path_1.default.dirname(dir) !== dir; dir = path_1.default.dirname(dir)) {
+        const file = path_1.default.resolve(dir, 'package.json');
+        if (fs_1.default.existsSync(file)) {
+            return require(file);
+        }
+    }
+    return null;
+};
+exports.getPackageJsonForPath = getPackageJsonForPath;
+//# sourceMappingURL=getPackageJsonForPath.js.map

node_modules/@expo/xcpretty/build/utils/getPackageJsonForPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPackageJsonForPath.js","sourceRoot":"","sources":["../../src/utils/getPackageJsonForPath.ts"],"names":[],"mappings":";;;;;;AAAA,4CAAoB;AACpB,gDAAwB;AAEjB,MAAM,qBAAqB,GAAG,CAAC,IAAY,EAAO,EAAE;IACzD,KAAK,IAAI,GAAG,GAAG,IAAI,EAAE,cAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,EAAE,GAAG,GAAG,cAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACxE,MAAM,IAAI,GAAG,cAAI,CAAC,OAAO,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;QAC/C,IAAI,YAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AARW,QAAA,qBAAqB,yBAQhC","sourcesContent":["import fs from 'fs';\nimport path from 'path';\n\nexport const getPackageJsonForPath = (root: string): any => {\n  for (let dir = root; path.dirname(dir) !== dir; dir = path.dirname(dir)) {\n    const file = path.resolve(dir, 'package.json');\n    if (fs.existsSync(file)) {\n      return require(file);\n    }\n  }\n  return null;\n};\n"]}

node_modules/@expo/xcpretty/build/utils/parsePodfileLock.d.ts

@@ -0,0 +1,31 @@
+export interface PodDependency {
+    name: string;
+    version?: string;
+    dependencies?: PodDependency[];
+}
+export interface ExternalSource {
+    /** "../node_modules/react-native/third-party-podspecs/DoubleConversion.podspec" */
+    ':podspec'?: string;
+    /** "../node_modules/expo-application/ios" */
+    ':path'?: string;
+}
+export interface PodfileLock {
+    pods?: PodDependency[];
+    /** "1.11.2" */
+    cocoapods?: string;
+    externalSources?: Record<string, ExternalSource>;
+    /** 73e35020f8f5d49ffd32debe3c1bdd501f8029a6 */
+    podfileChecksum?: string;
+    /** { "DoubleConversion": "cf9b38bf0b2d048436d9a82ad2abe1404f11e7de" } */
+    specChecksums?: Record<string, string>;
+}
+/**
+ * Parses a podfile.lock file from from YAML into a JSON object.
+ *
+ * @param str Podfile.lock file contents in YAML format.
+ * @returns
+ */
+export declare function loadPodfileLock(str: string): null | Record<string, any>;
+export declare const parsePodDependency: (pod: string | Record<string, string | Record<string, any>>) => PodDependency[];
+export declare function parsePodfileLock(fileContent: string): PodfileLock | null;
+export declare function getFilePathForExternalSource(podLock: PodfileLock, pod: string): string | null;

node_modules/@expo/xcpretty/build/utils/parsePodfileLock.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePodDependency = void 0;
+exports.loadPodfileLock = loadPodfileLock;
+exports.parsePodfileLock = parsePodfileLock;
+exports.getFilePathForExternalSource = getFilePathForExternalSource;
+const js_yaml_1 = require("js-yaml");
+const EXTERNAL_SOURCES_KEY = 'EXTERNAL SOURCES';
+/**
+ * Parses a podfile.lock file from from YAML into a JSON object.
+ *
+ * @param str Podfile.lock file contents in YAML format.
+ * @returns
+ */
+function loadPodfileLock(str) {
+    const contents = (0, js_yaml_1.load)(str);
+    if (!contents || typeof contents !== 'object') {
+        return null;
+    }
+    return contents;
+}
+const parsePodDependency = (pod) => {
+    if (typeof pod === 'string') {
+        // js-yaml fails to parse an array with a single item and instead formats it as a string divided by a `-` (hyphen).
+        // Here we match if a hyphen comes after a space. We use fake-nested-Podfile to test this hack.
+        const singleItemArrayBug = pod.match(/(.*)\s-\s(.*)/);
+        if (singleItemArrayBug === null || singleItemArrayBug === void 0 ? void 0 : singleItemArrayBug[2]) {
+            return (0, exports.parsePodDependency)({ [singleItemArrayBug[1]]: singleItemArrayBug[2] });
+        }
+        return [splitPodNameVersion(pod)];
+    }
+    return Object.entries(pod).map(([k, v]) => {
+        const results = splitPodNameVersion(k);
+        if (Array.isArray(v)) {
+            return {
+                ...results,
+                dependencies: v.map(x => (0, exports.parsePodDependency)(x)).flat(),
+            };
+        }
+        else if (typeof v === 'string') {
+            return {
+                ...results,
+                dependencies: (0, exports.parsePodDependency)(v),
+            };
+        }
+        return results;
+    });
+};
+exports.parsePodDependency = parsePodDependency;
+function parsePodfileLock(fileContent) {
+    var _a;
+    const contents = (_a = loadPodfileLock(fileContent)) !== null && _a !== void 0 ? _a : loadPodfileLock(EXTERNAL_SOURCES_KEY + fileContent.split(EXTERNAL_SOURCES_KEY).slice(1));
+    if (!contents) {
+        return null;
+    }
+    const parsed = Object.entries(contents).reduce((acc, [key, value]) => {
+        return {
+            ...acc,
+            [kebabCaseToCamelCase(rubyCaseToKebab(key))]: value,
+        };
+    }, {});
+    if (Array.isArray(parsed.pods)) {
+        const parsedPods = parsed.pods.map(exports.parsePodDependency);
+        parsed.pods = parsedPods.flat();
+    }
+    return parsed;
+}
+function splitPodNameVersion(pod) {
+    var _a;
+    const [name] = pod.split(' ');
+    return { name, version: (_a = pod.match(/\((.*)\)/)) === null || _a === void 0 ? void 0 : _a[1] };
+}
+function rubyCaseToKebab(str) {
+    return str.toLowerCase().split(' ').join('-');
+}
+function kebabCaseToCamelCase(str) {
+    return str.replace(/-([a-z])/g, g => g[1].toUpperCase());
+}
+function getFilePathForExternalSource(podLock, pod) {
+    var _a, _b, _c;
+    const source = (_a = podLock.externalSources) === null || _a === void 0 ? void 0 : _a[pod];
+    return (_c = (_b = source === null || source === void 0 ? void 0 : source[':podspec']) !== null && _b !== void 0 ? _b : source === null || source === void 0 ? void 0 : source[':path']) !== null && _c !== void 0 ? _c : null;
+}
+//# sourceMappingURL=parsePodfileLock.js.map

node_modules/@expo/xcpretty/build/utils/symbols.d.ts

@@ -0,0 +1,9 @@
+export declare const PASS = "\u2713";
+export declare const FAIL = "\u2717";
+export declare const PENDING = "\u29D6";
+export declare const COMPLETION = "\u203A";
+export declare const MEASURE = "\u25F7";
+export declare const ERROR: string;
+export declare const WARNING: string;
+export declare const INDENT = "    ";
+export declare const BREADCRUMB = "\u00BB";

node_modules/@expo/xcpretty/build/utils/symbols.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BREADCRUMB = exports.INDENT = exports.WARNING = exports.ERROR = exports.MEASURE = exports.COMPLETION = exports.PENDING = exports.FAIL = exports.PASS = void 0;
+const USE_ASCII = false;
+exports.PASS = '✓';
+exports.FAIL = '✗';
+exports.PENDING = '⧖';
+exports.COMPLETION = '\u203A'; //'▸';
+exports.MEASURE = '◷';
+exports.ERROR = USE_ASCII ? '[x]' : '❌ ';
+exports.WARNING = USE_ASCII ? '[!]' : '⚠️ ';
+exports.INDENT = '    ';
+exports.BREADCRUMB = '»';
+//# sourceMappingURL=symbols.js.map

node_modules/@expo/xcpretty/build/utils/symbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.js","sourceRoot":"","sources":["../../src/utils/symbols.ts"],"names":[],"mappings":";;;AAAA,MAAM,SAAS,GAAG,KAAK,CAAC;AAEX,QAAA,IAAI,GAAG,GAAG,CAAC;AACX,QAAA,IAAI,GAAG,GAAG,CAAC;AACX,QAAA,OAAO,GAAG,GAAG,CAAC;AACd,QAAA,UAAU,GAAG,QAAQ,CAAC,CAAC,MAAM;AAC7B,QAAA,OAAO,GAAG,GAAG,CAAC;AACd,QAAA,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AACjC,QAAA,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;AACpC,QAAA,MAAM,GAAG,MAAM,CAAC;AAChB,QAAA,UAAU,GAAG,GAAG,CAAC","sourcesContent":["const USE_ASCII = false;\n\nexport const PASS = '✓';\nexport const FAIL = '✗';\nexport const PENDING = '⧖';\nexport const COMPLETION = '\\u203A'; //'▸';\nexport const MEASURE = '◷';\nexport const ERROR = USE_ASCII ? '[x]' : '❌ ';\nexport const WARNING = USE_ASCII ? '[!]' : '⚠️ ';\nexport const INDENT = '    ';\nexport const BREADCRUMB = '»';\n"]}