@depup/expo__cli 55.0.16-depup.0

package/build/src/start/doctor/dependencies/validateDependenciesVersions.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getVersionedDependenciesAsync: function() {
+        return getVersionedDependenciesAsync;
+    },
+    isDependencyVersionIncorrect: function() {
+        return isDependencyVersionIncorrect;
+    },
+    logIncorrectDependencies: function() {
+        return logIncorrectDependencies;
+    },
+    validateDependenciesVersionsAsync: function() {
+        return validateDependenciesVersionsAsync;
+    }
+});
+function _assert() {
+    const data = /*#__PURE__*/ _interop_require_default(require("assert"));
+    _assert = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _npmpackagearg() {
+    const data = /*#__PURE__*/ _interop_require_default(require("npm-package-arg"));
+    _npmpackagearg = function() {
+        return data;
+    };
+    return data;
+}
+function _semver() {
+    const data = /*#__PURE__*/ _interop_require_default(require("semver"));
+    _semver = function() {
+        return data;
+    };
+    return data;
+}
+function _subset() {
+    const data = /*#__PURE__*/ _interop_require_default(require("semver/ranges/subset"));
+    _subset = function() {
+        return data;
+    };
+    return data;
+}
+const _getVersionedPackages = require("./getVersionedPackages");
+const _resolvePackages = require("./resolvePackages");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../log"));
+const _env = require("../../../utils/env");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const debug = require('debug')('expo:doctor:dependencies:validate');
+async function validateDependenciesVersionsAsync(projectRoot, exp, pkg, packagesToCheck) {
+    if (_env.env.EXPO_OFFLINE) {
+        _log.warn('Skipping dependency validation in offline mode');
+        return null;
+    } else if (_env.env.EXPO_NO_DEPENDENCY_VALIDATION) {
+        debug('Dependency validation is disabled through EXPO_NO_DEPENDENCY_VALIDATION=1');
+        return null;
+    }
+    const incorrectDeps = await getVersionedDependenciesAsync(projectRoot, exp, pkg, packagesToCheck);
+    return logIncorrectDependencies(incorrectDeps);
+}
+function logInvalidDependency({ packageName, expectedVersionOrRange, actualVersion }) {
+    _log.warn((0, _chalk().default)`  {bold ${packageName}}{cyan @}{red ${actualVersion}} - expected version: {green ${expectedVersionOrRange}}`);
+}
+function logIncorrectDependencies(incorrectDeps) {
+    if (!incorrectDeps.length) {
+        return true;
+    }
+    _log.warn((0, _chalk().default)`The following packages should be updated for best compatibility with the installed {bold expo} version:`);
+    incorrectDeps.forEach((dep)=>logInvalidDependency(dep));
+    _log.warn('Your project may not work correctly until you install the expected versions of the packages.');
+    return false;
+}
+async function getVersionedDependenciesAsync(projectRoot, exp, pkg, packagesToCheck) {
+    var _pkg_expo_install, _pkg_expo;
+    // This should never happen under normal circumstances since
+    // the CLI is versioned in the `expo` package.
+    (0, _assert().default)(exp.sdkVersion, 'SDK Version is missing');
+    // Get from both endpoints and combine the known package versions.
+    const combinedKnownPackages = await (0, _getVersionedPackages.getCombinedKnownVersionsAsync)({
+        projectRoot,
+        sdkVersion: exp.sdkVersion
+    });
+    // debug(`Known dependencies: %O`, combinedKnownPackages);
+    const resolvedDependencies = (packagesToCheck == null ? void 0 : packagesToCheck.length) ? getFilteredObject(packagesToCheck, {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+    }) : {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+    };
+    debug(`Checking dependencies for ${exp.sdkVersion}: %O`, resolvedDependencies);
+    // intersection of packages from package.json and bundled native modules
+    const { known: resolvedPackagesToCheck, unknown } = getPackagesToCheck(combinedKnownPackages, resolvedDependencies);
+    debug(`Comparing known versions: %O`, resolvedPackagesToCheck);
+    debug(`Skipping packages that cannot be versioned automatically: %O`, unknown);
+    // read package versions from the file system (node_modules)
+    const packageVersions = await (0, _resolvePackages.resolveAllPackageVersionsAsync)(projectRoot, resolvedPackagesToCheck);
+    debug(`Package versions: %O`, packageVersions);
+    // find incorrect dependencies by comparing the actual package versions with the bundled native module version ranges
+    let incorrectDeps = findIncorrectDependencies(pkg, packageVersions, combinedKnownPackages);
+    debug(`Incorrect dependencies: %O`, incorrectDeps);
+    if (pkg == null ? void 0 : (_pkg_expo = pkg.expo) == null ? void 0 : (_pkg_expo_install = _pkg_expo.install) == null ? void 0 : _pkg_expo_install.exclude) {
+        const packagesToExclude = pkg.expo.install.exclude;
+        // Parse the exclude list to ensure we can factor in any specified version ranges
+        const parsedPackagesToExclude = packagesToExclude.reduce((acc, packageName)=>{
+            const npaResult = (0, _npmpackagearg().default)(packageName);
+            if (typeof npaResult.name === 'string') {
+                acc[npaResult.name] = npaResult;
+            } else {
+                acc[packageName] = npaResult;
+            }
+            return acc;
+        }, {});
+        const incorrectAndExcludedDeps = incorrectDeps.filter((dep)=>{
+            if (parsedPackagesToExclude[dep.packageName]) {
+                const { name, raw, rawSpec, type } = parsedPackagesToExclude[dep.packageName];
+                const suggestedRange = combinedKnownPackages[name];
+                // If only the package name itself is specified, then we keep it in the exclude list
+                if (name === raw) {
+                    return true;
+                } else if (type === 'version') {
+                    return suggestedRange === rawSpec;
+                } else if (type === 'range') {
+                    // Fall through exclusions if the suggested range is invalid
+                    if (!_semver().default.validRange(suggestedRange)) {
+                        debug(`Invalid semver range in combined known packages for package ${name} in expo.install.exclude: %O`, suggestedRange);
+                        return false;
+                    }
+                    return (0, _subset().default)(suggestedRange, rawSpec);
+                } else {
+                    debug(`Unsupported npm package argument type for package ${name} in expo.install.exclude: %O`, type);
+                }
+            }
+            return false;
+        }).map((dep)=>dep.packageName);
+        debug(`Incorrect dependency warnings filtered out by expo.install.exclude: %O`, incorrectAndExcludedDeps);
+        incorrectDeps = incorrectDeps.filter((dep)=>!incorrectAndExcludedDeps.includes(dep.packageName));
+    }
+    return incorrectDeps;
+}
+function getFilteredObject(keys, object) {
+    return keys.reduce((acc, key)=>{
+        acc[key] = object[key];
+        return acc;
+    }, {});
+}
+function getPackagesToCheck(bundledNativeModules, dependencies) {
+    const dependencyNames = Object.keys(dependencies ?? {});
+    const known = [];
+    const unknown = [];
+    for (const dependencyName of dependencyNames){
+        if (dependencyName in bundledNativeModules) {
+            known.push(dependencyName);
+        } else {
+            unknown.push(dependencyName);
+        }
+    }
+    return {
+        known,
+        unknown
+    };
+}
+function findIncorrectDependencies(pkg, packageVersions, bundledNativeModules) {
+    const packages = Object.keys(packageVersions);
+    const incorrectDeps = [];
+    for (const packageName of packages){
+        const expectedVersionOrRange = bundledNativeModules[packageName];
+        const actualVersion = packageVersions[packageName];
+        if (isDependencyVersionIncorrect(packageName, actualVersion, expectedVersionOrRange)) {
+            incorrectDeps.push({
+                packageName,
+                packageType: findDependencyType(pkg, packageName),
+                expectedVersionOrRange,
+                actualVersion
+            });
+        }
+    }
+    return incorrectDeps;
+}
+function isDependencyVersionIncorrect(packageName, actualVersion, expectedVersionOrRange) {
+    if (!expectedVersionOrRange) {
+        return false;
+    }
+    // we never want to go backwards with the expo patch version
+    if (packageName === 'expo') {
+        return _semver().default.ltr(actualVersion, expectedVersionOrRange);
+    }
+    // For all other packages, check if the actual version satisfies the expected range
+    const satisfies = _semver().default.satisfies(actualVersion, expectedVersionOrRange, {
+        includePrerelease: true
+    });
+    return !satisfies;
+}
+function findDependencyType(pkg, packageName) {
+    if (pkg.devDependencies && packageName in pkg.devDependencies) {
+        return 'devDependencies';
+    }
+    return 'dependencies';
+}
+
+//# sourceMappingURL=validateDependenciesVersions.js.map

package/build/src/start/doctor/dependencies/validateDependenciesVersions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/doctor/dependencies/validateDependenciesVersions.ts"],"sourcesContent":["import { ExpoConfig, PackageJSONConfig } from '@expo/config';\nimport assert from 'assert';\nimport chalk from 'chalk';\nimport npmPackageArg from 'npm-package-arg';\nimport semver from 'semver';\nimport semverRangeSubset from 'semver/ranges/subset';\n\nimport { BundledNativeModules } from './bundledNativeModules';\nimport { getCombinedKnownVersionsAsync } from './getVersionedPackages';\nimport { resolveAllPackageVersionsAsync } from './resolvePackages';\nimport * as Log from '../../../log';\nimport { env } from '../../../utils/env';\n\nconst debug = require('debug')('expo:doctor:dependencies:validate') as typeof console.log;\n\ntype IncorrectDependency = {\n  packageName: string;\n  packageType: 'dependencies' | 'devDependencies';\n  expectedVersionOrRange: string;\n  actualVersion: string;\n};\n\ntype DependenciesToCheck = { known: string[]; unknown: string[] };\n\n/**\n * Print a list of incorrect dependency versions.\n * This only checks dependencies when not running in offline mode.\n *\n * @param projectRoot Expo project root.\n * @param exp Expo project config.\n * @param pkg Project's `package.json`.\n * @param packagesToCheck A list of packages to check, if undefined or empty, all will be checked.\n * @returns `true` if there are no incorrect dependencies.\n */\nexport async function validateDependenciesVersionsAsync(\n  projectRoot: string,\n  exp: Pick<ExpoConfig, 'sdkVersion'>,\n  pkg: PackageJSONConfig,\n  packagesToCheck?: string[]\n): Promise<boolean | null> {\n  if (env.EXPO_OFFLINE) {\n    Log.warn('Skipping dependency validation in offline mode');\n    return null;\n  } else if (env.EXPO_NO_DEPENDENCY_VALIDATION) {\n    debug('Dependency validation is disabled through EXPO_NO_DEPENDENCY_VALIDATION=1');\n    return null;\n  }\n\n  const incorrectDeps = await getVersionedDependenciesAsync(projectRoot, exp, pkg, packagesToCheck);\n  return logIncorrectDependencies(incorrectDeps);\n}\n\nfunction logInvalidDependency({\n  packageName,\n  expectedVersionOrRange,\n  actualVersion,\n}: IncorrectDependency) {\n  Log.warn(\n    chalk`  {bold ${packageName}}{cyan @}{red ${actualVersion}} - expected version: {green ${expectedVersionOrRange}}`\n  );\n}\n\nexport function logIncorrectDependencies(incorrectDeps: IncorrectDependency[]) {\n  if (!incorrectDeps.length) {\n    return true;\n  }\n\n  Log.warn(\n    chalk`The following packages should be updated for best compatibility with the installed {bold expo} version:`\n  );\n  incorrectDeps.forEach((dep) => logInvalidDependency(dep));\n\n  Log.warn(\n    'Your project may not work correctly until you install the expected versions of the packages.'\n  );\n\n  return false;\n}\n\n/**\n * Return a list of versioned dependencies for the project SDK version.\n *\n * @param projectRoot Expo project root.\n * @param exp Expo project config.\n * @param pkg Project's `package.json`.\n * @param packagesToCheck A list of packages to check, if undefined or empty, all will be checked.\n * @returns A list of incorrect dependencies.\n */\nexport async function getVersionedDependenciesAsync(\n  projectRoot: string,\n  exp: Pick<ExpoConfig, 'sdkVersion'>,\n  pkg: PackageJSONConfig,\n  packagesToCheck?: string[]\n): Promise<IncorrectDependency[]> {\n  // This should never happen under normal circumstances since\n  // the CLI is versioned in the `expo` package.\n  assert(exp.sdkVersion, 'SDK Version is missing');\n\n  // Get from both endpoints and combine the known package versions.\n  const combinedKnownPackages = await getCombinedKnownVersionsAsync({\n    projectRoot,\n    sdkVersion: exp.sdkVersion,\n  });\n  // debug(`Known dependencies: %O`, combinedKnownPackages);\n\n  const resolvedDependencies = packagesToCheck?.length\n    ? // Diff the provided packages to ensure we only check against installed packages.\n      getFilteredObject(packagesToCheck, { ...pkg.dependencies, ...pkg.devDependencies })\n    : // If no packages are provided, check against the `package.json` `dependencies` + `devDependencies` object.\n      { ...pkg.dependencies, ...pkg.devDependencies };\n  debug(`Checking dependencies for ${exp.sdkVersion}: %O`, resolvedDependencies);\n\n  // intersection of packages from package.json and bundled native modules\n  const { known: resolvedPackagesToCheck, unknown } = getPackagesToCheck(\n    combinedKnownPackages,\n    resolvedDependencies\n  );\n  debug(`Comparing known versions: %O`, resolvedPackagesToCheck);\n  debug(`Skipping packages that cannot be versioned automatically: %O`, unknown);\n  // read package versions from the file system (node_modules)\n  const packageVersions = await resolveAllPackageVersionsAsync(\n    projectRoot,\n    resolvedPackagesToCheck\n  );\n  debug(`Package versions: %O`, packageVersions);\n  // find incorrect dependencies by comparing the actual package versions with the bundled native module version ranges\n  let incorrectDeps = findIncorrectDependencies(pkg, packageVersions, combinedKnownPackages);\n  debug(`Incorrect dependencies: %O`, incorrectDeps);\n\n  if (pkg?.expo?.install?.exclude) {\n    const packagesToExclude = pkg.expo.install.exclude;\n\n    // Parse the exclude list to ensure we can factor in any specified version ranges\n    const parsedPackagesToExclude = packagesToExclude.reduce(\n      (acc: Record<string, npmPackageArg.Result>, packageName: string) => {\n        const npaResult = npmPackageArg(packageName);\n        if (typeof npaResult.name === 'string') {\n          acc[npaResult.name] = npaResult;\n        } else {\n          acc[packageName] = npaResult;\n        }\n        return acc;\n      },\n      {}\n    );\n\n    const incorrectAndExcludedDeps = incorrectDeps\n      .filter((dep) => {\n        if (parsedPackagesToExclude[dep.packageName]) {\n          const { name, raw, rawSpec, type } = parsedPackagesToExclude[dep.packageName];\n          const suggestedRange = combinedKnownPackages[name];\n\n          // If only the package name itself is specified, then we keep it in the exclude list\n          if (name === raw) {\n            return true;\n          } else if (type === 'version') {\n            return suggestedRange === rawSpec;\n          } else if (type === 'range') {\n            // Fall through exclusions if the suggested range is invalid\n            if (!semver.validRange(suggestedRange)) {\n              debug(\n                `Invalid semver range in combined known packages for package ${name} in expo.install.exclude: %O`,\n                suggestedRange\n              );\n              return false;\n            }\n\n            return semverRangeSubset(suggestedRange, rawSpec);\n          } else {\n            debug(\n              `Unsupported npm package argument type for package ${name} in expo.install.exclude: %O`,\n              type\n            );\n          }\n        }\n\n        return false;\n      })\n      .map((dep) => dep.packageName);\n\n    debug(\n      `Incorrect dependency warnings filtered out by expo.install.exclude: %O`,\n      incorrectAndExcludedDeps\n    );\n    incorrectDeps = incorrectDeps.filter(\n      (dep) => !incorrectAndExcludedDeps.includes(dep.packageName)\n    );\n  }\n\n  return incorrectDeps;\n}\n\nfunction getFilteredObject(keys: string[], object: Record<string, string>) {\n  return keys.reduce<Record<string, string>>((acc, key) => {\n    acc[key] = object[key];\n    return acc;\n  }, {});\n}\n\nfunction getPackagesToCheck(\n  bundledNativeModules: BundledNativeModules,\n  dependencies?: Record<string, string> | null\n): DependenciesToCheck {\n  const dependencyNames = Object.keys(dependencies ?? {});\n  const known: string[] = [];\n  const unknown: string[] = [];\n  for (const dependencyName of dependencyNames) {\n    if (dependencyName in bundledNativeModules) {\n      known.push(dependencyName);\n    } else {\n      unknown.push(dependencyName);\n    }\n  }\n  return { known, unknown };\n}\n\nfunction findIncorrectDependencies(\n  pkg: PackageJSONConfig,\n  packageVersions: Record<string, string>,\n  bundledNativeModules: BundledNativeModules\n): IncorrectDependency[] {\n  const packages = Object.keys(packageVersions);\n  const incorrectDeps: IncorrectDependency[] = [];\n  for (const packageName of packages) {\n    const expectedVersionOrRange = bundledNativeModules[packageName];\n    const actualVersion = packageVersions[packageName];\n    if (isDependencyVersionIncorrect(packageName, actualVersion, expectedVersionOrRange)) {\n      incorrectDeps.push({\n        packageName,\n        packageType: findDependencyType(pkg, packageName),\n        expectedVersionOrRange,\n        actualVersion,\n      });\n    }\n  }\n  return incorrectDeps;\n}\n\nexport function isDependencyVersionIncorrect(\n  packageName: string,\n  actualVersion: string,\n  expectedVersionOrRange?: string\n) {\n  if (!expectedVersionOrRange) {\n    return false;\n  }\n\n  // we never want to go backwards with the expo patch version\n  if (packageName === 'expo') {\n    return semver.ltr(actualVersion, expectedVersionOrRange);\n  }\n\n  // For all other packages, check if the actual version satisfies the expected range\n  const satisfies = semver.satisfies(actualVersion, expectedVersionOrRange, {\n    includePrerelease: true,\n  });\n\n  return !satisfies;\n}\n\nfunction findDependencyType(\n  pkg: PackageJSONConfig,\n  packageName: string\n): IncorrectDependency['packageType'] {\n  if (pkg.devDependencies && packageName in pkg.devDependencies) {\n    return 'devDependencies';\n  }\n\n  return 'dependencies';\n}\n"],"names":["getVersionedDependenciesAsync","isDependencyVersionIncorrect","logIncorrectDependencies","validateDependenciesVersionsAsync","debug","require","projectRoot","exp","pkg","packagesToCheck","env","EXPO_OFFLINE","Log","warn","EXPO_NO_DEPENDENCY_VALIDATION","incorrectDeps","logInvalidDependency","packageName","expectedVersionOrRange","actualVersion","chalk","length","forEach","dep","assert","sdkVersion","combinedKnownPackages","getCombinedKnownVersionsAsync","resolvedDependencies","getFilteredObject","dependencies","devDependencies","known","resolvedPackagesToCheck","unknown","getPackagesToCheck","packageVersions","resolveAllPackageVersionsAsync","findIncorrectDependencies","expo","install","exclude","packagesToExclude","parsedPackagesToExclude","reduce","acc","npaResult","npmPackageArg","name","incorrectAndExcludedDeps","filter","raw","rawSpec","type","suggestedRange","semver","validRange","semverRangeSubset","map","includes","keys","object","key","bundledNativeModules","dependencyNames","Object","dependencyName","push","packages","packageType","findDependencyType","ltr","satisfies","includePrerelease"],"mappings":"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"}

package/build/src/start/doctor/ngrok/ExternalModule.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ExternalModule: function() {
+        return ExternalModule;
+    },
+    ExternalModuleVersionError: function() {
+        return ExternalModuleVersionError;
+    }
+});
+function _packagemanager() {
+    const data = /*#__PURE__*/ _interop_require_wildcard(require("@expo/package-manager"));
+    _packagemanager = function() {
+        return data;
+    };
+    return data;
+}
+function _resolvefrom() {
+    const data = /*#__PURE__*/ _interop_require_default(require("resolve-from"));
+    _resolvefrom = function() {
+        return data;
+    };
+    return data;
+}
+function _semver() {
+    const data = /*#__PURE__*/ _interop_require_default(require("semver"));
+    _semver = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../log"));
+const _delay = require("../../../utils/delay");
+const _env = require("../../../utils/env");
+const _errors = require("../../../utils/errors");
+const _prompts = require("../../../utils/prompts");
+const _resolveGlobal = require("../../../utils/resolveGlobal");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const debug = require('debug')('expo:doctor:externalModule');
+class ExternalModuleVersionError extends _errors.CommandError {
+    constructor(message, shouldGloballyInstall){
+        super('EXTERNAL_MODULE_VERSION', message), this.shouldGloballyInstall = shouldGloballyInstall;
+    }
+}
+class ExternalModule {
+    constructor(/** Project root for checking if the package is installed locally. */ projectRoot, /** Info on the external package. */ pkg, /** A function used to create the installation prompt message. */ promptMessage){
+        this.projectRoot = projectRoot;
+        this.pkg = pkg;
+        this.promptMessage = promptMessage;
+        this.instance = null;
+    }
+    /** Resolve the globally or locally installed instance, or prompt to install. */ async resolveAsync({ prefersGlobalInstall, ...options } = {}) {
+        try {
+            return this.getVersioned() ?? this.installAsync({
+                ...options,
+                shouldGloballyInstall: prefersGlobalInstall
+            });
+        } catch (error) {
+            if (error instanceof ExternalModuleVersionError) {
+                // If the module version in not compliant with the version range,
+                // we should prompt the user to install the package where it already exists.
+                return this.installAsync({
+                    ...options,
+                    shouldGloballyInstall: error.shouldGloballyInstall ?? prefersGlobalInstall
+                });
+            }
+            throw error;
+        }
+    }
+    /** Prompt the user to install the package and try again. */ async installAsync({ shouldPrompt = true, autoInstall, shouldGloballyInstall } = {}) {
+        const packageName = [
+            this.pkg.name,
+            this.pkg.versionRange
+        ].join('@');
+        if (!autoInstall) {
+            // Delay the prompt so it doesn't conflict with other dev tool logs
+            await (0, _delay.delayAsync)(100);
+        }
+        const answer = autoInstall || shouldPrompt && await (0, _prompts.confirmAsync)({
+            message: this.promptMessage(packageName),
+            initial: true
+        });
+        if (answer) {
+            _log.log(`Installing ${packageName}...`);
+            // Always use npm for global installs
+            const packageManager = shouldGloballyInstall ? new (_packagemanager()).NpmPackageManager({
+                cwd: this.projectRoot,
+                log: _log.log,
+                silent: !(_env.env.EXPO_DEBUG || _env.env.CI)
+            }) : _packagemanager().createForProject(this.projectRoot, {
+                silent: !(_env.env.EXPO_DEBUG || _env.env.CI)
+            });
+            try {
+                if (shouldGloballyInstall) {
+                    await packageManager.addGlobalAsync([
+                        packageName
+                    ]);
+                } else {
+                    await packageManager.addDevAsync([
+                        packageName
+                    ]);
+                }
+                _log.log(`Installed ${packageName}`);
+            } catch (error) {
+                error.message = `Failed to install ${packageName} ${shouldGloballyInstall ? 'globally' : 'locally'}: ${error.message}`;
+                throw error;
+            }
+            return await this.resolveAsync({
+                shouldPrompt: false
+            });
+        }
+        throw new _errors.CommandError('EXTERNAL_MODULE_AVAILABILITY', `Install ${packageName} and try again`);
+    }
+    /** Get the module. */ get() {
+        try {
+            return this.getVersioned();
+        } catch  {
+            return null;
+        }
+    }
+    /** Get the module, throws if the module is not versioned correctly. */ getVersioned() {
+        this.instance ??= this._resolveModule(true) ?? this._resolveModule(false);
+        return this.instance;
+    }
+    /** Exposed for testing. */ _require(moduleId) {
+        return require(moduleId);
+    }
+    /** Resolve a copy that's installed in the project. Exposed for testing. */ _resolveLocal(moduleId) {
+        return (0, _resolvefrom().default)(this.projectRoot, moduleId);
+    }
+    /** Resolve a copy that's installed globally. Exposed for testing. */ _resolveGlobal(moduleId) {
+        return (0, _resolveGlobal.resolveGlobal)(moduleId);
+    }
+    /** Resolve the module and verify the version. Exposed for testing. */ _resolveModule(isLocal) {
+        const resolver = isLocal ? this._resolveLocal.bind(this) : this._resolveGlobal.bind(this);
+        try {
+            const packageJsonPath = resolver(`${this.pkg.name}/package.json`);
+            const packageJson = this._require(packageJsonPath);
+            if (packageJson) {
+                if (_semver().default.satisfies(packageJson.version, this.pkg.versionRange)) {
+                    const modulePath = resolver(this.pkg.name);
+                    const requiredModule = this._require(modulePath);
+                    if (requiredModule == null) {
+                        throw new _errors.CommandError('EXTERNAL_MODULE_EXPORT', `${this.pkg.name} exports a nullish value, which is not allowed.`);
+                    }
+                    return requiredModule;
+                }
+                throw new ExternalModuleVersionError(`Required module '${this.pkg.name}@${packageJson.version}' does not satisfy ${this.pkg.versionRange}. Installed at: ${packageJsonPath}`, !isLocal);
+            }
+        } catch (error) {
+            if (error instanceof _errors.CommandError) {
+                throw error;
+            } else if (error.code !== 'MODULE_NOT_FOUND') {
+                debug('Failed to resolve module', error.message);
+            }
+        }
+        return null;
+    }
+}
+
+//# sourceMappingURL=ExternalModule.js.map

package/build/src/start/doctor/ngrok/ExternalModule.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/doctor/ngrok/ExternalModule.ts"],"sourcesContent":["import * as PackageManager from '@expo/package-manager';\nimport resolveFrom from 'resolve-from';\nimport semver from 'semver';\n\nimport * as Log from '../../../log';\nimport { delayAsync } from '../../../utils/delay';\nimport { env } from '../../../utils/env';\nimport { CommandError } from '../../../utils/errors';\nimport { confirmAsync } from '../../../utils/prompts';\nimport { resolveGlobal } from '../../../utils/resolveGlobal';\n\nconst debug = require('debug')('expo:doctor:externalModule') as typeof console.log;\n\n/** An error that is thrown when a package is installed but doesn't meet the version criteria. */\nexport class ExternalModuleVersionError extends CommandError {\n  constructor(\n    message: string,\n    public readonly shouldGloballyInstall: boolean\n  ) {\n    super('EXTERNAL_MODULE_VERSION', message);\n  }\n}\n\ninterface PromptOptions {\n  /** Should prompt the user to install, when false the module will just assert on missing packages, default `true`. Ignored when `autoInstall` is true. */\n  shouldPrompt?: boolean;\n  /** Should automatically install the package without prompting, default `false` */\n  autoInstall?: boolean;\n}\n\nexport interface InstallPromptOptions extends PromptOptions {\n  /** Should install the package globally, default `false` */\n  shouldGloballyInstall?: boolean;\n}\n\nexport interface ResolvePromptOptions extends PromptOptions {\n  /**\n   * Prefer to install the package globally, this can be overridden if the function\n   * detects that a locally installed package simply needs an upgrade, default `false`\n   */\n  prefersGlobalInstall?: boolean;\n}\n\n/** Resolves a local or globally installed package, prompts to install if missing. */\nexport class ExternalModule<TModule> {\n  private instance: TModule | null = null;\n\n  constructor(\n    /** Project root for checking if the package is installed locally. */\n    private projectRoot: string,\n    /** Info on the external package. */\n    private pkg: {\n      /** NPM package name. */\n      name: string;\n      /** Required semver range, ex: `^1.0.0`. */\n      versionRange: string;\n    },\n    /** A function used to create the installation prompt message. */\n    private promptMessage: (pkgName: string) => string\n  ) {}\n\n  /** Resolve the globally or locally installed instance, or prompt to install. */\n  async resolveAsync({\n    prefersGlobalInstall,\n    ...options\n  }: ResolvePromptOptions = {}): Promise<TModule> {\n    try {\n      return (\n        this.getVersioned() ??\n        this.installAsync({\n          ...options,\n          shouldGloballyInstall: prefersGlobalInstall,\n        })\n      );\n    } catch (error: any) {\n      if (error instanceof ExternalModuleVersionError) {\n        // If the module version in not compliant with the version range,\n        // we should prompt the user to install the package where it already exists.\n        return this.installAsync({\n          ...options,\n          shouldGloballyInstall: error.shouldGloballyInstall ?? prefersGlobalInstall,\n        });\n      }\n      throw error;\n    }\n  }\n\n  /** Prompt the user to install the package and try again. */\n  async installAsync({\n    shouldPrompt = true,\n    autoInstall,\n    shouldGloballyInstall,\n  }: InstallPromptOptions = {}): Promise<TModule> {\n    const packageName = [this.pkg.name, this.pkg.versionRange].join('@');\n    if (!autoInstall) {\n      // Delay the prompt so it doesn't conflict with other dev tool logs\n      await delayAsync(100);\n    }\n    const answer =\n      autoInstall ||\n      (shouldPrompt &&\n        (await confirmAsync({\n          message: this.promptMessage(packageName),\n          initial: true,\n        })));\n    if (answer) {\n      Log.log(`Installing ${packageName}...`);\n\n      // Always use npm for global installs\n      const packageManager = shouldGloballyInstall\n        ? new PackageManager.NpmPackageManager({\n            cwd: this.projectRoot,\n            log: Log.log,\n            silent: !(env.EXPO_DEBUG || env.CI),\n          })\n        : PackageManager.createForProject(this.projectRoot, {\n            silent: !(env.EXPO_DEBUG || env.CI),\n          });\n\n      try {\n        if (shouldGloballyInstall) {\n          await packageManager.addGlobalAsync([packageName]);\n        } else {\n          await packageManager.addDevAsync([packageName]);\n        }\n        Log.log(`Installed ${packageName}`);\n      } catch (error: any) {\n        error.message = `Failed to install ${packageName} ${\n          shouldGloballyInstall ? 'globally' : 'locally'\n        }: ${error.message}`;\n        throw error;\n      }\n      return await this.resolveAsync({ shouldPrompt: false });\n    }\n\n    throw new CommandError('EXTERNAL_MODULE_AVAILABILITY', `Install ${packageName} and try again`);\n  }\n\n  /** Get the module. */\n  get(): TModule | null {\n    try {\n      return this.getVersioned();\n    } catch {\n      return null;\n    }\n  }\n\n  /** Get the module, throws if the module is not versioned correctly. */\n  getVersioned(): TModule | null {\n    this.instance ??= this._resolveModule(true) ?? this._resolveModule(false);\n    return this.instance;\n  }\n\n  /** Exposed for testing. */\n  _require(moduleId: string): any {\n    return require(moduleId);\n  }\n\n  /** Resolve a copy that's installed in the project. Exposed for testing. */\n  _resolveLocal(moduleId: string): string {\n    return resolveFrom(this.projectRoot, moduleId);\n  }\n\n  /** Resolve a copy that's installed globally. Exposed for testing. */\n  _resolveGlobal(moduleId: string): string {\n    return resolveGlobal(moduleId);\n  }\n\n  /** Resolve the module and verify the version. Exposed for testing. */\n  _resolveModule(isLocal: boolean): TModule | null {\n    const resolver = isLocal ? this._resolveLocal.bind(this) : this._resolveGlobal.bind(this);\n    try {\n      const packageJsonPath = resolver(`${this.pkg.name}/package.json`);\n      const packageJson = this._require(packageJsonPath);\n      if (packageJson) {\n        if (semver.satisfies(packageJson.version, this.pkg.versionRange)) {\n          const modulePath = resolver(this.pkg.name);\n          const requiredModule = this._require(modulePath);\n          if (requiredModule == null) {\n            throw new CommandError(\n              'EXTERNAL_MODULE_EXPORT',\n              `${this.pkg.name} exports a nullish value, which is not allowed.`\n            );\n          }\n          return requiredModule;\n        }\n        throw new ExternalModuleVersionError(\n          `Required module '${this.pkg.name}@${packageJson.version}' does not satisfy ${this.pkg.versionRange}. Installed at: ${packageJsonPath}`,\n          !isLocal\n        );\n      }\n    } catch (error: any) {\n      if (error instanceof CommandError) {\n        throw error;\n      } else if (error.code !== 'MODULE_NOT_FOUND') {\n        debug('Failed to resolve module', error.message);\n      }\n    }\n    return null;\n  }\n}\n"],"names":["ExternalModule","ExternalModuleVersionError","debug","require","CommandError","constructor","message","shouldGloballyInstall","projectRoot","pkg","promptMessage","instance","resolveAsync","prefersGlobalInstall","options","getVersioned","installAsync","error","shouldPrompt","autoInstall","packageName","name","versionRange","join","delayAsync","answer","confirmAsync","initial","Log","log","packageManager","PackageManager","NpmPackageManager","cwd","silent","env","EXPO_DEBUG","CI","createForProject","addGlobalAsync","addDevAsync","get","_resolveModule","_require","moduleId","_resolveLocal","resolveFrom","_resolveGlobal","resolveGlobal","isLocal","resolver","bind","packageJsonPath","packageJson","semver","satisfies","version","modulePath","requiredModule","code"],"mappings":";;;;;;;;;;;IA4CaA,cAAc;eAAdA;;IA9BAC,0BAA0B;eAA1BA;;;;iEAdmB;;;;;;;gEACR;;;;;;;gEACL;;;;;;6DAEE;uBACM;qBACP;wBACS;yBACA;+BACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9B,MAAMC,QAAQC,QAAQ,SAAS;AAGxB,MAAMF,mCAAmCG,oBAAY;IAC1DC,YACEC,OAAe,EACf,AAAgBC,qBAA8B,CAC9C;QACA,KAAK,CAAC,2BAA2BD,eAFjBC,wBAAAA;IAGlB;AACF;AAuBO,MAAMP;IAGXK,YACE,mEAAmE,GACnE,AAAQG,WAAmB,EAC3B,kCAAkC,GAClC,AAAQC,GAKP,EACD,+DAA+D,GAC/D,AAAQC,aAA0C,CAClD;aAVQF,cAAAA;aAEAC,MAAAA;aAOAC,gBAAAA;aAbFC,WAA2B;IAchC;IAEH,8EAA8E,GAC9E,MAAMC,aAAa,EACjBC,oBAAoB,EACpB,GAAGC,SACkB,GAAG,CAAC,CAAC,EAAoB;QAC9C,IAAI;YACF,OACE,IAAI,CAACC,YAAY,MACjB,IAAI,CAACC,YAAY,CAAC;gBAChB,GAAGF,OAAO;gBACVP,uBAAuBM;YACzB;QAEJ,EAAE,OAAOI,OAAY;YACnB,IAAIA,iBAAiBhB,4BAA4B;gBAC/C,iEAAiE;gBACjE,4EAA4E;gBAC5E,OAAO,IAAI,CAACe,YAAY,CAAC;oBACvB,GAAGF,OAAO;oBACVP,uBAAuBU,MAAMV,qBAAqB,IAAIM;gBACxD;YACF;YACA,MAAMI;QACR;IACF;IAEA,0DAA0D,GAC1D,MAAMD,aAAa,EACjBE,eAAe,IAAI,EACnBC,WAAW,EACXZ,qBAAqB,EACA,GAAG,CAAC,CAAC,EAAoB;QAC9C,MAAMa,cAAc;YAAC,IAAI,CAACX,GAAG,CAACY,IAAI;YAAE,IAAI,CAACZ,GAAG,CAACa,YAAY;SAAC,CAACC,IAAI,CAAC;QAChE,IAAI,CAACJ,aAAa;YAChB,mEAAmE;YACnE,MAAMK,IAAAA,iBAAU,EAAC;QACnB;QACA,MAAMC,SACJN,eACCD,gBACE,MAAMQ,IAAAA,qBAAY,EAAC;YAClBpB,SAAS,IAAI,CAACI,aAAa,CAACU;YAC5BO,SAAS;QACX;QACJ,IAAIF,QAAQ;YACVG,KAAIC,GAAG,CAAC,CAAC,WAAW,EAAET,YAAY,GAAG,CAAC;YAEtC,qCAAqC;YACrC,MAAMU,iBAAiBvB,wBACnB,IAAIwB,CAAAA,iBAAa,EAAEC,iBAAiB,CAAC;gBACnCC,KAAK,IAAI,CAACzB,WAAW;gBACrBqB,KAAKD,KAAIC,GAAG;gBACZK,QAAQ,CAAEC,CAAAA,QAAG,CAACC,UAAU,IAAID,QAAG,CAACE,EAAE,AAAD;YACnC,KACAN,kBAAeO,gBAAgB,CAAC,IAAI,CAAC9B,WAAW,EAAE;gBAChD0B,QAAQ,CAAEC,CAAAA,QAAG,CAACC,UAAU,IAAID,QAAG,CAACE,EAAE,AAAD;YACnC;YAEJ,IAAI;gBACF,IAAI9B,uBAAuB;oBACzB,MAAMuB,eAAeS,cAAc,CAAC;wBAACnB;qBAAY;gBACnD,OAAO;oBACL,MAAMU,eAAeU,WAAW,CAAC;wBAACpB;qBAAY;gBAChD;gBACAQ,KAAIC,GAAG,CAAC,CAAC,UAAU,EAAET,aAAa;YACpC,EAAE,OAAOH,OAAY;gBACnBA,MAAMX,OAAO,GAAG,CAAC,kBAAkB,EAAEc,YAAY,CAAC,EAChDb,wBAAwB,aAAa,UACtC,EAAE,EAAEU,MAAMX,OAAO,EAAE;gBACpB,MAAMW;YACR;YACA,OAAO,MAAM,IAAI,CAACL,YAAY,CAAC;gBAAEM,cAAc;YAAM;QACvD;QAEA,MAAM,IAAId,oBAAY,CAAC,gCAAgC,CAAC,QAAQ,EAAEgB,YAAY,cAAc,CAAC;IAC/F;IAEA,oBAAoB,GACpBqB,MAAsB;QACpB,IAAI;YACF,OAAO,IAAI,CAAC1B,YAAY;QAC1B,EAAE,OAAM;YACN,OAAO;QACT;IACF;IAEA,qEAAqE,GACrEA,eAA+B;QAC7B,IAAI,CAACJ,QAAQ,KAAK,IAAI,CAAC+B,cAAc,CAAC,SAAS,IAAI,CAACA,cAAc,CAAC;QACnE,OAAO,IAAI,CAAC/B,QAAQ;IACtB;IAEA,yBAAyB,GACzBgC,SAASC,QAAgB,EAAO;QAC9B,OAAOzC,QAAQyC;IACjB;IAEA,yEAAyE,GACzEC,cAAcD,QAAgB,EAAU;QACtC,OAAOE,IAAAA,sBAAW,EAAC,IAAI,CAACtC,WAAW,EAAEoC;IACvC;IAEA,mEAAmE,GACnEG,eAAeH,QAAgB,EAAU;QACvC,OAAOI,IAAAA,4BAAa,EAACJ;IACvB;IAEA,oEAAoE,GACpEF,eAAeO,OAAgB,EAAkB;QAC/C,MAAMC,WAAWD,UAAU,IAAI,CAACJ,aAAa,CAACM,IAAI,CAAC,IAAI,IAAI,IAAI,CAACJ,cAAc,CAACI,IAAI,CAAC,IAAI;QACxF,IAAI;YACF,MAAMC,kBAAkBF,SAAS,GAAG,IAAI,CAACzC,GAAG,CAACY,IAAI,CAAC,aAAa,CAAC;YAChE,MAAMgC,cAAc,IAAI,CAACV,QAAQ,CAACS;YAClC,IAAIC,aAAa;gBACf,IAAIC,iBAAM,CAACC,SAAS,CAACF,YAAYG,OAAO,EAAE,IAAI,CAAC/C,GAAG,CAACa,YAAY,GAAG;oBAChE,MAAMmC,aAAaP,SAAS,IAAI,CAACzC,GAAG,CAACY,IAAI;oBACzC,MAAMqC,iBAAiB,IAAI,CAACf,QAAQ,CAACc;oBACrC,IAAIC,kBAAkB,MAAM;wBAC1B,MAAM,IAAItD,oBAAY,CACpB,0BACA,GAAG,IAAI,CAACK,GAAG,CAACY,IAAI,CAAC,+CAA+C,CAAC;oBAErE;oBACA,OAAOqC;gBACT;gBACA,MAAM,IAAIzD,2BACR,CAAC,iBAAiB,EAAE,IAAI,CAACQ,GAAG,CAACY,IAAI,CAAC,CAAC,EAAEgC,YAAYG,OAAO,CAAC,mBAAmB,EAAE,IAAI,CAAC/C,GAAG,CAACa,YAAY,CAAC,gBAAgB,EAAE8B,iBAAiB,EACvI,CAACH;YAEL;QACF,EAAE,OAAOhC,OAAY;YACnB,IAAIA,iBAAiBb,oBAAY,EAAE;gBACjC,MAAMa;YACR,OAAO,IAAIA,MAAM0C,IAAI,KAAK,oBAAoB;gBAC5CzD,MAAM,4BAA4Be,MAAMX,OAAO;YACjD;QACF;QACA,OAAO;IACT;AACF"}

package/build/src/start/doctor/ngrok/NgrokResolver.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NgrokResolver: function() {
+        return NgrokResolver;
+    },
+    isNgrokClientError: function() {
+        return isNgrokClientError;
+    }
+});
+const _ExternalModule = require("./ExternalModule");
+class NgrokResolver extends _ExternalModule.ExternalModule {
+    constructor(projectRoot){
+        super(projectRoot, {
+            name: '@expo/ngrok',
+            versionRange: '^4.1.0'
+        }, (packageName)=>`The package ${packageName} is required to use tunnels, would you like to install it globally?`);
+    }
+}
+function isNgrokClientError(error) {
+    var _error_body;
+    return error == null ? void 0 : (_error_body = error.body) == null ? void 0 : _error_body.msg;
+}
+
+//# sourceMappingURL=NgrokResolver.js.map

package/build/src/start/doctor/ngrok/NgrokResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/doctor/ngrok/NgrokResolver.ts"],"sourcesContent":["import { ExternalModule } from './ExternalModule';\n\nexport interface NgrokClientError {\n  body: {\n    error_code: number;\n    status_code: number;\n    msg: string;\n    details: {\n      err: string;\n    };\n  };\n}\n\nexport interface NgrokOptions {\n  authtoken?: string;\n  port?: string | number | null;\n  host?: string;\n  httpauth?: string;\n  region?: string;\n  configPath?: string;\n\n  proto?: 'http' | 'tcp' | 'tls';\n  addr?: string;\n  inspect?: boolean;\n  auth?: string;\n  host_header?: string;\n  bind_tls?: true | false | 'both';\n  subdomain?: string;\n  hostname?: string;\n  crt?: string;\n  key?: string;\n  client_cas?: string;\n  remote_addr?: string;\n}\n\nexport interface NgrokInstance {\n  getActiveProcess(): { pid: number };\n  connect(\n    props: {\n      hostname?: string;\n      configPath: string;\n      onStatusChange: (status: string) => void;\n    } & NgrokOptions\n  ): Promise<string>;\n  kill(): Promise<void>;\n}\n\n/** Resolves the ngrok instance from local or globally installed package. */\nexport class NgrokResolver extends ExternalModule<NgrokInstance> {\n  constructor(projectRoot: string) {\n    super(\n      projectRoot,\n      {\n        name: '@expo/ngrok',\n        versionRange: '^4.1.0',\n      },\n      (packageName) =>\n        `The package ${packageName} is required to use tunnels, would you like to install it globally?`\n    );\n  }\n}\n\nexport function isNgrokClientError(error: any): error is NgrokClientError {\n  return error?.body?.msg;\n}\n"],"names":["NgrokResolver","isNgrokClientError","ExternalModule","constructor","projectRoot","name","versionRange","packageName","error","body","msg"],"mappings":";;;;;;;;;;;IAgDaA,aAAa;eAAbA;;IAcGC,kBAAkB;eAAlBA;;;gCA9De;AAgDxB,MAAMD,sBAAsBE,8BAAc;IAC/CC,YAAYC,WAAmB,CAAE;QAC/B,KAAK,CACHA,aACA;YACEC,MAAM;YACNC,cAAc;QAChB,GACA,CAACC,cACC,CAAC,YAAY,EAAEA,YAAY,mEAAmE,CAAC;IAErG;AACF;AAEO,SAASN,mBAAmBO,KAAU;QACpCA;IAAP,OAAOA,0BAAAA,cAAAA,MAAOC,IAAI,qBAAXD,YAAaE,GAAG;AACzB"}