@depup/expo__cli 55.0.16-depup.0

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

@@ -0,0 +1,192 @@
+"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, {
+    createInstallCommand: function() {
+        return createInstallCommand;
+    },
+    ensureDependenciesAsync: function() {
+        return ensureDependenciesAsync;
+    }
+});
+function _config() {
+    const data = require("@expo/config");
+    _config = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _wrapansi() {
+    const data = /*#__PURE__*/ _interop_require_default(require("wrap-ansi"));
+    _wrapansi = function() {
+        return data;
+    };
+    return data;
+}
+const _getMissingPackages = require("./getMissingPackages");
+const _installAsync = require("../../../install/installAsync");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../log"));
+const _errors = require("../../../utils/errors");
+const _interactive = require("../../../utils/interactive");
+const _ora = require("../../../utils/ora");
+const _prompts = require("../../../utils/prompts");
+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;
+}
+async function ensureDependenciesAsync(projectRoot, { exp = (0, _config().getConfig)(projectRoot).exp, requiredPackages, warningMessage, installMessage, // Don't prompt in CI
+skipPrompt = !(0, _interactive.isInteractive)(), isProjectMutable = (0, _interactive.isInteractive)() }) {
+    const { missing } = await (0, _getMissingPackages.getMissingPackagesAsync)(projectRoot, {
+        sdkVersion: exp.sdkVersion,
+        requiredPackages
+    });
+    if (!missing.length) {
+        return true;
+    }
+    // Prompt to install or bail out...
+    const readableMissingPackages = missing.map(({ pkg, version })=>version ? [
+            pkg,
+            version
+        ].join('@') : pkg).join(', ');
+    let title = installMessage;
+    if (skipPrompt && !isProjectMutable) {
+        title += '\n\n';
+    } else {
+        let confirm = skipPrompt;
+        if (skipPrompt) {
+            // Automatically install packages without prompting.
+            _log.log(wrapForTerminal(title + ` Installing ${_chalk().default.cyan(readableMissingPackages)}`));
+        } else {
+            confirm = await (0, _prompts.confirmAsync)({
+                message: wrapForTerminal(title + ` Would you like to install ${_chalk().default.cyan(readableMissingPackages)}?`),
+                initial: true
+            });
+        }
+        if (confirm) {
+            // Format with version if available.
+            const [packages, devPackages] = missing.reduce(([deps, devDeps], p)=>{
+                const pkg = p.version ? [
+                    p.pkg,
+                    p.version
+                ].join('@') : p.pkg;
+                if (p.dev) {
+                    return [
+                        deps,
+                        devDeps.concat(pkg)
+                    ];
+                }
+                return [
+                    deps.concat(pkg),
+                    devDeps
+                ];
+            }, [
+                [],
+                []
+            ]);
+            if (packages.length) {
+                await installPackagesAsync(projectRoot, {
+                    packages
+                });
+            }
+            if (devPackages.length) {
+                await installPackagesAsync(projectRoot, {
+                    packages: devPackages,
+                    dev: true
+                });
+            }
+            // Try again but skip prompting twice, simply fail if the packages didn't install correctly.
+            return await ensureDependenciesAsync(projectRoot, {
+                skipPrompt: true,
+                installMessage,
+                warningMessage,
+                requiredPackages
+            });
+        }
+        // Reset the title so it doesn't print twice in interactive mode.
+        title = '';
+    }
+    const installCommand = 'npx expo install ' + missing.map(({ pkg })=>pkg).join(' ');
+    const disableMessage = warningMessage;
+    const solution = `Install ${_chalk().default.bold(readableMissingPackages)} by running:\n\n  ${_chalk().default.reset.bold(installCommand)}\n\n`;
+    // This prevents users from starting a misconfigured JS or TS project by default.
+    throw new _errors.CommandError(wrapForTerminal(title + solution + disableMessage + '\n'));
+}
+/**  Wrap long messages to fit smaller terminals. */ function wrapForTerminal(message) {
+    return (0, _wrapansi().default)(message, process.stdout.columns || 80);
+}
+function createInstallCommand({ packages }) {
+    return 'npx expo install ' + packages.map(({ pkg })=>pkg).join(' ');
+}
+/** Install packages in the project. */ async function installPackagesAsync(projectRoot, { packages, dev }) {
+    const packagesStr = _chalk().default.bold(packages.join(', '));
+    _log.log();
+    const installingPackageStep = (0, _ora.logNewSection)(`Installing ${packagesStr}`);
+    try {
+        await (0, _installAsync.installAsync)(packages, {
+            projectRoot,
+            dev
+        });
+    } catch (e) {
+        installingPackageStep.fail(`Failed to install ${packagesStr} with error: ${e.message}`);
+        throw e;
+    }
+    installingPackageStep.succeed(`Installed ${packagesStr}`);
+}
+
+//# sourceMappingURL=ensureDependenciesAsync.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/doctor/dependencies/ensureDependenciesAsync.ts"],"sourcesContent":["import { ExpoConfig, getConfig } from '@expo/config';\nimport chalk from 'chalk';\nimport wrapAnsi from 'wrap-ansi';\n\nimport { getMissingPackagesAsync, ResolvedPackage } from './getMissingPackages';\nimport { installAsync } from '../../../install/installAsync';\nimport * as Log from '../../../log';\nimport { CommandError } from '../../../utils/errors';\nimport { isInteractive } from '../../../utils/interactive';\nimport { logNewSection } from '../../../utils/ora';\nimport { confirmAsync } from '../../../utils/prompts';\n\nexport type EnsureDependenciesOptions = {\n  /** The packages and/or version ranges that should be enforced in the project */\n  requiredPackages: ResolvedPackage[];\n  /** The user-facing message when the required packages are missing or incorrect */\n  installMessage: string;\n  /** The user-facing message when users aborted the installation */\n  warningMessage: string;\n  /** A previously loaded Expo configuration (loads when omitted) */\n  exp?: ExpoConfig;\n  /** If the prompts asking users to install should be skipped (defaults to false, in CI defaults to true) */\n  skipPrompt?: boolean;\n  /** Project can be mutated in the current environment (defaults to true, in CI defaults to false) */\n  isProjectMutable?: boolean;\n};\n\nexport async function ensureDependenciesAsync(\n  projectRoot: string,\n  {\n    exp = getConfig(projectRoot).exp,\n    requiredPackages,\n    warningMessage,\n    installMessage,\n    // Don't prompt in CI\n    skipPrompt = !isInteractive(),\n    isProjectMutable = isInteractive(),\n  }: EnsureDependenciesOptions\n): Promise<boolean> {\n  const { missing } = await getMissingPackagesAsync(projectRoot, {\n    sdkVersion: exp.sdkVersion,\n    requiredPackages,\n  });\n  if (!missing.length) {\n    return true;\n  }\n\n  // Prompt to install or bail out...\n  const readableMissingPackages = missing\n    .map(({ pkg, version }) => (version ? [pkg, version].join('@') : pkg))\n    .join(', ');\n\n  let title = installMessage;\n\n  if (skipPrompt && !isProjectMutable) {\n    title += '\\n\\n';\n  } else {\n    let confirm = skipPrompt;\n    if (skipPrompt) {\n      // Automatically install packages without prompting.\n      Log.log(wrapForTerminal(title + ` Installing ${chalk.cyan(readableMissingPackages)}`));\n    } else {\n      confirm = await confirmAsync({\n        message: wrapForTerminal(\n          title + ` Would you like to install ${chalk.cyan(readableMissingPackages)}?`\n        ),\n        initial: true,\n      });\n    }\n\n    if (confirm) {\n      // Format with version if available.\n      const [packages, devPackages] = missing.reduce(\n        ([deps, devDeps], p) => {\n          const pkg = p.version ? [p.pkg, p.version].join('@') : p.pkg;\n          if (p.dev) {\n            return [deps, devDeps.concat(pkg)];\n          }\n          return [deps.concat(pkg), devDeps];\n        },\n        [[], []] as [string[], string[]]\n      );\n\n      if (packages.length) {\n        await installPackagesAsync(projectRoot, {\n          packages,\n        });\n      }\n\n      if (devPackages.length) {\n        await installPackagesAsync(projectRoot, {\n          packages: devPackages,\n          dev: true,\n        });\n      }\n\n      // Try again but skip prompting twice, simply fail if the packages didn't install correctly.\n      return await ensureDependenciesAsync(projectRoot, {\n        skipPrompt: true,\n        installMessage,\n        warningMessage,\n        requiredPackages,\n      });\n    }\n\n    // Reset the title so it doesn't print twice in interactive mode.\n    title = '';\n  }\n\n  const installCommand = 'npx expo install ' + missing.map(({ pkg }) => pkg).join(' ');\n\n  const disableMessage = warningMessage;\n\n  const solution = `Install ${chalk.bold(\n    readableMissingPackages\n  )} by running:\\n\\n  ${chalk.reset.bold(installCommand)}\\n\\n`;\n\n  // This prevents users from starting a misconfigured JS or TS project by default.\n  throw new CommandError(wrapForTerminal(title + solution + disableMessage + '\\n'));\n}\n\n/**  Wrap long messages to fit smaller terminals. */\nfunction wrapForTerminal(message: string): string {\n  return wrapAnsi(message, process.stdout.columns || 80);\n}\n\n/** Create the bash install command from a given set of packages and settings. */\nexport function createInstallCommand({\n  packages,\n}: {\n  packages: {\n    file: string;\n    pkg: string;\n    version?: string | undefined;\n  }[];\n}) {\n  return 'npx expo install ' + packages.map(({ pkg }) => pkg).join(' ');\n}\n\n/** Install packages in the project. */\nasync function installPackagesAsync(\n  projectRoot: string,\n  { packages, dev }: { packages: string[]; dev?: boolean }\n) {\n  const packagesStr = chalk.bold(packages.join(', '));\n  Log.log();\n  const installingPackageStep = logNewSection(`Installing ${packagesStr}`);\n  try {\n    await installAsync(packages, { projectRoot, dev });\n  } catch (e: any) {\n    installingPackageStep.fail(`Failed to install ${packagesStr} with error: ${e.message}`);\n    throw e;\n  }\n  installingPackageStep.succeed(`Installed ${packagesStr}`);\n}\n"],"names":["createInstallCommand","ensureDependenciesAsync","projectRoot","exp","getConfig","requiredPackages","warningMessage","installMessage","skipPrompt","isInteractive","isProjectMutable","missing","getMissingPackagesAsync","sdkVersion","length","readableMissingPackages","map","pkg","version","join","title","confirm","Log","log","wrapForTerminal","chalk","cyan","confirmAsync","message","initial","packages","devPackages","reduce","deps","devDeps","p","dev","concat","installPackagesAsync","installCommand","disableMessage","solution","bold","reset","CommandError","wrapAnsi","process","stdout","columns","packagesStr","installingPackageStep","logNewSection","installAsync","e","fail","succeed"],"mappings":"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"}

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

@@ -0,0 +1,108 @@
+"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, {
+    collectMissingPackages: function() {
+        return collectMissingPackages;
+    },
+    getMissingPackagesAsync: function() {
+        return getMissingPackagesAsync;
+    },
+    mutatePackagesWithKnownVersionsAsync: function() {
+        return mutatePackagesWithKnownVersionsAsync;
+    },
+    versionSatisfiesRequiredPackage: function() {
+        return versionSatisfiesRequiredPackage;
+    }
+});
+function _jsonfile() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/json-file"));
+    _jsonfile = 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 _getVersionedPackages = require("./getVersionedPackages");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:doctor:dependencies:getMissingPackages');
+function collectMissingPackages(projectRoot, requiredPackages) {
+    const resolutions = {};
+    const missingPackages = requiredPackages.filter((p)=>{
+        const resolved = _resolvefrom().default.silent(projectRoot, p.file);
+        if (!resolved || !versionSatisfiesRequiredPackage(resolved, p)) {
+            return true;
+        }
+        resolutions[p.pkg] = resolved;
+        return false;
+    });
+    return {
+        missing: missingPackages,
+        resolutions
+    };
+}
+function versionSatisfiesRequiredPackage(packageJsonFilePath, resolvedPackage) {
+    // If the version is specified, check that it satisfies the installed version.
+    if (!resolvedPackage.version) {
+        debug(`Required package "${resolvedPackage.pkg}" found (no version constraint specified).`);
+        return true;
+    }
+    const pkgJson = _jsonfile().default.read(packageJsonFilePath);
+    if (// package.json has version.
+    typeof pkgJson.version === 'string' && // semver satisfaction.
+    _semver().default.satisfies(pkgJson.version, resolvedPackage.version)) {
+        return true;
+    }
+    debug(`Installed package "${resolvedPackage.pkg}" does not satisfy version constraint "${resolvedPackage.version}" (version: "${pkgJson.version}")`);
+    return false;
+}
+async function getMissingPackagesAsync(projectRoot, { sdkVersion, requiredPackages }) {
+    const results = collectMissingPackages(projectRoot, requiredPackages);
+    if (!results.missing.length) {
+        return results;
+    }
+    // Ensure the versions are right for the SDK that the project is currently using.
+    await mutatePackagesWithKnownVersionsAsync(projectRoot, sdkVersion, results.missing);
+    return results;
+}
+async function mutatePackagesWithKnownVersionsAsync(projectRoot, sdkVersion, packages) {
+    // Ensure the versions are right for the SDK that the project is currently using.
+    const relatedPackages = await (0, _getVersionedPackages.getCombinedKnownVersionsAsync)({
+        projectRoot,
+        sdkVersion
+    });
+    for (const pkg of packages){
+        if (// Only use the SDK versions if the package does not already have a hardcoded version.
+        // We do this because some packages have API coded into the CLI which expects an exact version.
+        !pkg.version && pkg.pkg in relatedPackages) {
+            pkg.version = relatedPackages[pkg.pkg];
+        }
+    }
+    return packages;
+}
+
+//# sourceMappingURL=getMissingPackages.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/doctor/dependencies/getMissingPackages.ts"],"sourcesContent":["import JsonFile from '@expo/json-file';\nimport resolveFrom from 'resolve-from';\nimport semver from 'semver';\n\nimport { getCombinedKnownVersionsAsync } from './getVersionedPackages';\n\nconst debug = require('debug')('expo:doctor:dependencies:getMissingPackages') as typeof console.log;\n\nexport type ResolvedPackage = {\n  /** Module ID pointing to the library `package.json`. */\n  file: string;\n  /** NPM package name. */\n  pkg: string;\n  /** Required version range. */\n  version?: string;\n  /** If the dependency should be installed as a `devDependency` */\n  dev?: boolean;\n};\n\n/** Given a set of required packages, this method returns a list of missing packages. */\nexport function collectMissingPackages(\n  projectRoot: string,\n  requiredPackages: ResolvedPackage[]\n): {\n  missing: ResolvedPackage[];\n  resolutions: Record<string, string>;\n} {\n  const resolutions: Record<string, string> = {};\n\n  const missingPackages = requiredPackages.filter((p) => {\n    const resolved = resolveFrom.silent(projectRoot, p.file);\n    if (!resolved || !versionSatisfiesRequiredPackage(resolved, p)) {\n      return true;\n    }\n    resolutions[p.pkg] = resolved;\n    return false;\n  });\n\n  return { missing: missingPackages, resolutions };\n}\n\nexport function versionSatisfiesRequiredPackage(\n  packageJsonFilePath: string,\n  resolvedPackage: Pick<ResolvedPackage, 'version' | 'pkg'>\n): boolean {\n  // If the version is specified, check that it satisfies the installed version.\n  if (!resolvedPackage.version) {\n    debug(`Required package \"${resolvedPackage.pkg}\" found (no version constraint specified).`);\n    return true;\n  }\n\n  const pkgJson = JsonFile.read(packageJsonFilePath);\n  if (\n    // package.json has version.\n    typeof pkgJson.version === 'string' &&\n    // semver satisfaction.\n    semver.satisfies(pkgJson.version, resolvedPackage.version)\n  ) {\n    return true;\n  }\n  debug(\n    `Installed package \"${resolvedPackage.pkg}\" does not satisfy version constraint \"${resolvedPackage.version}\" (version: \"${pkgJson.version}\")`\n  );\n  return false;\n}\n\n/**\n * Collect missing packages given a list of required packages.\n * Any missing packages will be versioned to the known versions for the current SDK.\n *\n * @param projectRoot\n * @param props.requiredPackages list of required packages to check for\n * @returns list of missing packages and resolutions to existing packages.\n */\nexport async function getMissingPackagesAsync(\n  projectRoot: string,\n  {\n    sdkVersion,\n    requiredPackages,\n  }: {\n    sdkVersion?: string;\n    requiredPackages: ResolvedPackage[];\n  }\n): Promise<{\n  missing: ResolvedPackage[];\n  resolutions: Record<string, string>;\n}> {\n  const results = collectMissingPackages(projectRoot, requiredPackages);\n  if (!results.missing.length) {\n    return results;\n  }\n\n  // Ensure the versions are right for the SDK that the project is currently using.\n  await mutatePackagesWithKnownVersionsAsync(projectRoot, sdkVersion, results.missing);\n\n  return results;\n}\n\nexport async function mutatePackagesWithKnownVersionsAsync(\n  projectRoot: string,\n  sdkVersion: string | undefined,\n  packages: ResolvedPackage[]\n) {\n  // Ensure the versions are right for the SDK that the project is currently using.\n  const relatedPackages = await getCombinedKnownVersionsAsync({ projectRoot, sdkVersion });\n  for (const pkg of packages) {\n    if (\n      // Only use the SDK versions if the package does not already have a hardcoded version.\n      // We do this because some packages have API coded into the CLI which expects an exact version.\n      !pkg.version &&\n      pkg.pkg in relatedPackages\n    ) {\n      pkg.version = relatedPackages[pkg.pkg];\n    }\n  }\n  return packages;\n}\n"],"names":["collectMissingPackages","getMissingPackagesAsync","mutatePackagesWithKnownVersionsAsync","versionSatisfiesRequiredPackage","debug","require","projectRoot","requiredPackages","resolutions","missingPackages","filter","p","resolved","resolveFrom","silent","file","pkg","missing","packageJsonFilePath","resolvedPackage","version","pkgJson","JsonFile","read","semver","satisfies","sdkVersion","results","length","packages","relatedPackages","getCombinedKnownVersionsAsync"],"mappings":";;;;;;;;;;;IAoBgBA,sBAAsB;eAAtBA;;IAsDMC,uBAAuB;eAAvBA;;IAwBAC,oCAAoC;eAApCA;;IAzDNC,+BAA+B;eAA/BA;;;;gEAzCK;;;;;;;gEACG;;;;;;;gEACL;;;;;;sCAE2B;;;;;;AAE9C,MAAMC,QAAQC,QAAQ,SAAS;AAcxB,SAASL,uBACdM,WAAmB,EACnBC,gBAAmC;IAKnC,MAAMC,cAAsC,CAAC;IAE7C,MAAMC,kBAAkBF,iBAAiBG,MAAM,CAAC,CAACC;QAC/C,MAAMC,WAAWC,sBAAW,CAACC,MAAM,CAACR,aAAaK,EAAEI,IAAI;QACvD,IAAI,CAACH,YAAY,CAACT,gCAAgCS,UAAUD,IAAI;YAC9D,OAAO;QACT;QACAH,WAAW,CAACG,EAAEK,GAAG,CAAC,GAAGJ;QACrB,OAAO;IACT;IAEA,OAAO;QAAEK,SAASR;QAAiBD;IAAY;AACjD;AAEO,SAASL,gCACde,mBAA2B,EAC3BC,eAAyD;IAEzD,8EAA8E;IAC9E,IAAI,CAACA,gBAAgBC,OAAO,EAAE;QAC5BhB,MAAM,CAAC,kBAAkB,EAAEe,gBAAgBH,GAAG,CAAC,0CAA0C,CAAC;QAC1F,OAAO;IACT;IAEA,MAAMK,UAAUC,mBAAQ,CAACC,IAAI,CAACL;IAC9B,IACE,4BAA4B;IAC5B,OAAOG,QAAQD,OAAO,KAAK,YAC3B,uBAAuB;IACvBI,iBAAM,CAACC,SAAS,CAACJ,QAAQD,OAAO,EAAED,gBAAgBC,OAAO,GACzD;QACA,OAAO;IACT;IACAhB,MACE,CAAC,mBAAmB,EAAEe,gBAAgBH,GAAG,CAAC,uCAAuC,EAAEG,gBAAgBC,OAAO,CAAC,aAAa,EAAEC,QAAQD,OAAO,CAAC,EAAE,CAAC;IAE/I,OAAO;AACT;AAUO,eAAenB,wBACpBK,WAAmB,EACnB,EACEoB,UAAU,EACVnB,gBAAgB,EAIjB;IAKD,MAAMoB,UAAU3B,uBAAuBM,aAAaC;IACpD,IAAI,CAACoB,QAAQV,OAAO,CAACW,MAAM,EAAE;QAC3B,OAAOD;IACT;IAEA,iFAAiF;IACjF,MAAMzB,qCAAqCI,aAAaoB,YAAYC,QAAQV,OAAO;IAEnF,OAAOU;AACT;AAEO,eAAezB,qCACpBI,WAAmB,EACnBoB,UAA8B,EAC9BG,QAA2B;IAE3B,iFAAiF;IACjF,MAAMC,kBAAkB,MAAMC,IAAAA,mDAA6B,EAAC;QAAEzB;QAAaoB;IAAW;IACtF,KAAK,MAAMV,OAAOa,SAAU;QAC1B,IACE,sFAAsF;QACtF,+FAA+F;QAC/F,CAACb,IAAII,OAAO,IACZJ,IAAIA,GAAG,IAAIc,iBACX;YACAd,IAAII,OAAO,GAAGU,eAAe,CAACd,IAAIA,GAAG,CAAC;QACxC;IACF;IACA,OAAOa;AACT"}

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

@@ -0,0 +1,165 @@
+"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, {
+    getCombinedKnownVersionsAsync: function() {
+        return getCombinedKnownVersionsAsync;
+    },
+    getOperationLog: function() {
+        return getOperationLog;
+    },
+    getRemoteVersionsForSdkAsync: function() {
+        return getRemoteVersionsForSdkAsync;
+    },
+    getVersionedPackagesAsync: function() {
+        return getVersionedPackagesAsync;
+    }
+});
+function _npmpackagearg() {
+    const data = /*#__PURE__*/ _interop_require_default(require("npm-package-arg"));
+    _npmpackagearg = function() {
+        return data;
+    };
+    return data;
+}
+const _bundledNativeModules = require("./bundledNativeModules");
+const _resolvePackages = require("./resolvePackages");
+const _getVersions = require("../../../api/getVersions");
+const _log = require("../../../log");
+const _env = require("../../../utils/env");
+const _errors = require("../../../utils/errors");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:doctor:dependencies:getVersionedPackages');
+/** Adds `react-dom`, `react`, and `react-native` to the list of known package versions (`relatedPackages`) */ function normalizeSdkVersionObject(version) {
+    if (!version) {
+        return {};
+    }
+    const { relatedPackages, facebookReactVersion, facebookReactNativeVersion, expoVersion } = version;
+    const reactVersion = facebookReactVersion ? {
+        react: facebookReactVersion,
+        'react-dom': facebookReactVersion
+    } : undefined;
+    const expoVersionIfAvailable = expoVersion ? {
+        expo: expoVersion
+    } : undefined;
+    return {
+        ...relatedPackages,
+        ...reactVersion,
+        ...expoVersionIfAvailable,
+        'react-native': facebookReactNativeVersion
+    };
+}
+async function getCombinedKnownVersionsAsync({ projectRoot, sdkVersion, skipCache }) {
+    const skipRemoteVersions = await (0, _resolvePackages.hasExpoCanaryAsync)(projectRoot);
+    if (skipRemoteVersions) {
+        _log.Log.warn('Dependency validation might be unreliable when using canary SDK versions');
+    }
+    const bundledNativeModules = sdkVersion ? await (0, _bundledNativeModules.getVersionedNativeModulesAsync)(projectRoot, sdkVersion, {
+        skipRemoteVersions
+    }) : {};
+    const versionsForSdk = !skipRemoteVersions ? await getRemoteVersionsForSdkAsync({
+        sdkVersion,
+        skipCache
+    }) : {};
+    return {
+        ...bundledNativeModules,
+        // Prefer the remote versions over the bundled versions, this enables us to push
+        // emergency fixes that users can access without having to update the `expo` package.
+        ...versionsForSdk
+    };
+}
+async function getRemoteVersionsForSdkAsync({ sdkVersion, skipCache } = {}) {
+    if (_env.env.EXPO_OFFLINE) {
+        _log.Log.warn('Dependency validation is unreliable in offline-mode');
+        return {};
+    }
+    try {
+        const { sdkVersions } = await (0, _getVersions.getVersionsAsync)({
+            skipCache
+        });
+        // We only want versioned dependencies so skip if they cannot be found.
+        if (!sdkVersion || !(sdkVersion in sdkVersions)) {
+            debug(`Skipping versioned dependencies because the SDK version is not found. (sdkVersion: ${sdkVersion}, available: ${Object.keys(sdkVersions).join(', ')})`);
+            return {};
+        }
+        const version = sdkVersions[sdkVersion];
+        return normalizeSdkVersionObject(version);
+    } catch (error) {
+        if (error instanceof _errors.CommandError && error.code === 'OFFLINE') {
+            return getRemoteVersionsForSdkAsync({
+                sdkVersion,
+                skipCache
+            });
+        }
+        throw error;
+    }
+}
+async function getVersionedPackagesAsync(projectRoot, { packages, sdkVersion, pkg }) {
+    const versionsForSdk = await getCombinedKnownVersionsAsync({
+        projectRoot,
+        sdkVersion,
+        skipCache: true
+    });
+    let nativeModulesCount = 0;
+    let othersCount = 0;
+    const excludedNativeModules = [];
+    const versionedPackages = packages.map((arg)=>{
+        const { name, type, raw, rawSpec } = (0, _npmpackagearg().default)(arg);
+        if ([
+            'tag',
+            'version',
+            'range'
+        ].includes(type) && name && versionsForSdk[name]) {
+            var _pkg_expo_install_exclude, _pkg_expo_install, _pkg_expo;
+            // Unimodule packages from npm registry are modified to use the bundled version.
+            // Some packages have the recommended version listed in https://exp.host/--/api/v2/versions.
+            const isExcludedFromValidation = pkg == null ? void 0 : (_pkg_expo = pkg.expo) == null ? void 0 : (_pkg_expo_install = _pkg_expo.install) == null ? void 0 : (_pkg_expo_install_exclude = _pkg_expo_install.exclude) == null ? void 0 : _pkg_expo_install_exclude.includes(name);
+            const hasSpecifiedExactVersion = rawSpec !== '' && rawSpec !== '*';
+            if (isExcludedFromValidation || hasSpecifiedExactVersion) {
+                othersCount++;
+                excludedNativeModules.push({
+                    name,
+                    bundledNativeVersion: versionsForSdk[name],
+                    isExcludedFromValidation,
+                    specifiedVersion: hasSpecifiedExactVersion ? rawSpec : ''
+                });
+                return raw;
+            }
+            nativeModulesCount++;
+            return `${name}@${versionsForSdk[name]}`;
+        } else {
+            // Other packages are passed through unmodified.
+            othersCount++;
+            return raw;
+        }
+    });
+    const messages = getOperationLog({
+        othersCount,
+        nativeModulesCount,
+        sdkVersion
+    });
+    return {
+        packages: versionedPackages,
+        messages,
+        excludedNativeModules
+    };
+}
+function getOperationLog({ nativeModulesCount, sdkVersion, othersCount }) {
+    return [
+        nativeModulesCount > 0 && `${nativeModulesCount} SDK ${sdkVersion} compatible native ${nativeModulesCount === 1 ? 'module' : 'modules'}`,
+        othersCount > 0 && `${othersCount} other ${othersCount === 1 ? 'package' : 'packages'}`
+    ].filter(Boolean);
+}
+
+//# sourceMappingURL=getVersionedPackages.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/doctor/dependencies/getVersionedPackages.ts"],"sourcesContent":["import { PackageJSONConfig } from '@expo/config';\nimport npmPackageArg from 'npm-package-arg';\n\nimport { getVersionedNativeModulesAsync } from './bundledNativeModules';\nimport { hasExpoCanaryAsync } from './resolvePackages';\nimport { getVersionsAsync, SDKVersion } from '../../../api/getVersions';\nimport { Log } from '../../../log';\nimport { env } from '../../../utils/env';\nimport { CommandError } from '../../../utils/errors';\n\nconst debug = require('debug')(\n  'expo:doctor:dependencies:getVersionedPackages'\n) as typeof console.log;\n\nexport type DependencyList = Record<string, string>;\n\n/** Adds `react-dom`, `react`, and `react-native` to the list of known package versions (`relatedPackages`) */\nfunction normalizeSdkVersionObject(version?: SDKVersion): Record<string, string> {\n  if (!version) {\n    return {};\n  }\n  const { relatedPackages, facebookReactVersion, facebookReactNativeVersion, expoVersion } =\n    version;\n\n  const reactVersion = facebookReactVersion\n    ? {\n        react: facebookReactVersion,\n        'react-dom': facebookReactVersion,\n      }\n    : undefined;\n\n  const expoVersionIfAvailable = expoVersion ? { expo: expoVersion } : undefined;\n\n  return {\n    ...relatedPackages,\n    ...reactVersion,\n    ...expoVersionIfAvailable,\n    'react-native': facebookReactNativeVersion,\n  };\n}\n\n/** Get the known versions for a given SDK, combines all sources. */\nexport async function getCombinedKnownVersionsAsync({\n  projectRoot,\n  sdkVersion,\n  skipCache,\n}: {\n  projectRoot: string;\n  sdkVersion?: string;\n  skipCache?: boolean;\n}) {\n  const skipRemoteVersions = await hasExpoCanaryAsync(projectRoot);\n  if (skipRemoteVersions) {\n    Log.warn('Dependency validation might be unreliable when using canary SDK versions');\n  }\n\n  const bundledNativeModules = sdkVersion\n    ? await getVersionedNativeModulesAsync(projectRoot, sdkVersion, { skipRemoteVersions })\n    : {};\n  const versionsForSdk = !skipRemoteVersions\n    ? await getRemoteVersionsForSdkAsync({ sdkVersion, skipCache })\n    : {};\n  return {\n    ...bundledNativeModules,\n    // Prefer the remote versions over the bundled versions, this enables us to push\n    // emergency fixes that users can access without having to update the `expo` package.\n    ...versionsForSdk,\n  };\n}\n\n/** @returns a key/value list of known dependencies and their version (including range). */\nexport async function getRemoteVersionsForSdkAsync({\n  sdkVersion,\n  skipCache,\n}: { sdkVersion?: string; skipCache?: boolean } = {}): Promise<DependencyList> {\n  if (env.EXPO_OFFLINE) {\n    Log.warn('Dependency validation is unreliable in offline-mode');\n    return {};\n  }\n\n  try {\n    const { sdkVersions } = await getVersionsAsync({ skipCache });\n\n    // We only want versioned dependencies so skip if they cannot be found.\n    if (!sdkVersion || !(sdkVersion in sdkVersions)) {\n      debug(\n        `Skipping versioned dependencies because the SDK version is not found. (sdkVersion: ${sdkVersion}, available: ${Object.keys(\n          sdkVersions\n        ).join(', ')})`\n      );\n      return {};\n    }\n\n    const version = sdkVersions[sdkVersion as keyof typeof sdkVersions] as unknown as SDKVersion;\n\n    return normalizeSdkVersionObject(version);\n  } catch (error: any) {\n    if (error instanceof CommandError && error.code === 'OFFLINE') {\n      return getRemoteVersionsForSdkAsync({ sdkVersion, skipCache });\n    }\n    throw error;\n  }\n}\n\ntype ExcludedNativeModules = {\n  name: string;\n  bundledNativeVersion: string;\n  isExcludedFromValidation: boolean;\n  specifiedVersion?: string; // e.g. 1.2.3, latest\n};\n\n/**\n * Versions a list of `packages` against a given `sdkVersion` based on local and remote versioning resources.\n *\n * @param projectRoot\n * @param param1\n * @returns\n */\nexport async function getVersionedPackagesAsync(\n  projectRoot: string,\n  {\n    packages,\n    sdkVersion,\n    pkg,\n  }: {\n    /** List of npm packages to process. */\n    packages: string[];\n    /** Target SDK Version number to version the `packages` for. */\n    sdkVersion: string;\n    pkg: PackageJSONConfig;\n  }\n): Promise<{\n  packages: string[];\n  messages: string[];\n  excludedNativeModules: ExcludedNativeModules[];\n}> {\n  const versionsForSdk = await getCombinedKnownVersionsAsync({\n    projectRoot,\n    sdkVersion,\n    skipCache: true,\n  });\n\n  let nativeModulesCount = 0;\n  let othersCount = 0;\n  const excludedNativeModules: ExcludedNativeModules[] = [];\n\n  const versionedPackages = packages.map((arg) => {\n    const { name, type, raw, rawSpec } = npmPackageArg(arg);\n\n    if (['tag', 'version', 'range'].includes(type) && name && versionsForSdk[name]) {\n      // Unimodule packages from npm registry are modified to use the bundled version.\n      // Some packages have the recommended version listed in https://exp.host/--/api/v2/versions.\n      const isExcludedFromValidation = pkg?.expo?.install?.exclude?.includes(name);\n      const hasSpecifiedExactVersion = rawSpec !== '' && rawSpec !== '*';\n      if (isExcludedFromValidation || hasSpecifiedExactVersion) {\n        othersCount++;\n        excludedNativeModules.push({\n          name,\n          bundledNativeVersion: versionsForSdk[name],\n          isExcludedFromValidation,\n          specifiedVersion: hasSpecifiedExactVersion ? rawSpec : '',\n        });\n        return raw;\n      }\n      nativeModulesCount++;\n      return `${name}@${versionsForSdk[name]}`;\n    } else {\n      // Other packages are passed through unmodified.\n      othersCount++;\n      return raw;\n    }\n  });\n\n  const messages = getOperationLog({\n    othersCount,\n    nativeModulesCount,\n    sdkVersion,\n  });\n\n  return {\n    packages: versionedPackages,\n    messages,\n    excludedNativeModules,\n  };\n}\n\n/** Craft a set of messages regarding the install operations. */\nexport function getOperationLog({\n  nativeModulesCount,\n  sdkVersion,\n  othersCount,\n}: {\n  nativeModulesCount: number;\n  othersCount: number;\n  sdkVersion: string;\n}): string[] {\n  return [\n    nativeModulesCount > 0 &&\n      `${nativeModulesCount} SDK ${sdkVersion} compatible native ${\n        nativeModulesCount === 1 ? 'module' : 'modules'\n      }`,\n    othersCount > 0 && `${othersCount} other ${othersCount === 1 ? 'package' : 'packages'}`,\n  ].filter(Boolean) as string[];\n}\n"],"names":["getCombinedKnownVersionsAsync","getOperationLog","getRemoteVersionsForSdkAsync","getVersionedPackagesAsync","debug","require","normalizeSdkVersionObject","version","relatedPackages","facebookReactVersion","facebookReactNativeVersion","expoVersion","reactVersion","react","undefined","expoVersionIfAvailable","expo","projectRoot","sdkVersion","skipCache","skipRemoteVersions","hasExpoCanaryAsync","Log","warn","bundledNativeModules","getVersionedNativeModulesAsync","versionsForSdk","env","EXPO_OFFLINE","sdkVersions","getVersionsAsync","Object","keys","join","error","CommandError","code","packages","pkg","nativeModulesCount","othersCount","excludedNativeModules","versionedPackages","map","arg","name","type","raw","rawSpec","npmPackageArg","includes","isExcludedFromValidation","install","exclude","hasSpecifiedExactVersion","push","bundledNativeVersion","specifiedVersion","messages","filter","Boolean"],"mappings":"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"}

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

@@ -0,0 +1,95 @@
+"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, {
+    hasExpoCanaryAsync: function() {
+        return hasExpoCanaryAsync;
+    },
+    resolveAllPackageVersionsAsync: function() {
+        return resolveAllPackageVersionsAsync;
+    },
+    resolvePackageVersionAsync: function() {
+        return resolvePackageVersionAsync;
+    }
+});
+function _jsonfile() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/json-file"));
+    _jsonfile = 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 _errors = require("../../../utils/errors");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function resolvePackageVersionAsync(projectRoot, packageName) {
+    let packageJsonPath;
+    try {
+        packageJsonPath = (0, _resolvefrom().default)(projectRoot, `${packageName}/package.json`);
+    } catch (error) {
+        // This is a workaround for packages using `exports`. If this doesn't
+        // include `package.json`, we have to use the error message to get the location.
+        if (error.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+            var _error_message_match;
+            packageJsonPath = (_error_message_match = error.message.match(/("exports"|defined) in (.*)$/i)) == null ? void 0 : _error_message_match[2];
+        }
+    }
+    if (!packageJsonPath) {
+        throw new _errors.CommandError('PACKAGE_NOT_FOUND', `"${packageName}" is added as a dependency in your project's package.json but it doesn't seem to be installed. Run "npm install", or the equivalent for your package manager, and try again.`);
+    }
+    const packageJson = await _jsonfile().default.readAsync(packageJsonPath);
+    return packageJson.version;
+}
+async function resolveAllPackageVersionsAsync(projectRoot, packages) {
+    const resolvedPackages = await Promise.all(packages.map(async (packageName)=>[
+            packageName,
+            await resolvePackageVersionAsync(projectRoot, packageName)
+        ]));
+    return Object.fromEntries(resolvedPackages);
+}
+async function hasExpoCanaryAsync(projectRoot) {
+    let expoVersion = '';
+    try {
+        // Resolve installed `expo` version first
+        expoVersion = await resolvePackageVersionAsync(projectRoot, 'expo');
+    } catch (error) {
+        var _packageJson_dependencies;
+        if (error.code !== 'PACKAGE_NOT_FOUND') {
+            throw error;
+        }
+        // Resolve through project `package.json`
+        const packageJson = await _jsonfile().default.readAsync((0, _resolvefrom().default)(projectRoot, './package.json'));
+        expoVersion = ((_packageJson_dependencies = packageJson.dependencies) == null ? void 0 : _packageJson_dependencies.expo) ?? '';
+    }
+    if (expoVersion === 'canary') {
+        return true;
+    }
+    const prerelease = _semver().default.prerelease(expoVersion) || [];
+    return !!prerelease.some((segment)=>typeof segment === 'string' && segment.includes('canary'));
+}
+
+//# sourceMappingURL=resolvePackages.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/doctor/dependencies/resolvePackages.ts"],"sourcesContent":["import JsonFile from '@expo/json-file';\nimport resolveFrom from 'resolve-from';\nimport semver from 'semver';\n\nimport { CommandError } from '../../../utils/errors';\n\nexport async function resolvePackageVersionAsync(\n  projectRoot: string,\n  packageName: string\n): Promise<string> {\n  let packageJsonPath: string | undefined;\n  try {\n    packageJsonPath = resolveFrom(projectRoot, `${packageName}/package.json`);\n  } catch (error: any) {\n    // This is a workaround for packages using `exports`. If this doesn't\n    // include `package.json`, we have to use the error message to get the location.\n    if (error.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {\n      packageJsonPath = error.message.match(/(\"exports\"|defined) in (.*)$/i)?.[2];\n    }\n  }\n  if (!packageJsonPath) {\n    throw new CommandError(\n      'PACKAGE_NOT_FOUND',\n      `\"${packageName}\" is added as a dependency in your project's package.json but it doesn't seem to be installed. Run \"npm install\", or the equivalent for your package manager, and try again.`\n    );\n  }\n  const packageJson = await JsonFile.readAsync<{ version: string }>(packageJsonPath);\n  return packageJson.version;\n}\n\nexport async function resolveAllPackageVersionsAsync(projectRoot: string, packages: string[]) {\n  const resolvedPackages = await Promise.all(\n    packages.map(async (packageName) => [\n      packageName,\n      await resolvePackageVersionAsync(projectRoot, packageName),\n    ])\n  );\n\n  return Object.fromEntries(resolvedPackages);\n}\n\n/**\n * Determine if the project has a `expo@canary` version installed.\n * This means that an unsable version is used, without the API knowing the exact packages.\n * Since this may be called during, or before, packages are installed, we also need to test on `package.json`.\n * Note, this returns `false` for beta releases.\n */\nexport async function hasExpoCanaryAsync(projectRoot: string) {\n  let expoVersion = '';\n\n  try {\n    // Resolve installed `expo` version first\n    expoVersion = await resolvePackageVersionAsync(projectRoot, 'expo');\n  } catch (error: any) {\n    if (error.code !== 'PACKAGE_NOT_FOUND') {\n      throw error;\n    }\n\n    // Resolve through project `package.json`\n    const packageJson = await JsonFile.readAsync<{ dependencies?: Record<string, string> }>(\n      resolveFrom(projectRoot, './package.json')\n    );\n    expoVersion = packageJson.dependencies?.expo ?? '';\n  }\n\n  if (expoVersion === 'canary') {\n    return true;\n  }\n\n  const prerelease = semver.prerelease(expoVersion) || [];\n  return !!prerelease.some((segment) => typeof segment === 'string' && segment.includes('canary'));\n}\n"],"names":["hasExpoCanaryAsync","resolveAllPackageVersionsAsync","resolvePackageVersionAsync","projectRoot","packageName","packageJsonPath","resolveFrom","error","code","message","match","CommandError","packageJson","JsonFile","readAsync","version","packages","resolvedPackages","Promise","all","map","Object","fromEntries","expoVersion","dependencies","expo","prerelease","semver","some","segment","includes"],"mappings":";;;;;;;;;;;IA+CsBA,kBAAkB;eAAlBA;;IAjBAC,8BAA8B;eAA9BA;;IAxBAC,0BAA0B;eAA1BA;;;;gEAND;;;;;;;gEACG;;;;;;;gEACL;;;;;;wBAEU;;;;;;AAEtB,eAAeA,2BACpBC,WAAmB,EACnBC,WAAmB;IAEnB,IAAIC;IACJ,IAAI;QACFA,kBAAkBC,IAAAA,sBAAW,EAACH,aAAa,GAAGC,YAAY,aAAa,CAAC;IAC1E,EAAE,OAAOG,OAAY;QACnB,qEAAqE;QACrE,gFAAgF;QAChF,IAAIA,MAAMC,IAAI,KAAK,iCAAiC;gBAChCD;YAAlBF,mBAAkBE,uBAAAA,MAAME,OAAO,CAACC,KAAK,CAAC,qDAApBH,oBAAsD,CAAC,EAAE;QAC7E;IACF;IACA,IAAI,CAACF,iBAAiB;QACpB,MAAM,IAAIM,oBAAY,CACpB,qBACA,CAAC,CAAC,EAAEP,YAAY,4KAA4K,CAAC;IAEjM;IACA,MAAMQ,cAAc,MAAMC,mBAAQ,CAACC,SAAS,CAAsBT;IAClE,OAAOO,YAAYG,OAAO;AAC5B;AAEO,eAAed,+BAA+BE,WAAmB,EAAEa,QAAkB;IAC1F,MAAMC,mBAAmB,MAAMC,QAAQC,GAAG,CACxCH,SAASI,GAAG,CAAC,OAAOhB,cAAgB;YAClCA;YACA,MAAMF,2BAA2BC,aAAaC;SAC/C;IAGH,OAAOiB,OAAOC,WAAW,CAACL;AAC5B;AAQO,eAAejB,mBAAmBG,WAAmB;IAC1D,IAAIoB,cAAc;IAElB,IAAI;QACF,yCAAyC;QACzCA,cAAc,MAAMrB,2BAA2BC,aAAa;IAC9D,EAAE,OAAOI,OAAY;YASLK;QARd,IAAIL,MAAMC,IAAI,KAAK,qBAAqB;YACtC,MAAMD;QACR;QAEA,yCAAyC;QACzC,MAAMK,cAAc,MAAMC,mBAAQ,CAACC,SAAS,CAC1CR,IAAAA,sBAAW,EAACH,aAAa;QAE3BoB,cAAcX,EAAAA,4BAAAA,YAAYY,YAAY,qBAAxBZ,0BAA0Ba,IAAI,KAAI;IAClD;IAEA,IAAIF,gBAAgB,UAAU;QAC5B,OAAO;IACT;IAEA,MAAMG,aAAaC,iBAAM,CAACD,UAAU,CAACH,gBAAgB,EAAE;IACvD,OAAO,CAAC,CAACG,WAAWE,IAAI,CAAC,CAACC,UAAY,OAAOA,YAAY,YAAYA,QAAQC,QAAQ,CAAC;AACxF"}