chore: add mobile app

frontend-admin/node_modules/@expo/config/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present 650 Industries, Inc. (aka Expo)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

frontend-admin/node_modules/@expo/config/README.md

@@ -0,0 +1,16 @@
+<!-- Title -->
+<h1 align="center">
+👋 Welcome to <br><code>@expo/config</code>
+</h1>
+
+<p align="center">A library for interacting with the <code>app.json</code>.</p>
+
+<p align="center">
+  <img src="https://flat.badgen.net/packagephobia/install/@expo/config">
+
+  <a href="https://www.npmjs.com/package/@expo/config">
+    <img src="https://flat.badgen.net/npm/dw/@expo/config" target="_blank" />
+  </a>
+</p>
+
+<!-- Body -->

frontend-admin/node_modules/@expo/config/build/Config.d.ts

@@ -0,0 +1,76 @@
+import { ConfigFilePaths, ExpoConfig, GetConfigOptions, PackageJSONConfig, ProjectConfig, ProjectTarget, WriteConfigOptions } from './Config.types';
+/**
+ * Evaluate the config for an Expo project.
+ * If a function is exported from the `app.config.js` then a partial config will be passed as an argument.
+ * The partial config is composed from any existing app.json, and certain fields from the `package.json` like name and description.
+ *
+ * If options.isPublicConfig is true, the Expo config will include only public-facing options (omitting private keys).
+ * The resulting config should be suitable for hosting or embedding in a publicly readable location.
+ *
+ * **Example**
+ * ```js
+ * module.exports = function({ config }) {
+ *   // mutate the config before returning it.
+ *   config.slug = 'new slug'
+ *   return { expo: config };
+ * }
+ * ```
+ *
+ * **Supports**
+ * - `app.config.ts`
+ * - `app.config.js`
+ * - `app.config.json`
+ * - `app.json`
+ *
+ * @param projectRoot the root folder containing all of your application code
+ * @param options enforce criteria for a project config
+ */
+export declare function getConfig(projectRoot: string, options?: GetConfigOptions): ProjectConfig;
+export declare function getPackageJson(projectRoot: string): PackageJSONConfig;
+/**
+ * Get the static and dynamic config paths for a project. Also accounts for custom paths.
+ *
+ * @param projectRoot
+ */
+export declare function getConfigFilePaths(projectRoot: string): ConfigFilePaths;
+/**
+ * Attempt to modify an Expo project config.
+ * This will only fully work if the project is using static configs only.
+ * Otherwise 'warn' | 'fail' will return with a message about why the config couldn't be updated.
+ * The potentially modified config object will be returned for testing purposes.
+ *
+ * @param projectRoot
+ * @param modifications modifications to make to an existing config
+ * @param readOptions options for reading the current config file
+ * @param writeOptions If true, the static config file will not be rewritten
+ */
+export declare function modifyConfigAsync(projectRoot: string, modifications: Partial<ExpoConfig>, readOptions?: GetConfigOptions, writeOptions?: WriteConfigOptions): Promise<{
+    type: 'success' | 'warn' | 'fail';
+    message?: string;
+    config: ExpoConfig | null;
+}>;
+export declare function getWebOutputPath(config?: {
+    [key: string]: any;
+}): string;
+export declare function getNameFromConfig(exp?: Record<string, any>): {
+    appName?: string;
+    webName?: string;
+};
+export declare function getDefaultTarget(projectRoot: string, exp?: Pick<ExpoConfig, 'sdkVersion'>): ProjectTarget;
+/**
+ * Return a useful name describing the project config.
+ * - dynamic: app.config.js
+ * - static: app.json
+ * - custom path app config relative to root folder
+ * - both: app.config.js or app.json
+ */
+export declare function getProjectConfigDescription(projectRoot: string): string;
+/**
+ * Returns a string describing the configurations used for the given project root.
+ * Will return null if no config is found.
+ *
+ * @param projectRoot
+ * @param projectConfig
+ */
+export declare function getProjectConfigDescriptionWithPaths(projectRoot: string, projectConfig: ConfigFilePaths): string;
+export * from './Config.types';

frontend-admin/node_modules/@expo/config/build/Config.js

@@ -0,0 +1,633 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  getConfig: true,
+  getPackageJson: true,
+  getConfigFilePaths: true,
+  modifyConfigAsync: true,
+  getWebOutputPath: true,
+  getNameFromConfig: true,
+  getDefaultTarget: true,
+  getProjectConfigDescription: true,
+  getProjectConfigDescriptionWithPaths: true
+};
+exports.getConfig = getConfig;
+exports.getConfigFilePaths = getConfigFilePaths;
+exports.getDefaultTarget = getDefaultTarget;
+exports.getNameFromConfig = getNameFromConfig;
+exports.getPackageJson = getPackageJson;
+exports.getProjectConfigDescription = getProjectConfigDescription;
+exports.getProjectConfigDescriptionWithPaths = getProjectConfigDescriptionWithPaths;
+exports.getWebOutputPath = getWebOutputPath;
+exports.modifyConfigAsync = modifyConfigAsync;
+function _jsonFile() {
+  const data = _interopRequireDefault(require("@expo/json-file"));
+  _jsonFile = function () {
+    return data;
+  };
+  return data;
+}
+function _deepmerge() {
+  const data = _interopRequireDefault(require("deepmerge"));
+  _deepmerge = function () {
+    return data;
+  };
+  return data;
+}
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _glob() {
+  const data = require("glob");
+  _glob = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _resolveFrom() {
+  const data = _interopRequireDefault(require("resolve-from"));
+  _resolveFrom = function () {
+    return data;
+  };
+  return data;
+}
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+function _slugify() {
+  const data = _interopRequireDefault(require("slugify"));
+  _slugify = function () {
+    return data;
+  };
+  return data;
+}
+function _getConfig() {
+  const data = require("./getConfig");
+  _getConfig = function () {
+    return data;
+  };
+  return data;
+}
+function _getExpoSDKVersion() {
+  const data = require("./getExpoSDKVersion");
+  _getExpoSDKVersion = function () {
+    return data;
+  };
+  return data;
+}
+function _withConfigPlugins() {
+  const data = require("./plugins/withConfigPlugins");
+  _withConfigPlugins = function () {
+    return data;
+  };
+  return data;
+}
+function _withInternal() {
+  const data = require("./plugins/withInternal");
+  _withInternal = function () {
+    return data;
+  };
+  return data;
+}
+function _resolvePackageJson() {
+  const data = require("./resolvePackageJson");
+  _resolvePackageJson = function () {
+    return data;
+  };
+  return data;
+}
+var _Config = require("./Config.types");
+Object.keys(_Config).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Config[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Config[key];
+    }
+  });
+});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let hasWarnedAboutRootConfig = false;
+
+/**
+ * If a config has an `expo` object then that will be used as the config.
+ * This method reduces out other top level values if an `expo` object exists.
+ *
+ * @param config Input config object to reduce
+ */
+function reduceExpoObject(config) {
+  if (!config) return config || null;
+  if (config.expo && !hasWarnedAboutRootConfig) {
+    const keys = Object.keys(config).filter(key => key !== 'expo');
+    if (keys.length) {
+      hasWarnedAboutRootConfig = true;
+      const ansiYellow = str => `\u001B[33m${str}\u001B[0m`;
+      const ansiGray = str => `\u001B[90m${str}\u001B[0m`;
+      const ansiBold = str => `\u001B[1m${str}\u001B[22m`;
+      const plural = keys.length > 1;
+      console.warn(ansiYellow(ansiBold('Warning: ') + `Root-level ${ansiBold(`"expo"`)} object found. Ignoring extra key${plural ? 's' : ''} in Expo config: ${keys.map(key => `"${key}"`).join(', ')}\n` + ansiGray(`Learn more: https://expo.fyi/root-expo-object`)));
+    }
+  }
+  const {
+    mods,
+    ...expo
+  } = config.expo ?? config;
+  return {
+    expo,
+    mods
+  };
+}
+
+/**
+ * Get all platforms that a project is currently capable of running.
+ *
+ * @param projectRoot
+ * @param exp
+ */
+function getSupportedPlatforms(projectRoot) {
+  const platforms = [];
+  if (_resolveFrom().default.silent(projectRoot, 'react-native')) {
+    platforms.push('ios', 'android');
+  }
+  if (_resolveFrom().default.silent(projectRoot, 'react-dom')) {
+    platforms.push('web');
+  }
+  return platforms;
+}
+
+/**
+ * Evaluate the config for an Expo project.
+ * If a function is exported from the `app.config.js` then a partial config will be passed as an argument.
+ * The partial config is composed from any existing app.json, and certain fields from the `package.json` like name and description.
+ *
+ * If options.isPublicConfig is true, the Expo config will include only public-facing options (omitting private keys).
+ * The resulting config should be suitable for hosting or embedding in a publicly readable location.
+ *
+ * **Example**
+ * ```js
+ * module.exports = function({ config }) {
+ *   // mutate the config before returning it.
+ *   config.slug = 'new slug'
+ *   return { expo: config };
+ * }
+ * ```
+ *
+ * **Supports**
+ * - `app.config.ts`
+ * - `app.config.js`
+ * - `app.config.json`
+ * - `app.json`
+ *
+ * @param projectRoot the root folder containing all of your application code
+ * @param options enforce criteria for a project config
+ */
+function getConfig(projectRoot, options = {}) {
+  const paths = getConfigFilePaths(projectRoot);
+  const rawStaticConfig = paths.staticConfigPath ? (0, _getConfig().getStaticConfig)(paths.staticConfigPath) : null;
+  // For legacy reasons, always return an object.
+  const rootConfig = rawStaticConfig || {};
+  const staticConfig = reduceExpoObject(rawStaticConfig) || {};
+
+  // Can only change the package.json location if an app.json or app.config.json exists
+  const [packageJson, packageJsonPath] = getPackageJsonAndPath(projectRoot);
+  function fillAndReturnConfig(config, dynamicConfigObjectType, mayHaveUnusedStaticConfig = false) {
+    const configWithDefaultValues = {
+      ...ensureConfigHasDefaultValues({
+        projectRoot,
+        exp: config.expo || {},
+        pkg: packageJson,
+        skipSDKVersionRequirement: options.skipSDKVersionRequirement,
+        paths,
+        packageJsonPath
+      }),
+      mods: config.mods,
+      dynamicConfigObjectType,
+      rootConfig,
+      dynamicConfigPath: paths.dynamicConfigPath,
+      staticConfigPath: paths.staticConfigPath,
+      hasUnusedStaticConfig: !!paths.staticConfigPath && !!paths.dynamicConfigPath && mayHaveUnusedStaticConfig
+    };
+    if (options.isModdedConfig) {
+      // @ts-ignore: Add the mods back to the object.
+      configWithDefaultValues.exp.mods = config.mods ?? null;
+    }
+
+    // Apply static json plugins, should be done after _internal
+    configWithDefaultValues.exp = (0, _withConfigPlugins().withConfigPlugins)(configWithDefaultValues.exp, !!options.skipPlugins);
+    if (!options.isModdedConfig) {
+      // @ts-ignore: Delete mods added by static plugins when they won't have a chance to be evaluated
+      delete configWithDefaultValues.exp.mods;
+    }
+    if (options.isPublicConfig) {
+      // TODD(EvanBacon): Drop plugins array after it's been resolved.
+
+      // Remove internal values with references to user's file paths from the public config.
+      delete configWithDefaultValues.exp._internal;
+
+      // hooks no longer exists in the typescript type but should still be removed
+      if ('hooks' in configWithDefaultValues.exp) {
+        delete configWithDefaultValues.exp.hooks;
+      }
+      if (configWithDefaultValues.exp.ios?.config) {
+        delete configWithDefaultValues.exp.ios.config;
+      }
+      if (configWithDefaultValues.exp.android?.config) {
+        delete configWithDefaultValues.exp.android.config;
+      }
+      delete configWithDefaultValues.exp.updates?.codeSigningCertificate;
+      delete configWithDefaultValues.exp.updates?.codeSigningMetadata;
+    }
+    return configWithDefaultValues;
+  }
+
+  // Fill in the static config
+  function getContextConfig(config) {
+    return ensureConfigHasDefaultValues({
+      projectRoot,
+      exp: config.expo || {},
+      pkg: packageJson,
+      skipSDKVersionRequirement: true,
+      paths,
+      packageJsonPath
+    }).exp;
+  }
+  if (paths.dynamicConfigPath) {
+    // No app.config.json or app.json but app.config.js
+    const {
+      exportedObjectType,
+      config: rawDynamicConfig,
+      mayHaveUnusedStaticConfig
+    } = (0, _getConfig().getDynamicConfig)(paths.dynamicConfigPath, {
+      projectRoot,
+      staticConfigPath: paths.staticConfigPath,
+      packageJsonPath,
+      config: getContextConfig(staticConfig)
+    });
+    // Allow for the app.config.js to `export default null;`
+    // Use `dynamicConfigPath` to detect if a dynamic config exists.
+    const dynamicConfig = reduceExpoObject(rawDynamicConfig) || {};
+    return fillAndReturnConfig(dynamicConfig, exportedObjectType, mayHaveUnusedStaticConfig);
+  }
+
+  // No app.config.js but json or no config
+  return fillAndReturnConfig(staticConfig || {}, null);
+}
+function getPackageJson(projectRoot) {
+  const [pkg] = getPackageJsonAndPath(projectRoot);
+  return pkg;
+}
+function getPackageJsonAndPath(projectRoot) {
+  const packageJsonPath = (0, _resolvePackageJson().getRootPackageJsonPath)(projectRoot);
+  return [_jsonFile().default.read(packageJsonPath), packageJsonPath];
+}
+
+/**
+ * Get the static and dynamic config paths for a project. Also accounts for custom paths.
+ *
+ * @param projectRoot
+ */
+function getConfigFilePaths(projectRoot) {
+  return {
+    dynamicConfigPath: getDynamicConfigFilePath(projectRoot),
+    staticConfigPath: getStaticConfigFilePath(projectRoot)
+  };
+}
+function getDynamicConfigFilePath(projectRoot) {
+  for (const fileName of ['app.config.ts', 'app.config.js']) {
+    const configPath = _path().default.join(projectRoot, fileName);
+    if (_fs().default.existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+function getStaticConfigFilePath(projectRoot) {
+  for (const fileName of ['app.config.json', 'app.json']) {
+    const configPath = _path().default.join(projectRoot, fileName);
+    if (_fs().default.existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+
+/**
+ * Attempt to modify an Expo project config.
+ * This will only fully work if the project is using static configs only.
+ * Otherwise 'warn' | 'fail' will return with a message about why the config couldn't be updated.
+ * The potentially modified config object will be returned for testing purposes.
+ *
+ * @param projectRoot
+ * @param modifications modifications to make to an existing config
+ * @param readOptions options for reading the current config file
+ * @param writeOptions If true, the static config file will not be rewritten
+ */
+async function modifyConfigAsync(projectRoot, modifications, readOptions = {}, writeOptions = {}) {
+  const config = getConfig(projectRoot, readOptions);
+  const isDryRun = writeOptions.dryRun;
+
+  // Create or modify the static config, when not using dynamic config
+  if (!config.dynamicConfigPath) {
+    const outputConfig = mergeConfigModifications(config, modifications);
+    if (!isDryRun) {
+      const configPath = config.staticConfigPath ?? _path().default.join(projectRoot, 'app.json');
+      await _jsonFile().default.writeAsync(configPath, outputConfig, {
+        json5: false
+      });
+    }
+    return {
+      type: 'success',
+      config: outputConfig.expo ?? outputConfig
+    };
+  }
+
+  // Attempt to write to a function-like dynamic config, when used with a static config
+  if (config.staticConfigPath && config.dynamicConfigObjectType === 'function' && !modifications.hasOwnProperty('plugins') // We don't know what plugins are in dynamic configs
+  ) {
+    const outputConfig = mergeConfigModifications(config, modifications);
+    if (isDryRun) {
+      return {
+        type: 'warn',
+        message: `Cannot verify config modifications in dry-run mode for config at: ${_path().default.relative(projectRoot, config.dynamicConfigPath)}`,
+        config: null
+      };
+    }
+
+    // Attempt to write the static config with the config modifications
+    await _jsonFile().default.writeAsync(config.staticConfigPath, outputConfig, {
+      json5: false
+    });
+
+    // Verify that the dynamic config is using the static config
+    const newConfig = getConfig(projectRoot, readOptions);
+    const newConfighasModifications = isMatchingObject(modifications, newConfig.exp);
+    if (newConfighasModifications) {
+      return {
+        type: 'success',
+        config: newConfig.exp
+      };
+    }
+
+    // Rollback the changes when the reloaded config did not include the modifications
+    await _jsonFile().default.writeAsync(config.staticConfigPath, config.rootConfig, {
+      json5: false
+    });
+  }
+
+  // We cannot automatically write to a dynamic config
+  return {
+    type: 'warn',
+    message: `Cannot automatically write to dynamic config at: ${_path().default.relative(projectRoot, config.dynamicConfigPath)}`,
+    config: null
+  };
+}
+
+/**
+ * Merge the config modifications, using an optional possible top-level `expo` object.
+ * Note, changes in the plugins are merged differently to avoid duplicate entries.
+ */
+function mergeConfigModifications(config, {
+  plugins,
+  ...modifications
+}) {
+  const modifiedExpoConfig = !config.rootConfig.expo ? (0, _deepmerge().default)(config.rootConfig, modifications) : (0, _deepmerge().default)(config.rootConfig.expo, modifications);
+  if (plugins?.length) {
+    // When adding plugins, ensure the config has a plugin list
+    if (!modifiedExpoConfig.plugins) {
+      modifiedExpoConfig.plugins = [];
+    }
+
+    // Create a plugin lookup map
+    const existingPlugins = Object.fromEntries(modifiedExpoConfig.plugins.map(definition => typeof definition === 'string' ? [definition, undefined] : definition));
+    for (const plugin of plugins) {
+      // Unpack the plugin definition, using either the short (string) or normal (array) notation
+      const [pluginName, pluginProps] = Array.isArray(plugin) ? plugin : [plugin];
+      // Abort if the plugin definition is empty
+      if (!pluginName) continue;
+
+      // Add the plugin if it doesn't exist yet, including its properties
+      if (!(pluginName in existingPlugins)) {
+        modifiedExpoConfig.plugins.push(plugin);
+        continue;
+      }
+
+      // If the plugin has properties, and it exists, merge the properties
+      if (pluginProps) {
+        modifiedExpoConfig.plugins = modifiedExpoConfig.plugins.map(existingPlugin => {
+          const [existingPluginName] = Array.isArray(existingPlugin) ? existingPlugin : [existingPlugin];
+
+          // Do not modify other plugins
+          if (existingPluginName !== pluginName) {
+            return existingPlugin;
+          }
+
+          // Add the props to the existing plugin entry
+          if (typeof existingPlugin === 'string') {
+            return [existingPlugin, pluginProps];
+          }
+
+          // Merge the props to the existing plugin properties
+          if (Array.isArray(existingPlugin) && existingPlugin[0]) {
+            return [existingPlugin[0], (0, _deepmerge().default)(existingPlugin[1] ?? {}, pluginProps)];
+          }
+          return existingPlugin;
+        });
+        continue;
+      }
+
+      // If the same plugin exists with properties, and the modification does not contain properties, ignore
+    }
+  }
+  const finalizedConfig = !config.rootConfig.expo ? modifiedExpoConfig : {
+    ...config.rootConfig,
+    expo: modifiedExpoConfig
+  };
+  return finalizedConfig;
+}
+function isMatchingObject(expectedValues, actualValues) {
+  for (const key in expectedValues) {
+    if (!expectedValues.hasOwnProperty(key)) {
+      continue;
+    }
+    if (typeof expectedValues[key] === 'object' && actualValues[key] !== null) {
+      if (!isMatchingObject(expectedValues[key], actualValues[key])) {
+        return false;
+      }
+    } else {
+      if (expectedValues[key] !== actualValues[key]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function ensureConfigHasDefaultValues({
+  projectRoot,
+  exp,
+  pkg,
+  paths,
+  packageJsonPath,
+  skipSDKVersionRequirement = false
+}) {
+  if (!exp) {
+    exp = {};
+  }
+  exp = (0, _withInternal().withInternal)(exp, {
+    projectRoot,
+    ...(paths ?? {}),
+    packageJsonPath
+  });
+  // Defaults for package.json fields
+  const pkgName = typeof pkg.name === 'string' ? pkg.name : _path().default.basename(projectRoot);
+  const pkgVersion = typeof pkg.version === 'string' ? pkg.version : '1.0.0';
+  const pkgWithDefaults = {
+    ...pkg,
+    name: pkgName,
+    version: pkgVersion
+  };
+
+  // Defaults for app.json/app.config.js fields
+  const name = exp.name ?? pkgName;
+  const slug = exp.slug ?? (0, _slugify().default)(name.toLowerCase());
+  const version = exp.version ?? pkgVersion;
+  let description = exp.description;
+  if (!description && typeof pkg.description === 'string') {
+    description = pkg.description;
+  }
+  const expWithDefaults = {
+    ...exp,
+    name,
+    slug,
+    version,
+    description
+  };
+  let sdkVersion;
+  try {
+    sdkVersion = (0, _getExpoSDKVersion().getExpoSDKVersion)(projectRoot, expWithDefaults);
+  } catch (error) {
+    if (!skipSDKVersionRequirement) throw error;
+  }
+  let platforms = exp.platforms;
+  if (!platforms) {
+    platforms = getSupportedPlatforms(projectRoot);
+  }
+  return {
+    exp: {
+      ...expWithDefaults,
+      sdkVersion,
+      platforms
+    },
+    pkg: pkgWithDefaults
+  };
+}
+const DEFAULT_BUILD_PATH = `web-build`;
+function getWebOutputPath(config = {}) {
+  if (process.env.WEBPACK_BUILD_OUTPUT_PATH) {
+    return process.env.WEBPACK_BUILD_OUTPUT_PATH;
+  }
+  const expo = config.expo || config || {};
+  return expo?.web?.build?.output || DEFAULT_BUILD_PATH;
+}
+function getNameFromConfig(exp = {}) {
+  // For RN CLI support
+  const appManifest = exp.expo || exp;
+  const {
+    web = {}
+  } = appManifest;
+
+  // rn-cli apps use a displayName value as well.
+  const appName = exp.displayName || appManifest.displayName || appManifest.name;
+  const webName = web.name || appName;
+  return {
+    appName,
+    webName
+  };
+}
+function getDefaultTarget(projectRoot, exp) {
+  exp ??= getConfig(projectRoot, {
+    skipSDKVersionRequirement: true
+  }).exp;
+
+  // before SDK 37, always default to managed to preserve previous behavior
+  if (exp.sdkVersion && exp.sdkVersion !== 'UNVERSIONED' && _semver().default.lt(exp.sdkVersion, '37.0.0')) {
+    return 'managed';
+  }
+  return isBareWorkflowProject(projectRoot) ? 'bare' : 'managed';
+}
+function isBareWorkflowProject(projectRoot) {
+  const [pkg] = getPackageJsonAndPath(projectRoot);
+
+  // TODO: Drop this
+  if (pkg.dependencies && pkg.dependencies.expokit) {
+    return false;
+  }
+  const xcodeprojFiles = (0, _glob().sync)('ios/**/*.xcodeproj', {
+    absolute: true,
+    cwd: projectRoot
+  });
+  if (xcodeprojFiles.length) {
+    return true;
+  }
+  const gradleFiles = (0, _glob().sync)('android/**/*.gradle', {
+    absolute: true,
+    cwd: projectRoot
+  });
+  if (gradleFiles.length) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Return a useful name describing the project config.
+ * - dynamic: app.config.js
+ * - static: app.json
+ * - custom path app config relative to root folder
+ * - both: app.config.js or app.json
+ */
+function getProjectConfigDescription(projectRoot) {
+  const paths = getConfigFilePaths(projectRoot);
+  return getProjectConfigDescriptionWithPaths(projectRoot, paths);
+}
+
+/**
+ * Returns a string describing the configurations used for the given project root.
+ * Will return null if no config is found.
+ *
+ * @param projectRoot
+ * @param projectConfig
+ */
+function getProjectConfigDescriptionWithPaths(projectRoot, projectConfig) {
+  if (projectConfig.dynamicConfigPath) {
+    const relativeDynamicConfigPath = _path().default.relative(projectRoot, projectConfig.dynamicConfigPath);
+    if (projectConfig.staticConfigPath) {
+      return `${relativeDynamicConfigPath} or ${_path().default.relative(projectRoot, projectConfig.staticConfigPath)}`;
+    }
+    return relativeDynamicConfigPath;
+  } else if (projectConfig.staticConfigPath) {
+    return _path().default.relative(projectRoot, projectConfig.staticConfigPath);
+  }
+  // If a config doesn't exist, our tooling will generate a static app.json
+  return 'app.json';
+}
+//# sourceMappingURL=Config.js.map

frontend-admin/node_modules/@expo/config/build/Config.types.d.ts

@@ -0,0 +1,165 @@
+import { ModConfig } from '@expo/config-plugins';
+import { ExpoConfig } from '@expo/config-types';
+export { ExpoConfig };
+export type PackageJSONConfig = {
+    dependencies?: Record<string, string>;
+    [key: string]: any;
+};
+export interface ProjectConfig {
+    /**
+     * Fully evaluated Expo config with default values injected.
+     */
+    exp: ExpoConfig;
+    /**
+     * Dynamic config for processing native files during the generation process.
+     */
+    mods?: ModConfig | null;
+    /**
+     * Project package.json object with default values injected.
+     */
+    pkg: PackageJSONConfig;
+    /**
+     * Unaltered static config (app.config.json, app.json, or custom json config).
+     * For legacy, an empty object will be returned even if no static config exists.
+     */
+    rootConfig: AppJSONConfig;
+    /**
+     * Path to the static json config file if it exists.
+     * If a project has an app.config.js and an app.json then app.json will be returned.
+     * If a project has an app.config.json and an app.json then app.config.json will be returned.
+     * Returns null if no static config file exists.
+     */
+    staticConfigPath: string | null;
+    /**
+     * Path to an app.config.js or app.config.ts.
+     * Returns null if no dynamic config file exists.
+     */
+    dynamicConfigPath: string | null;
+    /**
+     * Returns the type of the value exported from the dynamic config.
+     * This can be used to determine if the dynamic config is potentially extending a static config when (v === 'function').
+     * Returns null if no dynamic config file exists.
+     */
+    dynamicConfigObjectType: string | null;
+    /**
+     * Returns true if both a static and dynamic config are present, and the dynamic config is applied on top of the static.
+     * This is only used for expo-doctor diagnostic warnings. This flag may be true even in cases where all static config values are used.
+     * It only checks against a typical pattern for layering static and dynamic config, e.g.,:
+     * module.exports = ({ config }) => {
+        return {
+          ...config,
+          name: 'name overridden by dynamic config',
+        };
+      };
+     */
+    hasUnusedStaticConfig: boolean;
+}
+export type AppJSONConfig = {
+    expo: ExpoConfig;
+    [key: string]: any;
+};
+export type BareAppConfig = {
+    name: string;
+    [key: string]: any;
+};
+export type HookArguments = {
+    config: any;
+    url: any;
+    exp: ExpoConfig;
+    iosBundle: string | Uint8Array;
+    iosSourceMap: string | null;
+    iosManifest: any;
+    iosManifestUrl: string;
+    androidBundle: string | Uint8Array;
+    androidSourceMap: string | null;
+    androidManifest: any;
+    androidManifestUrl: string;
+    projectRoot: string;
+    log: (msg: any) => void;
+};
+export type ExpoGoConfig = {
+    mainModuleName: string;
+    debuggerHost: string;
+    developer: {
+        tool: string | null;
+        projectRoot?: string;
+    };
+    packagerOpts: {
+        [key: string]: any;
+    };
+};
+export type EASConfig = {
+    projectId?: string;
+};
+export type ClientScopingConfig = {
+    scopeKey?: string;
+};
+export interface ExpoUpdatesManifestAsset {
+    url: string;
+    key: string;
+    contentType: string;
+    hash?: string;
+}
+export interface ExpoUpdatesManifest {
+    id: string;
+    createdAt: string;
+    runtimeVersion: string;
+    launchAsset: ExpoUpdatesManifestAsset;
+    assets: ExpoUpdatesManifestAsset[];
+    metadata: {
+        [key: string]: string;
+    };
+    extra: ClientScopingConfig & {
+        expoClient?: ExpoConfig & {
+            /**
+             * Only present during development using @expo/cli.
+             */
+            hostUri?: string;
+        };
+        expoGo?: ExpoGoConfig;
+        eas?: EASConfig;
+    };
+}
+export type Hook = {
+    file: string;
+    config: any;
+};
+export type HookType = 'postPublish' | 'postExport';
+export declare enum ProjectPrivacy {
+    PUBLIC = "public",
+    UNLISTED = "unlisted"
+}
+export type Platform = 'android' | 'ios' | 'web';
+export type ProjectTarget = 'managed' | 'bare';
+export type ConfigErrorCode = 'NO_APP_JSON' | 'NOT_OBJECT' | 'NO_EXPO' | 'MODULE_NOT_FOUND' | 'DEPRECATED' | 'INVALID_MODE' | 'INVALID_FORMAT' | 'INVALID_PLUGIN' | 'INVALID_CONFIG' | 'ENTRY_NOT_FOUND';
+export type ConfigContext = {
+    projectRoot: string;
+    /**
+     * The static config path either app.json, app.config.json, or a custom user-defined config.
+     */
+    staticConfigPath: string | null;
+    packageJsonPath: string | null;
+    config: Partial<ExpoConfig>;
+};
+export type GetConfigOptions = {
+    isPublicConfig?: boolean;
+    /**
+     * Should the config `mods` be preserved in the config? Used for compiling mods in the eject command.
+     *
+     * @default false
+     */
+    isModdedConfig?: boolean;
+    skipSDKVersionRequirement?: boolean;
+    /**
+     * Dangerously skip resolving plugins.
+     */
+    skipPlugins?: boolean;
+    strict?: boolean;
+};
+export type WriteConfigOptions = {
+    dryRun?: boolean;
+};
+export type ConfigFilePaths = {
+    staticConfigPath: string | null;
+    dynamicConfigPath: string | null;
+};

frontend-admin/node_modules/@expo/config/build/Config.types.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ExpoConfig", {
+  enumerable: true,
+  get: function () {
+    return _configTypes().ExpoConfig;
+  }
+});
+exports.ProjectPrivacy = void 0;
+function _configTypes() {
+  const data = require("@expo/config-types");
+  _configTypes = function () {
+    return data;
+  };
+  return data;
+}
+let ProjectPrivacy = exports.ProjectPrivacy = /*#__PURE__*/function (ProjectPrivacy) {
+  ProjectPrivacy["PUBLIC"] = "public";
+  ProjectPrivacy["UNLISTED"] = "unlisted";
+  return ProjectPrivacy;
+}({});
+//# sourceMappingURL=Config.types.js.map

frontend-admin/node_modules/@expo/config/build/Errors.d.ts

@@ -0,0 +1,11 @@
+import { ConfigErrorCode } from './Config.types';
+/**
+ * Based on `JsonFileError` from `@expo/json-file`
+ */
+export declare class ConfigError extends Error {
+    code: ConfigErrorCode;
+    cause?: Error | undefined;
+    readonly name = "ConfigError";
+    readonly isConfigError = true;
+    constructor(message: string, code: ConfigErrorCode, cause?: Error | undefined);
+}

frontend-admin/node_modules/@expo/config/build/Errors.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConfigError = void 0;
+/**
+ * Based on `JsonFileError` from `@expo/json-file`
+ */
+class ConfigError extends Error {
+  name = 'ConfigError';
+  isConfigError = true;
+  constructor(message, code, cause) {
+    super(cause ? `${message}\n└─ Cause: ${cause.name}: ${cause.message}` : message);
+    this.code = code;
+    this.cause = cause;
+  }
+}
+exports.ConfigError = ConfigError;
+//# sourceMappingURL=Errors.js.map

frontend-admin/node_modules/@expo/config/build/Errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.js","names":["ConfigError","Error","name","isConfigError","constructor","message","code","cause","exports"],"sources":["../src/Errors.ts"],"sourcesContent":["import { ConfigErrorCode } from './Config.types';\n\n/**\n * Based on `JsonFileError` from `@expo/json-file`\n */\nexport class ConfigError extends Error {\n  readonly name = 'ConfigError';\n  readonly isConfigError = true;\n\n  constructor(\n    message: string,\n    public code: ConfigErrorCode,\n    public cause?: Error\n  ) {\n    super(cause ? `${message}\\n└─ Cause: ${cause.name}: ${cause.message}` : message);\n  }\n}\n"],"mappings":";;;;;;AAEA;AACA;AACA;AACO,MAAMA,WAAW,SAASC,KAAK,CAAC;EAC5BC,IAAI,GAAG,aAAa;EACpBC,aAAa,GAAG,IAAI;EAE7BC,WAAWA,CACTC,OAAe,EACRC,IAAqB,EACrBC,KAAa,EACpB;IACA,KAAK,CAACA,KAAK,GAAG,GAAGF,OAAO,eAAeE,KAAK,CAACL,IAAI,KAAKK,KAAK,CAACF,OAAO,EAAE,GAAGA,OAAO,CAAC;IAAC,KAH1EC,IAAqB,GAArBA,IAAqB;IAAA,KACrBC,KAAa,GAAbA,KAAa;EAGtB;AACF;AAACC,OAAA,CAAAR,WAAA,GAAAA,WAAA","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/Serialize.d.ts

@@ -0,0 +1,3 @@
+export declare function serializeAndEvaluate(val: any): any;
+export declare function serializeSkippingMods(val: any): any;
+export declare function serializeAfterStaticPlugins(val: any): any;

frontend-admin/node_modules/@expo/config/build/Serialize.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeAfterStaticPlugins = serializeAfterStaticPlugins;
+exports.serializeAndEvaluate = serializeAndEvaluate;
+exports.serializeSkippingMods = serializeSkippingMods;
+function _Errors() {
+  const data = require("./Errors");
+  _Errors = function () {
+    return data;
+  };
+  return data;
+}
+function serializeAndEvaluate(val) {
+  if (['undefined', 'string', 'boolean', 'number', 'bigint'].includes(typeof val)) {
+    return val;
+  } else if (typeof val === 'function') {
+    // TODO: Bacon: Should we support async methods?
+    return val();
+  } else if (Array.isArray(val)) {
+    return val.map(serializeAndEvaluate);
+  } else if (typeof val === 'object') {
+    const output = {};
+    for (const property in val) {
+      if (val.hasOwnProperty(property)) {
+        output[property] = serializeAndEvaluate(val[property]);
+      }
+    }
+    return output;
+  }
+  // symbol
+  throw new (_Errors().ConfigError)(`Expo config doesn't support \`Symbols\`: ${val}`, 'INVALID_CONFIG');
+}
+function serializeSkippingMods(val) {
+  if (typeof val === 'object' && !Array.isArray(val)) {
+    const output = {};
+    for (const property in val) {
+      if (val.hasOwnProperty(property)) {
+        if (property === 'mods' || property === 'plugins') {
+          // Don't serialize mods or plugins
+          output[property] = val[property];
+        } else {
+          output[property] = serializeAndEvaluate(val[property]);
+        }
+      }
+    }
+    return output;
+  }
+  return serializeAndEvaluate(val);
+}
+function serializeAndEvaluatePlugin(val) {
+  if (['undefined', 'string', 'boolean', 'number', 'bigint'].includes(typeof val)) {
+    return val;
+  } else if (typeof val === 'function') {
+    return val.name || 'withAnonymous';
+  } else if (Array.isArray(val)) {
+    return val.map(serializeAndEvaluatePlugin);
+  } else if (typeof val === 'object') {
+    const output = {};
+    for (const property in val) {
+      if (val.hasOwnProperty(property)) {
+        output[property] = serializeAndEvaluatePlugin(val[property]);
+      }
+    }
+    return output;
+  }
+  // symbol
+  throw new (_Errors().ConfigError)(`Expo config doesn't support \`Symbols\`: ${val}`, 'INVALID_CONFIG');
+}
+function serializeAfterStaticPlugins(val) {
+  if (typeof val === 'object' && !Array.isArray(val)) {
+    const output = {};
+    for (const property in val) {
+      if (val.hasOwnProperty(property)) {
+        if (property === 'mods') {
+          // Don't serialize mods
+          output[property] = val[property];
+        } else if (property === 'plugins' && Array.isArray(val[property])) {
+          // Serialize the mods by removing any config plugins
+          output[property] = val[property].map(serializeAndEvaluatePlugin);
+        } else {
+          output[property] = serializeAndEvaluate(val[property]);
+        }
+      }
+    }
+    return output;
+  }
+  return serializeAndEvaluate(val);
+}
+//# sourceMappingURL=Serialize.js.map

frontend-admin/node_modules/@expo/config/build/buildCacheProvider.d.ts

@@ -0,0 +1,78 @@
+type AndroidRunOptions = {
+    variant?: string;
+    device?: boolean | string;
+    port?: number;
+    bundler?: boolean;
+    install?: boolean;
+    buildCache?: boolean;
+    allArch?: boolean;
+    binary?: string;
+    appId?: string;
+};
+type IosRunOptions = {
+    /** iOS device to target. */
+    device?: string | boolean;
+    /** Dev server port to use, ignored if `bundler` is `false`. */
+    port?: number;
+    /** Xcode scheme to build. */
+    scheme?: string | boolean;
+    /** Xcode configuration to build. Default `Debug` */
+    configuration?: 'Debug' | 'Release';
+    /** Should start the bundler dev server. */
+    bundler?: boolean;
+    /** Should install missing dependencies before building. */
+    install?: boolean;
+    /** Should use derived data for builds. */
+    buildCache?: boolean;
+    /** Path to an existing binary to install on the device. */
+    binary?: string;
+    /** Re-bundle JS and assets, then embed in existing app, and install again. */
+    rebundle?: boolean;
+};
+export type RunOptions = AndroidRunOptions | IosRunOptions;
+export type ResolveBuildCacheProps = {
+    projectRoot: string;
+    platform: 'android' | 'ios';
+    runOptions: RunOptions;
+    fingerprintHash: string;
+};
+/**
+ * @deprecated Use `ResolveBuildCacheProps` instead.
+ */
+export type ResolveRemoteBuildCacheProps = ResolveBuildCacheProps;
+export type UploadBuildCacheProps = {
+    projectRoot: string;
+    buildPath: string;
+    runOptions: RunOptions;
+    fingerprintHash: string;
+    platform: 'android' | 'ios';
+};
+/**
+ * @deprecated Use `ResolveBuildCacheProps` instead.
+ */
+export type UploadRemoteBuildCacheProps = UploadBuildCacheProps;
+export type CalculateFingerprintHashProps = {
+    projectRoot: string;
+    platform: 'android' | 'ios';
+    runOptions: RunOptions;
+};
+export type BuildCacheProvider<T = any> = {
+    plugin: BuildCacheProviderPlugin<T>;
+    options: T;
+};
+export type BuildCacheProviderPlugin<T = any> = {
+    calculateFingerprintHash?: (props: CalculateFingerprintHashProps, options: T) => Promise<string | null>;
+} & ({
+    resolveBuildCache(props: ResolveBuildCacheProps, options: T): Promise<string | null>;
+    uploadBuildCache(props: UploadBuildCacheProps, options: T): Promise<string | null>;
+} | {
+    /**
+     * @deprecated Use `resolveBuildCache` instead.
+     */
+    resolveRemoteBuildCache: (props: ResolveRemoteBuildCacheProps, options: T) => Promise<string | null>;
+    /**
+     * @deprecated Use `uploadBuildCache` instead.
+     */
+    uploadRemoteBuildCache: (props: UploadRemoteBuildCacheProps, options: T) => Promise<string | null>;
+});
+export {};

frontend-admin/node_modules/@expo/config/build/buildCacheProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=buildCacheProvider.js.map

frontend-admin/node_modules/@expo/config/build/buildCacheProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildCacheProvider.js","names":[],"sources":["../src/buildCacheProvider.ts"],"sourcesContent":["type AndroidRunOptions = {\n  variant?: string;\n  device?: boolean | string;\n  port?: number;\n  bundler?: boolean;\n  install?: boolean;\n  buildCache?: boolean;\n  allArch?: boolean;\n  binary?: string;\n  appId?: string;\n};\n\ntype IosRunOptions = {\n  /** iOS device to target. */\n  device?: string | boolean;\n  /** Dev server port to use, ignored if `bundler` is `false`. */\n  port?: number;\n  /** Xcode scheme to build. */\n  scheme?: string | boolean;\n  /** Xcode configuration to build. Default `Debug` */\n  configuration?: 'Debug' | 'Release';\n  /** Should start the bundler dev server. */\n  bundler?: boolean;\n  /** Should install missing dependencies before building. */\n  install?: boolean;\n  /** Should use derived data for builds. */\n  buildCache?: boolean;\n  /** Path to an existing binary to install on the device. */\n  binary?: string;\n\n  /** Re-bundle JS and assets, then embed in existing app, and install again. */\n  rebundle?: boolean;\n};\n\nexport type RunOptions = AndroidRunOptions | IosRunOptions;\n\nexport type ResolveBuildCacheProps = {\n  projectRoot: string;\n  platform: 'android' | 'ios';\n  runOptions: RunOptions;\n  fingerprintHash: string;\n};\n\n/**\n * @deprecated Use `ResolveBuildCacheProps` instead.\n */\nexport type ResolveRemoteBuildCacheProps = ResolveBuildCacheProps;\n\nexport type UploadBuildCacheProps = {\n  projectRoot: string;\n  buildPath: string;\n  runOptions: RunOptions;\n  fingerprintHash: string;\n  platform: 'android' | 'ios';\n};\n/**\n * @deprecated Use `ResolveBuildCacheProps` instead.\n */\nexport type UploadRemoteBuildCacheProps = UploadBuildCacheProps;\n\nexport type CalculateFingerprintHashProps = {\n  projectRoot: string;\n  platform: 'android' | 'ios';\n  runOptions: RunOptions;\n};\n\nexport type BuildCacheProvider<T = any> = {\n  plugin: BuildCacheProviderPlugin<T>;\n  options: T;\n};\n\nexport type BuildCacheProviderPlugin<T = any> = {\n  calculateFingerprintHash?: (\n    props: CalculateFingerprintHashProps,\n    options: T\n  ) => Promise<string | null>;\n} & (\n  | {\n      resolveBuildCache(props: ResolveBuildCacheProps, options: T): Promise<string | null>;\n      uploadBuildCache(props: UploadBuildCacheProps, options: T): Promise<string | null>;\n    }\n  | {\n      /**\n       * @deprecated Use `resolveBuildCache` instead.\n       */\n      resolveRemoteBuildCache: (\n        props: ResolveRemoteBuildCacheProps,\n        options: T\n      ) => Promise<string | null>;\n      /**\n       * @deprecated Use `uploadBuildCache` instead.\n       */\n      uploadRemoteBuildCache: (\n        props: UploadRemoteBuildCacheProps,\n        options: T\n      ) => Promise<string | null>;\n    }\n);\n"],"mappings":"","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/environment.d.ts

@@ -0,0 +1 @@
+export declare const NON_STANDARD_SYMBOL: unique symbol;

frontend-admin/node_modules/@expo/config/build/environment.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NON_STANDARD_SYMBOL = void 0;
+const NON_STANDARD_SYMBOL = exports.NON_STANDARD_SYMBOL = Symbol('non-standard');
+//# sourceMappingURL=environment.js.map

frontend-admin/node_modules/@expo/config/build/environment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.js","names":["NON_STANDARD_SYMBOL","exports","Symbol"],"sources":["../src/environment.ts"],"sourcesContent":["export const NON_STANDARD_SYMBOL = Symbol('non-standard');\n"],"mappings":";;;;;;AAAO,MAAMA,mBAAmB,GAAAC,OAAA,CAAAD,mBAAA,GAAGE,MAAM,CAAC,cAAc,CAAC","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/evalConfig.d.ts

@@ -0,0 +1,31 @@
+import { AppJSONConfig, ConfigContext, ExpoConfig } from './Config.types';
+type RawDynamicConfig = AppJSONConfig | Partial<ExpoConfig> | null;
+export type DynamicConfigResults = {
+    config: RawDynamicConfig;
+    exportedObjectType: string;
+    mayHaveUnusedStaticConfig: boolean;
+};
+/**
+ * Transpile and evaluate the dynamic config object.
+ * This method is shared between the standard reading method in getConfig, and the headless script.
+ *
+ * @param options configFile path to the dynamic app.config.*, request to send to the dynamic config if it exports a function.
+ * @returns the serialized and evaluated config along with the exported object type (object or function).
+ */
+export declare function evalConfig(configFile: string, request: ConfigContext | null): DynamicConfigResults;
+/**
+ * - Resolve the exported contents of an Expo config (be it default or module.exports)
+ * - Assert no promise exports
+ * - Return config type
+ * - Serialize config
+ *
+ * @param result
+ * @param configFile
+ * @param request
+ */
+export declare function resolveConfigExport(result: any, configFile: string, request: ConfigContext | null): {
+    config: any;
+    exportedObjectType: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+    mayHaveUnusedStaticConfig: any;
+};
+export {};

frontend-admin/node_modules/@expo/config/build/evalConfig.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evalConfig = evalConfig;
+exports.resolveConfigExport = resolveConfigExport;
+function _fs() {
+  const data = require("fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _requireFromString() {
+  const data = _interopRequireDefault(require("require-from-string"));
+  _requireFromString = function () {
+    return data;
+  };
+  return data;
+}
+function _sucrase() {
+  const data = require("sucrase");
+  _sucrase = function () {
+    return data;
+  };
+  return data;
+}
+function _Errors() {
+  const data = require("./Errors");
+  _Errors = function () {
+    return data;
+  };
+  return data;
+}
+function _Serialize() {
+  const data = require("./Serialize");
+  _Serialize = function () {
+    return data;
+  };
+  return data;
+}
+function _environment() {
+  const data = require("./environment");
+  _environment = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Transpile and evaluate the dynamic config object.
+ * This method is shared between the standard reading method in getConfig, and the headless script.
+ *
+ * @param options configFile path to the dynamic app.config.*, request to send to the dynamic config if it exports a function.
+ * @returns the serialized and evaluated config along with the exported object type (object or function).
+ */
+function evalConfig(configFile, request) {
+  const contents = (0, _fs().readFileSync)(configFile, 'utf8');
+  let result;
+  try {
+    const {
+      code
+    } = (0, _sucrase().transform)(contents, {
+      filePath: configFile,
+      transforms: ['typescript', 'imports']
+    });
+    result = (0, _requireFromString().default)(code, configFile);
+  } catch (error) {
+    const location = extractLocationFromSyntaxError(error);
+
+    // Apply a code frame preview to the error if possible, sucrase doesn't do this by default.
+    if (location) {
+      const {
+        codeFrameColumns
+      } = require('@babel/code-frame');
+      const codeFrame = codeFrameColumns(contents, {
+        start: error.loc
+      }, {
+        highlightCode: true
+      });
+      error.codeFrame = codeFrame;
+      error.message += `\n${codeFrame}`;
+    } else {
+      const importantStack = extractImportantStackFromNodeError(error);
+      if (importantStack) {
+        error.message += `\n${importantStack}`;
+      }
+    }
+    throw error;
+  }
+  return resolveConfigExport(result, configFile, request);
+}
+function extractLocationFromSyntaxError(error) {
+  // sucrase provides the `loc` object
+  if (error.loc) {
+    return error.loc;
+  }
+
+  // `SyntaxError`s provide the `lineNumber` and `columnNumber` properties
+  if ('lineNumber' in error && 'columnNumber' in error) {
+    return {
+      line: error.lineNumber,
+      column: error.columnNumber
+    };
+  }
+  return null;
+}
+
+// These kinda errors often come from syntax errors in files that were imported by the main file.
+// An example is a module that includes an import statement.
+function extractImportantStackFromNodeError(error) {
+  if (isSyntaxError(error)) {
+    const traces = error.stack?.split('\n').filter(line => !line.startsWith('    at '));
+    if (!traces) return null;
+
+    // Remove redundant line
+    if (traces[traces.length - 1].startsWith('SyntaxError:')) {
+      traces.pop();
+    }
+    return traces.join('\n');
+  }
+  return null;
+}
+function isSyntaxError(error) {
+  return error instanceof SyntaxError || error.constructor.name === 'SyntaxError';
+}
+
+/**
+ * - Resolve the exported contents of an Expo config (be it default or module.exports)
+ * - Assert no promise exports
+ * - Return config type
+ * - Serialize config
+ *
+ * @param result
+ * @param configFile
+ * @param request
+ */
+function resolveConfigExport(result, configFile, request) {
+  // add key to static config that we'll check for after the dynamic is evaluated
+  // to see if the static config was used in determining the dynamic
+  const hasBaseStaticConfig = _environment().NON_STANDARD_SYMBOL;
+  if (request?.config) {
+    // @ts-ignore
+    request.config[hasBaseStaticConfig] = true;
+  }
+  if (result.default != null) {
+    result = result.default;
+  }
+  const exportedObjectType = typeof result;
+  if (typeof result === 'function') {
+    result = result(request);
+  }
+  if (result instanceof Promise) {
+    throw new (_Errors().ConfigError)(`Config file ${configFile} cannot return a Promise.`, 'INVALID_CONFIG');
+  }
+
+  // If the key is not added, it suggests that the static config was not used as the base for the dynamic.
+  // note(Keith): This is the most common way to use static and dynamic config together, but not the only way.
+  // Hence, this is only output from getConfig() for informational purposes for use by tools like Expo Doctor
+  // to suggest that there *may* be a problem.
+  const mayHaveUnusedStaticConfig =
+  // @ts-ignore
+  request?.config?.[hasBaseStaticConfig] && !result?.[hasBaseStaticConfig];
+  if (result) {
+    delete result._hasBaseStaticConfig;
+  }
+
+  // If the expo object exists, ignore all other values.
+  if (result?.expo) {
+    result = (0, _Serialize().serializeSkippingMods)(result.expo);
+  } else {
+    result = (0, _Serialize().serializeSkippingMods)(result);
+  }
+  return {
+    config: result,
+    exportedObjectType,
+    mayHaveUnusedStaticConfig
+  };
+}
+//# sourceMappingURL=evalConfig.js.map

frontend-admin/node_modules/@expo/config/build/getConfig.d.ts

@@ -0,0 +1,4 @@
+import { AppJSONConfig, ConfigContext, ExpoConfig } from './Config.types';
+import { DynamicConfigResults } from './evalConfig';
+export declare function getDynamicConfig(configPath: string, request: ConfigContext): DynamicConfigResults;
+export declare function getStaticConfig(configPath: string): AppJSONConfig | ExpoConfig;

frontend-admin/node_modules/@expo/config/build/getConfig.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDynamicConfig = getDynamicConfig;
+exports.getStaticConfig = getStaticConfig;
+function _jsonFile() {
+  const data = _interopRequireDefault(require("@expo/json-file"));
+  _jsonFile = function () {
+    return data;
+  };
+  return data;
+}
+function _fs() {
+  const data = require("fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _Errors() {
+  const data = require("./Errors");
+  _Errors = function () {
+    return data;
+  };
+  return data;
+}
+function _evalConfig() {
+  const data = require("./evalConfig");
+  _evalConfig = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// We cannot use async config resolution right now because Next.js doesn't support async configs.
+// If they don't add support for async Webpack configs then we may need to pull support for Next.js.
+function readConfigFile(configFile, context) {
+  // If the file doesn't exist then we should skip it and continue searching.
+  if (!(0, _fs().existsSync)(configFile)) {
+    return null;
+  }
+  try {
+    return (0, _evalConfig().evalConfig)(configFile, context);
+  } catch (error) {
+    // @ts-ignore
+    error.isConfigError = true;
+    error.message = `Error reading Expo config at ${configFile}:\n\n${error.message}`;
+    throw error;
+  }
+}
+function getDynamicConfig(configPath, request) {
+  const config = readConfigFile(configPath, request);
+  if (config) {
+    // The config must be serialized and evaluated ahead of time so the spawned process can send it over.
+    return config;
+  }
+  // TODO: It seems this is only thrown if the file cannot be found (which may never happen).
+  // If so we should throw a more helpful error.
+  throw new (_Errors().ConfigError)(`Failed to read config at: ${configPath}`, 'INVALID_CONFIG');
+}
+function getStaticConfig(configPath) {
+  const config = _jsonFile().default.read(configPath, {
+    json5: true
+  });
+  if (config) {
+    return config;
+  }
+  throw new (_Errors().ConfigError)(`Failed to read config at: ${configPath}`, 'INVALID_CONFIG');
+}
+//# sourceMappingURL=getConfig.js.map

frontend-admin/node_modules/@expo/config/build/getConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getConfig.js","names":["_jsonFile","data","_interopRequireDefault","require","_fs","_Errors","_evalConfig","e","__esModule","default","readConfigFile","configFile","context","existsSync","evalConfig","error","isConfigError","message","getDynamicConfig","configPath","request","config","ConfigError","getStaticConfig","JsonFile","read","json5"],"sources":["../src/getConfig.ts"],"sourcesContent":["import JsonFile from '@expo/json-file';\nimport { existsSync } from 'fs';\n\nimport { AppJSONConfig, ConfigContext, ExpoConfig } from './Config.types';\nimport { ConfigError } from './Errors';\nimport { DynamicConfigResults, evalConfig } from './evalConfig';\n\n// We cannot use async config resolution right now because Next.js doesn't support async configs.\n// If they don't add support for async Webpack configs then we may need to pull support for Next.js.\nfunction readConfigFile(configFile: string, context: ConfigContext): null | DynamicConfigResults {\n  // If the file doesn't exist then we should skip it and continue searching.\n  if (!existsSync(configFile)) {\n    return null;\n  }\n  try {\n    return evalConfig(configFile, context);\n  } catch (error: any) {\n    // @ts-ignore\n    error.isConfigError = true;\n    error.message = `Error reading Expo config at ${configFile}:\\n\\n${error.message}`;\n    throw error;\n  }\n}\n\nexport function getDynamicConfig(configPath: string, request: ConfigContext): DynamicConfigResults {\n  const config = readConfigFile(configPath, request);\n  if (config) {\n    // The config must be serialized and evaluated ahead of time so the spawned process can send it over.\n    return config;\n  }\n  // TODO: It seems this is only thrown if the file cannot be found (which may never happen).\n  // If so we should throw a more helpful error.\n  throw new ConfigError(`Failed to read config at: ${configPath}`, 'INVALID_CONFIG');\n}\n\nexport function getStaticConfig(configPath: string): AppJSONConfig | ExpoConfig {\n  const config = JsonFile.read(configPath, { json5: true });\n  if (config) {\n    return config as any;\n  }\n  throw new ConfigError(`Failed to read config at: ${configPath}`, 'INVALID_CONFIG');\n}\n"],"mappings":";;;;;;;AAAA,SAAAA,UAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,SAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,IAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,GAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAGA,SAAAI,QAAA;EAAA,MAAAJ,IAAA,GAAAE,OAAA;EAAAE,OAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAK,YAAA;EAAA,MAAAL,IAAA,GAAAE,OAAA;EAAAG,WAAA,YAAAA,CAAA;IAAA,OAAAL,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAgE,SAAAC,uBAAAK,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEhE;AACA;AACA,SAASG,cAAcA,CAACC,UAAkB,EAAEC,OAAsB,EAA+B;EAC/F;EACA,IAAI,CAAC,IAAAC,gBAAU,EAACF,UAAU,CAAC,EAAE;IAC3B,OAAO,IAAI;EACb;EACA,IAAI;IACF,OAAO,IAAAG,wBAAU,EAACH,UAAU,EAAEC,OAAO,CAAC;EACxC,CAAC,CAAC,OAAOG,KAAU,EAAE;IACnB;IACAA,KAAK,CAACC,aAAa,GAAG,IAAI;IAC1BD,KAAK,CAACE,OAAO,GAAG,gCAAgCN,UAAU,QAAQI,KAAK,CAACE,OAAO,EAAE;IACjF,MAAMF,KAAK;EACb;AACF;AAEO,SAASG,gBAAgBA,CAACC,UAAkB,EAAEC,OAAsB,EAAwB;EACjG,MAAMC,MAAM,GAAGX,cAAc,CAACS,UAAU,EAAEC,OAAO,CAAC;EAClD,IAAIC,MAAM,EAAE;IACV;IACA,OAAOA,MAAM;EACf;EACA;EACA;EACA,MAAM,KAAIC,qBAAW,EAAC,6BAA6BH,UAAU,EAAE,EAAE,gBAAgB,CAAC;AACpF;AAEO,SAASI,eAAeA,CAACJ,UAAkB,EAA8B;EAC9E,MAAME,MAAM,GAAGG,mBAAQ,CAACC,IAAI,CAACN,UAAU,EAAE;IAAEO,KAAK,EAAE;EAAK,CAAC,CAAC;EACzD,IAAIL,MAAM,EAAE;IACV,OAAOA,MAAM;EACf;EACA,MAAM,KAAIC,qBAAW,EAAC,6BAA6BH,UAAU,EAAE,EAAE,gBAAgB,CAAC;AACpF","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/getExpoSDKVersion.d.ts

@@ -0,0 +1,6 @@
+import { ExpoConfig } from './Config.types';
+/**
+ * Resolve the Expo SDK Version either from the input Expo config or from the installed
+ * version of the `expo` package.
+ */
+export declare function getExpoSDKVersion(projectRoot: string, exp?: Pick<ExpoConfig, 'sdkVersion'>): string;

frontend-admin/node_modules/@expo/config/build/getExpoSDKVersion.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExpoSDKVersion = getExpoSDKVersion;
+function _jsonFile() {
+  const data = _interopRequireDefault(require("@expo/json-file"));
+  _jsonFile = function () {
+    return data;
+  };
+  return data;
+}
+function _resolveFrom() {
+  const data = _interopRequireDefault(require("resolve-from"));
+  _resolveFrom = function () {
+    return data;
+  };
+  return data;
+}
+function _Errors() {
+  const data = require("./Errors");
+  _Errors = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Resolve the Expo SDK Version either from the input Expo config or from the installed
+ * version of the `expo` package.
+ */
+function getExpoSDKVersion(projectRoot, exp = {}) {
+  return exp?.sdkVersion ?? getExpoSDKVersionFromPackage(projectRoot);
+}
+
+/**
+ * Resolve the Expo SDK Version either from the input Expo config or from the installed
+ * version of the `expo` package.
+ */
+function getExpoSDKVersionFromPackage(projectRoot) {
+  const packageJsonPath = _resolveFrom().default.silent(projectRoot, 'expo/package.json');
+  if (!packageJsonPath) {
+    throw new (_Errors().ConfigError)(`Cannot determine the project's Expo SDK version because the module \`expo\` is not installed. Install it with \`npm install expo\` and try again.`, 'MODULE_NOT_FOUND');
+  }
+  const expoPackageJson = _jsonFile().default.read(packageJsonPath, {
+    json5: true
+  });
+  const {
+    version: packageVersion
+  } = expoPackageJson;
+  if (!(typeof packageVersion === 'string')) {
+    // This is technically impossible.
+    throw new (_Errors().ConfigError)(`Cannot determine the project's Expo SDK version because the module \`expo\` has an invalid package.json (missing \`version\` field). Try reinstalling node modules and trying again.`, 'MODULE_NOT_FOUND');
+  }
+  const majorVersion = packageVersion.split('.').shift();
+  return `${majorVersion}.0.0`;
+}
+//# sourceMappingURL=getExpoSDKVersion.js.map

frontend-admin/node_modules/@expo/config/build/getExpoSDKVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExpoSDKVersion.js","names":["_jsonFile","data","_interopRequireDefault","require","_resolveFrom","_Errors","e","__esModule","default","getExpoSDKVersion","projectRoot","exp","sdkVersion","getExpoSDKVersionFromPackage","packageJsonPath","resolveFrom","silent","ConfigError","expoPackageJson","JsonFile","read","json5","version","packageVersion","majorVersion","split","shift"],"sources":["../src/getExpoSDKVersion.ts"],"sourcesContent":["import JsonFile from '@expo/json-file';\nimport resolveFrom from 'resolve-from';\n\nimport { ExpoConfig } from './Config.types';\nimport { ConfigError } from './Errors';\n\n/**\n * Resolve the Expo SDK Version either from the input Expo config or from the installed\n * version of the `expo` package.\n */\nexport function getExpoSDKVersion(\n  projectRoot: string,\n  exp: Pick<ExpoConfig, 'sdkVersion'> = {}\n): string {\n  return exp?.sdkVersion ?? getExpoSDKVersionFromPackage(projectRoot);\n}\n\n/**\n * Resolve the Expo SDK Version either from the input Expo config or from the installed\n * version of the `expo` package.\n */\nfunction getExpoSDKVersionFromPackage(projectRoot: string): string {\n  const packageJsonPath = resolveFrom.silent(projectRoot, 'expo/package.json');\n  if (!packageJsonPath) {\n    throw new ConfigError(\n      `Cannot determine the project's Expo SDK version because the module \\`expo\\` is not installed. Install it with \\`npm install expo\\` and try again.`,\n      'MODULE_NOT_FOUND'\n    );\n  }\n  const expoPackageJson = JsonFile.read(packageJsonPath, { json5: true });\n  const { version: packageVersion } = expoPackageJson;\n\n  if (!(typeof packageVersion === 'string')) {\n    // This is technically impossible.\n    throw new ConfigError(\n      `Cannot determine the project's Expo SDK version because the module \\`expo\\` has an invalid package.json (missing \\`version\\` field). Try reinstalling node modules and trying again.`,\n      'MODULE_NOT_FOUND'\n    );\n  }\n\n  const majorVersion = packageVersion.split('.').shift();\n  return `${majorVersion}.0.0`;\n}\n"],"mappings":";;;;;;AAAA,SAAAA,UAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,SAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,aAAA;EAAA,MAAAH,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAC,YAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAGA,SAAAI,QAAA;EAAA,MAAAJ,IAAA,GAAAE,OAAA;EAAAE,OAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAuC,SAAAC,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEvC;AACA;AACA;AACA;AACO,SAASG,iBAAiBA,CAC/BC,WAAmB,EACnBC,GAAmC,GAAG,CAAC,CAAC,EAChC;EACR,OAAOA,GAAG,EAAEC,UAAU,IAAIC,4BAA4B,CAACH,WAAW,CAAC;AACrE;;AAEA;AACA;AACA;AACA;AACA,SAASG,4BAA4BA,CAACH,WAAmB,EAAU;EACjE,MAAMI,eAAe,GAAGC,sBAAW,CAACC,MAAM,CAACN,WAAW,EAAE,mBAAmB,CAAC;EAC5E,IAAI,CAACI,eAAe,EAAE;IACpB,MAAM,KAAIG,qBAAW,EACnB,mJAAmJ,EACnJ,kBACF,CAAC;EACH;EACA,MAAMC,eAAe,GAAGC,mBAAQ,CAACC,IAAI,CAACN,eAAe,EAAE;IAAEO,KAAK,EAAE;EAAK,CAAC,CAAC;EACvE,MAAM;IAAEC,OAAO,EAAEC;EAAe,CAAC,GAAGL,eAAe;EAEnD,IAAI,EAAE,OAAOK,cAAc,KAAK,QAAQ,CAAC,EAAE;IACzC;IACA,MAAM,KAAIN,qBAAW,EACnB,sLAAsL,EACtL,kBACF,CAAC;EACH;EAEA,MAAMO,YAAY,GAAGD,cAAc,CAACE,KAAK,CAAC,GAAG,CAAC,CAACC,KAAK,CAAC,CAAC;EACtD,OAAO,GAAGF,YAAY,MAAM;AAC9B","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Config';
+export * from './Config.types';
+export * from './getExpoSDKVersion';
+export * from './Errors';
+export * from './buildCacheProvider';

frontend-admin/node_modules/@expo/config/build/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Config = require("./Config");
+Object.keys(_Config).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Config[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Config[key];
+    }
+  });
+});
+var _Config2 = require("./Config.types");
+Object.keys(_Config2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Config2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Config2[key];
+    }
+  });
+});
+var _getExpoSDKVersion = require("./getExpoSDKVersion");
+Object.keys(_getExpoSDKVersion).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getExpoSDKVersion[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getExpoSDKVersion[key];
+    }
+  });
+});
+var _Errors = require("./Errors");
+Object.keys(_Errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Errors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Errors[key];
+    }
+  });
+});
+var _buildCacheProvider = require("./buildCacheProvider");
+Object.keys(_buildCacheProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _buildCacheProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _buildCacheProvider[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

frontend-admin/node_modules/@expo/config/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_Config","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_Config2","_getExpoSDKVersion","_Errors","_buildCacheProvider"],"sources":["../src/index.ts"],"sourcesContent":["/* eslint-disable import/export */\n\nexport * from './Config';\nexport * from './Config.types';\nexport * from './getExpoSDKVersion';\nexport * from './Errors';\nexport * from './buildCacheProvider';\n"],"mappings":";;;;;AAEA,IAAAA,OAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,OAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,OAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,OAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,QAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,QAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,QAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,QAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AACA,IAAAM,kBAAA,GAAAV,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAQ,kBAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,kBAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,kBAAA,CAAAN,GAAA;IAAA;EAAA;AAAA;AACA,IAAAO,OAAA,GAAAX,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAS,OAAA,EAAAR,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAO,OAAA,CAAAP,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAG,OAAA,CAAAP,GAAA;IAAA;EAAA;AAAA;AACA,IAAAQ,mBAAA,GAAAZ,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAU,mBAAA,EAAAT,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAQ,mBAAA,CAAAR,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAI,mBAAA,CAAAR,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/paths/env.d.ts

@@ -0,0 +1,6 @@
+declare class Env {
+    /** Disable auto server root detection for Metro. This will not change the server root to the workspace root. */
+    get EXPO_NO_METRO_WORKSPACE_ROOT(): boolean;
+}
+export declare const env: Env;
+export {};

frontend-admin/node_modules/@expo/config/build/paths/env.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.env = void 0;
+function _getenv() {
+  const data = require("getenv");
+  _getenv = function () {
+    return data;
+  };
+  return data;
+}
+class Env {
+  /** Disable auto server root detection for Metro. This will not change the server root to the workspace root. */
+  get EXPO_NO_METRO_WORKSPACE_ROOT() {
+    if ((0, _getenv().string)('EXPO_USE_METRO_WORKSPACE_ROOT', '')) {
+      console.warn('EXPO_USE_METRO_WORKSPACE_ROOT is enabled by default, use EXPO_NO_METRO_WORKSPACE_ROOT instead to disable.');
+    }
+    return (0, _getenv().boolish)('EXPO_NO_METRO_WORKSPACE_ROOT', false);
+  }
+}
+const env = exports.env = new Env();
+//# sourceMappingURL=env.js.map

frontend-admin/node_modules/@expo/config/build/paths/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","names":["_getenv","data","require","Env","EXPO_NO_METRO_WORKSPACE_ROOT","string","console","warn","boolish","env","exports"],"sources":["../../src/paths/env.ts"],"sourcesContent":["import { boolish, string } from 'getenv';\n\nclass Env {\n  /** Disable auto server root detection for Metro. This will not change the server root to the workspace root. */\n  get EXPO_NO_METRO_WORKSPACE_ROOT(): boolean {\n    if (string('EXPO_USE_METRO_WORKSPACE_ROOT', '')) {\n      console.warn(\n        'EXPO_USE_METRO_WORKSPACE_ROOT is enabled by default, use EXPO_NO_METRO_WORKSPACE_ROOT instead to disable.'\n      );\n    }\n\n    return boolish('EXPO_NO_METRO_WORKSPACE_ROOT', false);\n  }\n}\n\nexport const env = new Env();\n"],"mappings":";;;;;;AAAA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,MAAME,GAAG,CAAC;EACR;EACA,IAAIC,4BAA4BA,CAAA,EAAY;IAC1C,IAAI,IAAAC,gBAAM,EAAC,+BAA+B,EAAE,EAAE,CAAC,EAAE;MAC/CC,OAAO,CAACC,IAAI,CACV,2GACF,CAAC;IACH;IAEA,OAAO,IAAAC,iBAAO,EAAC,8BAA8B,EAAE,KAAK,CAAC;EACvD;AACF;AAEO,MAAMC,GAAG,GAAAC,OAAA,CAAAD,GAAA,GAAG,IAAIN,GAAG,CAAC,CAAC","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/paths/extensions.d.ts

@@ -0,0 +1,8 @@
+export type LanguageOptions = {
+    isTS: boolean;
+    isModern: boolean;
+    isReact: boolean;
+};
+export declare function getExtensions(platforms: string[], extensions: string[], workflows: string[]): string[];
+export declare function getLanguageExtensionsInOrder({ isTS, isModern, isReact, }: LanguageOptions): string[];
+export declare function getBareExtensions(platforms: string[], languageOptions?: LanguageOptions): string[];

frontend-admin/node_modules/@expo/config/build/paths/extensions.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBareExtensions = getBareExtensions;
+exports.getExtensions = getExtensions;
+exports.getLanguageExtensionsInOrder = getLanguageExtensionsInOrder;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function getExtensions(platforms, extensions, workflows) {
+  // In the past we used spread operators to collect the values so now we enforce type safety on them.
+  (0, _assert().default)(Array.isArray(platforms), 'Expected: `platforms: string[]`');
+  (0, _assert().default)(Array.isArray(extensions), 'Expected: `extensions: string[]`');
+  (0, _assert().default)(Array.isArray(workflows), 'Expected: `workflows: string[]`');
+  const fileExtensions = [];
+  // support .expo files
+  for (const workflow of [...workflows, '']) {
+    // Ensure order is correct: [platformA.js, platformB.js, js]
+    for (const platform of [...platforms, '']) {
+      // Support both TypeScript and JavaScript
+      for (const extension of extensions) {
+        fileExtensions.push([platform, workflow, extension].filter(Boolean).join('.'));
+      }
+    }
+  }
+  return fileExtensions;
+}
+function getLanguageExtensionsInOrder({
+  isTS,
+  isModern,
+  isReact
+}) {
+  // @ts-ignore: filter removes false type
+  const addLanguage = lang => [lang, isReact && `${lang}x`].filter(Boolean);
+
+  // Support JavaScript
+  let extensions = addLanguage('js');
+  if (isModern) {
+    extensions.unshift('mjs');
+  }
+  if (isTS) {
+    extensions = [...addLanguage('ts'), ...extensions];
+  }
+  return extensions;
+}
+function getBareExtensions(platforms, languageOptions = {
+  isTS: true,
+  isModern: true,
+  isReact: true
+}) {
+  const fileExtensions = getExtensions(platforms, getLanguageExtensionsInOrder(languageOptions), []);
+  // Always add these last
+  _addMiscellaneousExtensions(platforms, fileExtensions);
+  return fileExtensions;
+}
+function _addMiscellaneousExtensions(platforms, fileExtensions) {
+  // Always add these with no platform extension
+  // In the future we may want to add platform and workspace extensions to json.
+  fileExtensions.push('json');
+  // Native doesn't currently support web assembly.
+  if (platforms.includes('web')) {
+    fileExtensions.push('wasm');
+  }
+  return fileExtensions;
+}
+//# sourceMappingURL=extensions.js.map

frontend-admin/node_modules/@expo/config/build/paths/extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.js","names":["_assert","data","_interopRequireDefault","require","e","__esModule","default","getExtensions","platforms","extensions","workflows","assert","Array","isArray","fileExtensions","workflow","platform","extension","push","filter","Boolean","join","getLanguageExtensionsInOrder","isTS","isModern","isReact","addLanguage","lang","unshift","getBareExtensions","languageOptions","_addMiscellaneousExtensions","includes"],"sources":["../../src/paths/extensions.ts"],"sourcesContent":["import assert from 'assert';\n\nexport type LanguageOptions = {\n  isTS: boolean;\n  isModern: boolean;\n  isReact: boolean;\n};\n\nexport function getExtensions(\n  platforms: string[],\n  extensions: string[],\n  workflows: string[]\n): string[] {\n  // In the past we used spread operators to collect the values so now we enforce type safety on them.\n  assert(Array.isArray(platforms), 'Expected: `platforms: string[]`');\n  assert(Array.isArray(extensions), 'Expected: `extensions: string[]`');\n  assert(Array.isArray(workflows), 'Expected: `workflows: string[]`');\n\n  const fileExtensions = [];\n  // support .expo files\n  for (const workflow of [...workflows, '']) {\n    // Ensure order is correct: [platformA.js, platformB.js, js]\n    for (const platform of [...platforms, '']) {\n      // Support both TypeScript and JavaScript\n      for (const extension of extensions) {\n        fileExtensions.push([platform, workflow, extension].filter(Boolean).join('.'));\n      }\n    }\n  }\n  return fileExtensions;\n}\n\nexport function getLanguageExtensionsInOrder({\n  isTS,\n  isModern,\n  isReact,\n}: LanguageOptions): string[] {\n  // @ts-ignore: filter removes false type\n  const addLanguage = (lang: string): string[] => [lang, isReact && `${lang}x`].filter(Boolean);\n\n  // Support JavaScript\n  let extensions = addLanguage('js');\n\n  if (isModern) {\n    extensions.unshift('mjs');\n  }\n  if (isTS) {\n    extensions = [...addLanguage('ts'), ...extensions];\n  }\n\n  return extensions;\n}\n\nexport function getBareExtensions(\n  platforms: string[],\n  languageOptions: LanguageOptions = { isTS: true, isModern: true, isReact: true }\n): string[] {\n  const fileExtensions = getExtensions(\n    platforms,\n    getLanguageExtensionsInOrder(languageOptions),\n    []\n  );\n  // Always add these last\n  _addMiscellaneousExtensions(platforms, fileExtensions);\n  return fileExtensions;\n}\n\nfunction _addMiscellaneousExtensions(platforms: string[], fileExtensions: string[]): string[] {\n  // Always add these with no platform extension\n  // In the future we may want to add platform and workspace extensions to json.\n  fileExtensions.push('json');\n  // Native doesn't currently support web assembly.\n  if (platforms.includes('web')) {\n    fileExtensions.push('wasm');\n  }\n  return fileExtensions;\n}\n"],"mappings":";;;;;;;;AAAA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA4B,SAAAC,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAQrB,SAASG,aAAaA,CAC3BC,SAAmB,EACnBC,UAAoB,EACpBC,SAAmB,EACT;EACV;EACA,IAAAC,iBAAM,EAACC,KAAK,CAACC,OAAO,CAACL,SAAS,CAAC,EAAE,iCAAiC,CAAC;EACnE,IAAAG,iBAAM,EAACC,KAAK,CAACC,OAAO,CAACJ,UAAU,CAAC,EAAE,kCAAkC,CAAC;EACrE,IAAAE,iBAAM,EAACC,KAAK,CAACC,OAAO,CAACH,SAAS,CAAC,EAAE,iCAAiC,CAAC;EAEnE,MAAMI,cAAc,GAAG,EAAE;EACzB;EACA,KAAK,MAAMC,QAAQ,IAAI,CAAC,GAAGL,SAAS,EAAE,EAAE,CAAC,EAAE;IACzC;IACA,KAAK,MAAMM,QAAQ,IAAI,CAAC,GAAGR,SAAS,EAAE,EAAE,CAAC,EAAE;MACzC;MACA,KAAK,MAAMS,SAAS,IAAIR,UAAU,EAAE;QAClCK,cAAc,CAACI,IAAI,CAAC,CAACF,QAAQ,EAAED,QAAQ,EAAEE,SAAS,CAAC,CAACE,MAAM,CAACC,OAAO,CAAC,CAACC,IAAI,CAAC,GAAG,CAAC,CAAC;MAChF;IACF;EACF;EACA,OAAOP,cAAc;AACvB;AAEO,SAASQ,4BAA4BA,CAAC;EAC3CC,IAAI;EACJC,QAAQ;EACRC;AACe,CAAC,EAAY;EAC5B;EACA,MAAMC,WAAW,GAAIC,IAAY,IAAe,CAACA,IAAI,EAAEF,OAAO,IAAI,GAAGE,IAAI,GAAG,CAAC,CAACR,MAAM,CAACC,OAAO,CAAC;;EAE7F;EACA,IAAIX,UAAU,GAAGiB,WAAW,CAAC,IAAI,CAAC;EAElC,IAAIF,QAAQ,EAAE;IACZf,UAAU,CAACmB,OAAO,CAAC,KAAK,CAAC;EAC3B;EACA,IAAIL,IAAI,EAAE;IACRd,UAAU,GAAG,CAAC,GAAGiB,WAAW,CAAC,IAAI,CAAC,EAAE,GAAGjB,UAAU,CAAC;EACpD;EAEA,OAAOA,UAAU;AACnB;AAEO,SAASoB,iBAAiBA,CAC/BrB,SAAmB,EACnBsB,eAAgC,GAAG;EAAEP,IAAI,EAAE,IAAI;EAAEC,QAAQ,EAAE,IAAI;EAAEC,OAAO,EAAE;AAAK,CAAC,EACtE;EACV,MAAMX,cAAc,GAAGP,aAAa,CAClCC,SAAS,EACTc,4BAA4B,CAACQ,eAAe,CAAC,EAC7C,EACF,CAAC;EACD;EACAC,2BAA2B,CAACvB,SAAS,EAAEM,cAAc,CAAC;EACtD,OAAOA,cAAc;AACvB;AAEA,SAASiB,2BAA2BA,CAACvB,SAAmB,EAAEM,cAAwB,EAAY;EAC5F;EACA;EACAA,cAAc,CAACI,IAAI,CAAC,MAAM,CAAC;EAC3B;EACA,IAAIV,SAAS,CAACwB,QAAQ,CAAC,KAAK,CAAC,EAAE;IAC7BlB,cAAc,CAACI,IAAI,CAAC,MAAM,CAAC;EAC7B;EACA,OAAOJ,cAAc;AACvB","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/paths/index.d.ts

@@ -0,0 +1,2 @@
+export * from './paths';
+export * from './extensions';

frontend-admin/node_modules/@expo/config/build/paths/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _paths = require("./paths");
+Object.keys(_paths).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _paths[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _paths[key];
+    }
+  });
+});
+var _extensions = require("./extensions");
+Object.keys(_extensions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _extensions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _extensions[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

frontend-admin/node_modules/@expo/config/build/paths/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_paths","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_extensions"],"sources":["../../src/paths/index.ts"],"sourcesContent":["export * from './paths';\nexport * from './extensions';\n"],"mappings":";;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,MAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,MAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,MAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,WAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,WAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,WAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,WAAA,CAAAL,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/paths/paths.d.ts

@@ -0,0 +1,27 @@
+import { PackageJSONConfig } from '../Config.types';
+export declare function ensureSlash(inputPath: string, needsSlash: boolean): string;
+export declare function getPossibleProjectRoot(): string;
+/** @returns the absolute entry file for an Expo project. */
+export declare function resolveEntryPoint(projectRoot: string, { platform, pkg, }?: {
+    platform?: string;
+    pkg?: PackageJSONConfig;
+}): string;
+export declare function getFileWithExtensions(fromDirectory: string, moduleId: string, extensions: string[]): string | null;
+/** Get the Metro server root, when working in monorepos */
+export declare function getMetroServerRoot(projectRoot: string): string;
+/**
+ * Get the workspace globs for Metro's watchFolders.
+ * @note This does not traverse the monorepo, and should be used with `getMetroServerRoot`
+ */
+export declare function getMetroWorkspaceGlobs(monorepoRoot: string): string[] | null;
+/**
+ * Convert an absolute entry point to a server or project root relative filepath.
+ * This is useful on Android where the entry point is an absolute path.
+ */
+export declare function convertEntryPointToRelative(projectRoot: string, absolutePath: string): string;
+/**
+ * Resolve the entry point relative to either the server or project root.
+ * This relative entry path should be used to pass non-absolute paths to Metro,
+ * accounting for possible monorepos and keeping the cache sharable (no absolute paths).
+ */
+export declare const resolveRelativeEntryPoint: typeof resolveEntryPoint;

frontend-admin/node_modules/@expo/config/build/paths/paths.js

@@ -0,0 +1,189 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertEntryPointToRelative = convertEntryPointToRelative;
+exports.ensureSlash = ensureSlash;
+exports.getFileWithExtensions = getFileWithExtensions;
+exports.getMetroServerRoot = getMetroServerRoot;
+exports.getMetroWorkspaceGlobs = getMetroWorkspaceGlobs;
+exports.getPossibleProjectRoot = getPossibleProjectRoot;
+exports.resolveEntryPoint = resolveEntryPoint;
+exports.resolveRelativeEntryPoint = void 0;
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _resolveFrom() {
+  const data = _interopRequireDefault(require("resolve-from"));
+  _resolveFrom = function () {
+    return data;
+  };
+  return data;
+}
+function _resolveWorkspaceRoot() {
+  const data = require("resolve-workspace-root");
+  _resolveWorkspaceRoot = function () {
+    return data;
+  };
+  return data;
+}
+function _env() {
+  const data = require("./env");
+  _env = function () {
+    return data;
+  };
+  return data;
+}
+function _extensions() {
+  const data = require("./extensions");
+  _extensions = function () {
+    return data;
+  };
+  return data;
+}
+function _Config() {
+  const data = require("../Config");
+  _Config = function () {
+    return data;
+  };
+  return data;
+}
+function _Errors() {
+  const data = require("../Errors");
+  _Errors = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// https://github.com/facebook/create-react-app/blob/9750738cce89a967cc71f28390daf5d4311b193c/packages/react-scripts/config/paths.js#L22
+function ensureSlash(inputPath, needsSlash) {
+  const hasSlash = inputPath.endsWith('/');
+  if (hasSlash && !needsSlash) {
+    return inputPath.substring(0, inputPath.length - 1);
+  } else if (!hasSlash && needsSlash) {
+    return `${inputPath}/`;
+  } else {
+    return inputPath;
+  }
+}
+function getPossibleProjectRoot() {
+  return _fs().default.realpathSync(process.cwd());
+}
+const nativePlatforms = ['ios', 'android'];
+
+/** @returns the absolute entry file for an Expo project. */
+function resolveEntryPoint(projectRoot, {
+  platform,
+  pkg = (0, _Config().getPackageJson)(projectRoot)
+} = {}) {
+  const platforms = !platform ? [] : nativePlatforms.includes(platform) ? [platform, 'native'] : [platform];
+  const extensions = (0, _extensions().getBareExtensions)(platforms);
+
+  // If the config doesn't define a custom entry then we want to look at the `package.json`s `main` field, and try again.
+  const {
+    main
+  } = pkg;
+  if (main && typeof main === 'string') {
+    // Testing the main field against all of the provided extensions - for legacy reasons we can't use node module resolution as the package.json allows you to pass in a file without a relative path and expect it as a relative path.
+    let entry = getFileWithExtensions(projectRoot, main, extensions);
+    if (!entry) {
+      // Allow for paths like: `{ "main": "expo/AppEntry" }`
+      entry = resolveFromSilentWithExtensions(projectRoot, main, extensions);
+      if (!entry) throw new (_Errors().ConfigError)(`Cannot resolve entry file: The \`main\` field defined in your \`package.json\` points to an unresolvable or non-existent path.`, 'ENTRY_NOT_FOUND');
+    }
+    return entry;
+  }
+
+  // Check for a root index.* file in the project root.
+  const entry = resolveFromSilentWithExtensions(projectRoot, './index', extensions);
+  if (entry) {
+    return entry;
+  }
+  try {
+    // If none of the default files exist then we will attempt to use the main Expo entry point.
+    // This requires `expo` to be installed in the project to work as it will use `node_module/expo/AppEntry.js`
+    // Doing this enables us to create a bare minimum Expo project.
+
+    // TODO(Bacon): We may want to do a check against `./App` and `expo` in the `package.json` `dependencies` as we can more accurately ensure that the project is expo-min without needing the modules installed.
+    return (0, _resolveFrom().default)(projectRoot, 'expo/AppEntry');
+  } catch {
+    throw new (_Errors().ConfigError)(`The project entry file could not be resolved. Define it in the \`main\` field of the \`package.json\`, create an \`index.js\`, or install the \`expo\` package.`, 'ENTRY_NOT_FOUND');
+  }
+}
+
+// Resolve from but with the ability to resolve like a bundler
+function resolveFromSilentWithExtensions(fromDirectory, moduleId, extensions) {
+  for (const extension of extensions) {
+    const modulePath = _resolveFrom().default.silent(fromDirectory, `${moduleId}.${extension}`);
+    if (modulePath?.endsWith(extension)) {
+      return modulePath;
+    }
+  }
+  return _resolveFrom().default.silent(fromDirectory, moduleId) || null;
+}
+
+// Statically attempt to resolve a module but with the ability to resolve like a bundler.
+// This won't use node module resolution.
+function getFileWithExtensions(fromDirectory, moduleId, extensions) {
+  const modulePath = _path().default.join(fromDirectory, moduleId);
+  if (_fs().default.existsSync(modulePath)) {
+    return modulePath;
+  }
+  for (const extension of extensions) {
+    const modulePath = _path().default.join(fromDirectory, `${moduleId}.${extension}`);
+    if (_fs().default.existsSync(modulePath)) {
+      return modulePath;
+    }
+  }
+  return null;
+}
+
+/** Get the Metro server root, when working in monorepos */
+function getMetroServerRoot(projectRoot) {
+  if (_env().env.EXPO_NO_METRO_WORKSPACE_ROOT) {
+    return projectRoot;
+  }
+  return (0, _resolveWorkspaceRoot().resolveWorkspaceRoot)(projectRoot) ?? projectRoot;
+}
+
+/**
+ * Get the workspace globs for Metro's watchFolders.
+ * @note This does not traverse the monorepo, and should be used with `getMetroServerRoot`
+ */
+function getMetroWorkspaceGlobs(monorepoRoot) {
+  return (0, _resolveWorkspaceRoot().getWorkspaceGlobs)(monorepoRoot);
+}
+
+/**
+ * Convert an absolute entry point to a server or project root relative filepath.
+ * This is useful on Android where the entry point is an absolute path.
+ */
+function convertEntryPointToRelative(projectRoot, absolutePath) {
+  // The project root could be using a different root on MacOS (`/var` vs `/private/var`)
+  // We need to make sure to get the non-symlinked path to the server or project root.
+  return _path().default.relative(_fs().default.realpathSync(getMetroServerRoot(projectRoot)), _fs().default.realpathSync(absolutePath));
+}
+
+/**
+ * Resolve the entry point relative to either the server or project root.
+ * This relative entry path should be used to pass non-absolute paths to Metro,
+ * accounting for possible monorepos and keeping the cache sharable (no absolute paths).
+ */
+const resolveRelativeEntryPoint = (projectRoot, options) => {
+  return convertEntryPointToRelative(projectRoot, resolveEntryPoint(projectRoot, options));
+};
+exports.resolveRelativeEntryPoint = resolveRelativeEntryPoint;
+//# sourceMappingURL=paths.js.map

frontend-admin/node_modules/@expo/config/build/plugins/withConfigPlugins.d.ts

@@ -0,0 +1,8 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+/**
+ * Resolves static plugins array as config plugin functions.
+ *
+ * @param config
+ * @param projectRoot
+ */
+export declare const withConfigPlugins: ConfigPlugin<boolean>;

frontend-admin/node_modules/@expo/config/build/plugins/withConfigPlugins.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withConfigPlugins = void 0;
+function _configPlugins() {
+  const data = require("@expo/config-plugins");
+  _configPlugins = function () {
+    return data;
+  };
+  return data;
+}
+function _Serialize() {
+  const data = require("../Serialize");
+  _Serialize = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * Resolves static plugins array as config plugin functions.
+ *
+ * @param config
+ * @param projectRoot
+ */
+const withConfigPlugins = (config, skipPlugins) => {
+  // @ts-ignore: plugins not on config type yet -- TODO
+  if (!Array.isArray(config.plugins) || !config.plugins?.length) {
+    return config;
+  }
+  if (!skipPlugins) {
+    // Resolve and evaluate plugins
+    // @ts-ignore: TODO: add plugins to the config schema
+    config = (0, _configPlugins().withPlugins)(config, config.plugins);
+  } else {
+    // Delete the plugins array in case someone added functions or other values which cannot be automatically serialized.
+    delete config.plugins;
+  }
+  // plugins aren't serialized by default, serialize the plugins after resolving them.
+  return (0, _Serialize().serializeAfterStaticPlugins)(config);
+};
+exports.withConfigPlugins = withConfigPlugins;
+//# sourceMappingURL=withConfigPlugins.js.map

frontend-admin/node_modules/@expo/config/build/plugins/withConfigPlugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withConfigPlugins.js","names":["_configPlugins","data","require","_Serialize","withConfigPlugins","config","skipPlugins","Array","isArray","plugins","length","withPlugins","serializeAfterStaticPlugins","exports"],"sources":["../../src/plugins/withConfigPlugins.ts"],"sourcesContent":["import { ConfigPlugin, withPlugins } from '@expo/config-plugins';\n\nimport { serializeAfterStaticPlugins } from '../Serialize';\n\n/**\n * Resolves static plugins array as config plugin functions.\n *\n * @param config\n * @param projectRoot\n */\nexport const withConfigPlugins: ConfigPlugin<boolean> = (config, skipPlugins) => {\n  // @ts-ignore: plugins not on config type yet -- TODO\n  if (!Array.isArray(config.plugins) || !config.plugins?.length) {\n    return config;\n  }\n  if (!skipPlugins) {\n    // Resolve and evaluate plugins\n    // @ts-ignore: TODO: add plugins to the config schema\n    config = withPlugins(config, config.plugins);\n  } else {\n    // Delete the plugins array in case someone added functions or other values which cannot be automatically serialized.\n    delete config.plugins;\n  }\n  // plugins aren't serialized by default, serialize the plugins after resolving them.\n  return serializeAfterStaticPlugins(config);\n};\n"],"mappings":";;;;;;AAAA,SAAAA,eAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,cAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAE,WAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,UAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMG,iBAAwC,GAAGA,CAACC,MAAM,EAAEC,WAAW,KAAK;EAC/E;EACA,IAAI,CAACC,KAAK,CAACC,OAAO,CAACH,MAAM,CAACI,OAAO,CAAC,IAAI,CAACJ,MAAM,CAACI,OAAO,EAAEC,MAAM,EAAE;IAC7D,OAAOL,MAAM;EACf;EACA,IAAI,CAACC,WAAW,EAAE;IAChB;IACA;IACAD,MAAM,GAAG,IAAAM,4BAAW,EAACN,MAAM,EAAEA,MAAM,CAACI,OAAO,CAAC;EAC9C,CAAC,MAAM;IACL;IACA,OAAOJ,MAAM,CAACI,OAAO;EACvB;EACA;EACA,OAAO,IAAAG,wCAA2B,EAACP,MAAM,CAAC;AAC5C,CAAC;AAACQ,OAAA,CAAAT,iBAAA,GAAAA,iBAAA","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/plugins/withInternal.d.ts

@@ -0,0 +1,13 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { ConfigFilePaths } from '../Config.types';
+export declare const EXPO_DEBUG: boolean;
+/**
+ * Adds the _internal object.
+ *
+ * @param config
+ * @param projectRoot
+ */
+export declare const withInternal: ConfigPlugin<{
+    projectRoot: string;
+    packageJsonPath?: string;
+} & Partial<ConfigFilePaths>>;

frontend-admin/node_modules/@expo/config/build/plugins/withInternal.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withInternal = exports.EXPO_DEBUG = void 0;
+function _getenv() {
+  const data = require("getenv");
+  _getenv = function () {
+    return data;
+  };
+  return data;
+}
+const EXPO_DEBUG = exports.EXPO_DEBUG = (0, _getenv().boolish)('EXPO_DEBUG', false);
+
+/**
+ * Adds the _internal object.
+ *
+ * @param config
+ * @param projectRoot
+ */
+const withInternal = (config, internals) => {
+  if (!config._internal) {
+    config._internal = {};
+  }
+  config._internal = {
+    isDebug: EXPO_DEBUG,
+    ...config._internal,
+    ...internals
+  };
+  return config;
+};
+exports.withInternal = withInternal;
+//# sourceMappingURL=withInternal.js.map

frontend-admin/node_modules/@expo/config/build/plugins/withInternal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withInternal.js","names":["_getenv","data","require","EXPO_DEBUG","exports","boolish","withInternal","config","internals","_internal","isDebug"],"sources":["../../src/plugins/withInternal.ts"],"sourcesContent":["import { ConfigPlugin } from '@expo/config-plugins';\nimport { boolish } from 'getenv';\n\nimport { ConfigFilePaths } from '../Config.types';\n\nexport const EXPO_DEBUG = boolish('EXPO_DEBUG', false);\n\n/**\n * Adds the _internal object.\n *\n * @param config\n * @param projectRoot\n */\nexport const withInternal: ConfigPlugin<\n  { projectRoot: string; packageJsonPath?: string } & Partial<ConfigFilePaths>\n> = (config, internals) => {\n  if (!config._internal) {\n    config._internal = {};\n  }\n\n  config._internal = {\n    isDebug: EXPO_DEBUG,\n    ...config._internal,\n    ...internals,\n  };\n\n  return config;\n};\n"],"mappings":";;;;;;AACA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAIO,MAAME,UAAU,GAAAC,OAAA,CAAAD,UAAA,GAAG,IAAAE,iBAAO,EAAC,YAAY,EAAE,KAAK,CAAC;;AAEtD;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,YAEZ,GAAGA,CAACC,MAAM,EAAEC,SAAS,KAAK;EACzB,IAAI,CAACD,MAAM,CAACE,SAAS,EAAE;IACrBF,MAAM,CAACE,SAAS,GAAG,CAAC,CAAC;EACvB;EAEAF,MAAM,CAACE,SAAS,GAAG;IACjBC,OAAO,EAAEP,UAAU;IACnB,GAAGI,MAAM,CAACE,SAAS;IACnB,GAAGD;EACL,CAAC;EAED,OAAOD,MAAM;AACf,CAAC;AAACH,OAAA,CAAAE,YAAA,GAAAA,YAAA","ignoreList":[]}

frontend-admin/node_modules/@expo/config/build/resolvePackageJson.d.ts

@@ -0,0 +1 @@
+export declare function getRootPackageJsonPath(projectRoot: string): string;

frontend-admin/node_modules/@expo/config/build/resolvePackageJson.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRootPackageJsonPath = getRootPackageJsonPath;
+function _fs() {
+  const data = require("fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _Errors() {
+  const data = require("./Errors");
+  _Errors = function () {
+    return data;
+  };
+  return data;
+}
+function getRootPackageJsonPath(projectRoot) {
+  const packageJsonPath = (0, _path().join)(projectRoot, 'package.json');
+  if (!(0, _fs().existsSync)(packageJsonPath)) {
+    throw new (_Errors().ConfigError)(`The expected package.json path: ${packageJsonPath} does not exist`, 'MODULE_NOT_FOUND');
+  }
+  return packageJsonPath;
+}
+//# sourceMappingURL=resolvePackageJson.js.map

frontend-admin/node_modules/@expo/config/build/resolvePackageJson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePackageJson.js","names":["_fs","data","require","_path","_Errors","getRootPackageJsonPath","projectRoot","packageJsonPath","join","existsSync","ConfigError"],"sources":["../src/resolvePackageJson.ts"],"sourcesContent":["import { existsSync } from 'fs';\nimport { join } from 'path';\n\nimport { ConfigError } from './Errors';\n\nexport function getRootPackageJsonPath(projectRoot: string): string {\n  const packageJsonPath = join(projectRoot, 'package.json');\n  if (!existsSync(packageJsonPath)) {\n    throw new ConfigError(\n      `The expected package.json path: ${packageJsonPath} does not exist`,\n      'MODULE_NOT_FOUND'\n    );\n  }\n  return packageJsonPath;\n}\n"],"mappings":";;;;;;AAAA,SAAAA,IAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,GAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,MAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,KAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAG,QAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,OAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,SAASI,sBAAsBA,CAACC,WAAmB,EAAU;EAClE,MAAMC,eAAe,GAAG,IAAAC,YAAI,EAACF,WAAW,EAAE,cAAc,CAAC;EACzD,IAAI,CAAC,IAAAG,gBAAU,EAACF,eAAe,CAAC,EAAE;IAChC,MAAM,KAAIG,qBAAW,EACnB,mCAAmCH,eAAe,iBAAiB,EACnE,kBACF,CAAC;EACH;EACA,OAAOA,eAAe;AACxB","ignoreList":[]}

frontend-admin/node_modules/@expo/config/node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver.js

frontend-admin/node_modules/@expo/config/node_modules/@babel/code-frame/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

frontend-admin/node_modules/@expo/config/node_modules/@babel/code-frame/README.md

@@ -0,0 +1,19 @@
+# @babel/code-frame
+
+> Generate errors that contain a code frame that point to source locations.
+
+See our website [@babel/code-frame](https://babeljs.io/docs/en/next/babel-code-frame.html) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/code-frame
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/code-frame --dev
+```

frontend-admin/node_modules/@expo/config/node_modules/@babel/code-frame/lib/index.js

@@ -0,0 +1,167 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.codeFrameColumns = codeFrameColumns;
+exports.default = _default;
+
+var _highlight = _interopRequireWildcard(require("@babel/highlight"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (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; }
+
+let deprecationWarningShown = false;
+
+function getDefs(chalk) {
+  return {
+    gutter: chalk.grey,
+    marker: chalk.red.bold,
+    message: chalk.red.bold
+  };
+}
+
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+
+function getMarkerLines(loc, source, opts) {
+  const startLoc = Object.assign({
+    column: 0,
+    line: -1
+  }, loc.start);
+  const endLoc = Object.assign({}, startLoc, loc.end);
+  const {
+    linesAbove = 2,
+    linesBelow = 3
+  } = opts || {};
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+
+  if (startLine === -1) {
+    start = 0;
+  }
+
+  if (endLine === -1) {
+    end = source.length;
+  }
+
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
+
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length;
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - i].length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0];
+      } else {
+        markerLines[startLine] = true;
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn];
+    }
+  }
+
+  return {
+    start,
+    end,
+    markerLines
+  };
+}
+
+function codeFrameColumns(rawLines, loc, opts = {}) {
+  const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
+  const chalk = (0, _highlight.getChalk)(opts);
+  const defs = getDefs(chalk);
+
+  const maybeHighlight = (chalkFn, string) => {
+    return highlighted ? chalkFn(string) : string;
+  };
+
+  const lines = rawLines.split(NEWLINE);
+  const {
+    start,
+    end,
+    markerLines
+  } = getMarkerLines(loc, lines, opts);
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  const numberMaxWidth = String(end).length;
+  const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
+  let frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} | `;
+    const hasMarker = markerLines[number];
+    const lastMarkerLine = !markerLines[number + 1];
+
+    if (hasMarker) {
+      let markerLine = "";
+
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
+
+        if (lastMarkerLine && opts.message) {
+          markerLine += " " + maybeHighlight(defs.message, opts.message);
+        }
+      }
+
+      return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
+    } else {
+      return ` ${maybeHighlight(defs.gutter, gutter)}${line}`;
+    }
+  }).join("\n");
+
+  if (opts.message && !hasColumns) {
+    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+  }
+
+  if (highlighted) {
+    return chalk.reset(frame);
+  } else {
+    return frame;
+  }
+}
+
+function _default(rawLines, lineNumber, colNumber, opts = {}) {
+  if (!deprecationWarningShown) {
+    deprecationWarningShown = true;
+    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+
+    if (process.emitWarning) {
+      process.emitWarning(message, "DeprecationWarning");
+    } else {
+      const deprecationError = new Error(message);
+      deprecationError.name = "DeprecationWarning";
+      console.warn(new Error(message));
+    }
+  }
+
+  colNumber = Math.max(colNumber, 0);
+  const location = {
+    start: {
+      column: colNumber,
+      line: lineNumber
+    }
+  };
+  return codeFrameColumns(rawLines, location, opts);
+}

frontend-admin/node_modules/@expo/config/node_modules/@babel/code-frame/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@babel/code-frame",
+  "version": "7.10.4",
+  "description": "Generate errors that contain a code frame that point to source locations.",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-code-frame"
+  },
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/highlight": "^7.10.4"
+  },
+  "devDependencies": {
+    "chalk": "^2.0.0",
+    "strip-ansi": "^4.0.0"
+  },
+  "gitHead": "7fd40d86a0d03ff0e9c3ea16b29689945433d4df"
+}

frontend-admin/node_modules/@expo/config/node_modules/semver/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

frontend-admin/node_modules/@expo/config/node_modules/semver/README.md

@@ -0,0 +1,664 @@
+semver(1) -- The semantic versioner for npm
+===========================================
+
+## Install
+
+```bash
+npm install semver
+````
+
+## Usage
+
+As a node module:
+
+```js
+const semver = require('semver')
+
+semver.valid('1.2.3') // '1.2.3'
+semver.valid('a.b.c') // null
+semver.clean('  =v1.2.3   ') // '1.2.3'
+semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
+semver.gt('1.2.3', '9.8.7') // false
+semver.lt('1.2.3', '9.8.7') // true
+semver.minVersion('>=1.0.0') // '1.0.0'
+semver.valid(semver.coerce('v2')) // '2.0.0'
+semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
+```
+
+You can also just load the module for the function that you care about if
+you'd like to minimize your footprint.
+
+```js
+// load the whole API at once in a single object
+const semver = require('semver')
+
+// or just load the bits you need
+// all of them listed here, just pick and choose what you want
+
+// classes
+const SemVer = require('semver/classes/semver')
+const Comparator = require('semver/classes/comparator')
+const Range = require('semver/classes/range')
+
+// functions for working with versions
+const semverParse = require('semver/functions/parse')
+const semverValid = require('semver/functions/valid')
+const semverClean = require('semver/functions/clean')
+const semverInc = require('semver/functions/inc')
+const semverDiff = require('semver/functions/diff')
+const semverMajor = require('semver/functions/major')
+const semverMinor = require('semver/functions/minor')
+const semverPatch = require('semver/functions/patch')
+const semverPrerelease = require('semver/functions/prerelease')
+const semverCompare = require('semver/functions/compare')
+const semverRcompare = require('semver/functions/rcompare')
+const semverCompareLoose = require('semver/functions/compare-loose')
+const semverCompareBuild = require('semver/functions/compare-build')
+const semverSort = require('semver/functions/sort')
+const semverRsort = require('semver/functions/rsort')
+
+// low-level comparators between versions
+const semverGt = require('semver/functions/gt')
+const semverLt = require('semver/functions/lt')
+const semverEq = require('semver/functions/eq')
+const semverNeq = require('semver/functions/neq')
+const semverGte = require('semver/functions/gte')
+const semverLte = require('semver/functions/lte')
+const semverCmp = require('semver/functions/cmp')
+const semverCoerce = require('semver/functions/coerce')
+
+// working with ranges
+const semverSatisfies = require('semver/functions/satisfies')
+const semverMaxSatisfying = require('semver/ranges/max-satisfying')
+const semverMinSatisfying = require('semver/ranges/min-satisfying')
+const semverToComparators = require('semver/ranges/to-comparators')
+const semverMinVersion = require('semver/ranges/min-version')
+const semverValidRange = require('semver/ranges/valid')
+const semverOutside = require('semver/ranges/outside')
+const semverGtr = require('semver/ranges/gtr')
+const semverLtr = require('semver/ranges/ltr')
+const semverIntersects = require('semver/ranges/intersects')
+const semverSimplifyRange = require('semver/ranges/simplify')
+const semverRangeSubset = require('semver/ranges/subset')
+```
+
+As a command-line utility:
+
+```
+$ semver -h
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, prerelease, or release.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-n <0|1>
+        This is the base to be used for the prerelease identifier.
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.
+```
+
+## Versions
+
+A "version" is described by the `v2.0.0` specification found at
+<https://semver.org/>.
+
+A leading `"="` or `"v"` character is stripped off and ignored.
+Support for stripping a leading "v" is kept for compatibility with `v1.0.0` of the SemVer
+specification but should not be used anymore.
+
+## Ranges
+
+A `version range` is a set of `comparators` that specify versions
+that satisfy the range.
+
+A `comparator` is composed of an `operator` and a `version`.  The set
+of primitive `operators` is:
+
+* `<` Less than
+* `<=` Less than or equal to
+* `>` Greater than
+* `>=` Greater than or equal to
+* `=` Equal.  If no operator is specified, then equality is assumed,
+  so this operator is optional but MAY be included.
+
+For example, the comparator `>=1.2.7` would match the versions
+`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
+or `1.1.0`. The comparator `>1` is equivalent to `>=2.0.0` and
+would match the versions `2.0.0` and `3.1.0`, but not the versions
+`1.0.1` or `1.1.0`.
+
+Comparators can be joined by whitespace to form a `comparator set`,
+which is satisfied by the **intersection** of all of the comparators
+it includes.
+
+A range is composed of one or more comparator sets, joined by `||`.  A
+version matches a range if and only if every comparator in at least
+one of the `||`-separated comparator sets is satisfied by the version.
+
+For example, the range `>=1.2.7 <1.3.0` would match the versions
+`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
+or `1.1.0`.
+
+The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
+`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
+
+### Prerelease Tags
+
+If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
+it will only be allowed to satisfy comparator sets if at least one
+comparator with the same `[major, minor, patch]` tuple also has a
+prerelease tag.
+
+For example, the range `>1.2.3-alpha.3` would be allowed to match the
+version `1.2.3-alpha.7`, but it would *not* be satisfied by
+`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
+than" `1.2.3-alpha.3` according to the SemVer sort rules.  The version
+range only accepts prerelease tags on the `1.2.3` version.
+Version `3.4.5` *would* satisfy the range because it does not have a
+prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
+
+The purpose of this behavior is twofold.  First, prerelease versions
+frequently are updated very quickly, and contain many breaking changes
+that are (by the author's design) not yet fit for public consumption.
+Therefore, by default, they are excluded from range-matching
+semantics.
+
+Second, a user who has opted into using a prerelease version has
+indicated the intent to use *that specific* set of
+alpha/beta/rc versions.  By including a prerelease tag in the range,
+the user is indicating that they are aware of the risk.  However, it
+is still not appropriate to assume that they have opted into taking a
+similar risk on the *next* set of prerelease versions.
+
+Note that this behavior can be suppressed (treating all prerelease
+versions as if they were normal versions, for range-matching)
+by setting the `includePrerelease` flag on the options
+object to any
+[functions](https://github.com/npm/node-semver#functions) that do
+range matching.
+
+#### Prerelease Identifiers
+
+The method `.inc` takes an additional `identifier` string argument that
+will append the value of the string as a prerelease identifier:
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta')
+// '1.2.4-beta.0'
+```
+
+command-line example:
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta
+1.2.4-beta.0
+```
+
+Which then can be used to increment further:
+
+```bash
+$ semver 1.2.4-beta.0 -i prerelease
+1.2.4-beta.1
+```
+
+To get out of the prerelease phase, use the `release` option:
+
+```bash
+$ semver 1.2.4-beta.1 -i release
+1.2.4
+```
+
+#### Prerelease Identifier Base
+
+The method `.inc` takes an optional parameter 'identifierBase' string
+that will let you let your prerelease number as zero-based or one-based.
+Set to `false` to omit the prerelease number altogether.
+If you do not specify this parameter, it will default to zero-based.
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta', '1')
+// '1.2.4-beta.1'
+```
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta', false)
+// '1.2.4-beta'
+```
+
+command-line example:
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta -n 1
+1.2.4-beta.1
+```
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta -n false
+1.2.4-beta
+```
+
+### Advanced Range Syntax
+
+Advanced range syntax desugars to primitive comparators in
+deterministic ways.
+
+Advanced ranges may be combined in the same way as primitive
+comparators using white space or `||`.
+
+#### Hyphen Ranges `X.Y.Z - A.B.C`
+
+Specifies an inclusive set.
+
+* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+
+If a partial version is provided as the first version in the inclusive
+range, then the missing pieces are replaced with zeroes.
+
+* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
+
+If a partial version is provided as the second version in the
+inclusive range, then all versions that start with the supplied parts
+of the tuple are accepted, but nothing that would be greater than the
+provided tuple parts.
+
+* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0-0`
+* `1.2.3 - 2` := `>=1.2.3 <3.0.0-0`
+
+#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
+
+Any of `X`, `x`, or `*` may be used to "stand in" for one of the
+numeric values in the `[major, minor, patch]` tuple.
+
+* `*` := `>=0.0.0` (Any non-prerelease version satisfies, unless
+  `includePrerelease` is specified, in which case any version at all
+  satisfies)
+* `1.x` := `>=1.0.0 <2.0.0-0` (Matching major version)
+* `1.2.x` := `>=1.2.0 <1.3.0-0` (Matching major and minor versions)
+
+A partial version range is treated as an X-Range, so the special
+character is in fact optional.
+
+* `""` (empty string) := `*` := `>=0.0.0`
+* `1` := `1.x.x` := `>=1.0.0 <2.0.0-0`
+* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0-0`
+
+#### Tilde Ranges `~1.2.3` `~1.2` `~1`
+
+Allows patch-level changes if a minor version is specified on the
+comparator.  Allows minor-level changes if not.
+
+* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0-0`
+* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0-0` (Same as `1.2.x`)
+* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0-0` (Same as `1.x`)
+* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0-0`
+* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0-0` (Same as `0.2.x`)
+* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0-0` (Same as `0.x`)
+* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0-0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+
+#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
+
+Allows changes that do not modify the left-most non-zero element in the
+`[major, minor, patch]` tuple.  In other words, this allows patch and
+minor updates for versions `1.0.0` and above, patch updates for
+versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
+
+Many authors treat a `0.x` version as if the `x` were the major
+"breaking-change" indicator.
+
+Caret ranges are ideal when an author may make breaking changes
+between `0.2.4` and `0.3.0` releases, which is a common practice.
+However, it presumes that there will *not* be breaking changes between
+`0.2.4` and `0.2.5`.  It allows for changes that are presumed to be
+additive (but non-breaking), according to commonly observed practices.
+
+* `^1.2.3` := `>=1.2.3 <2.0.0-0`
+* `^0.2.3` := `>=0.2.3 <0.3.0-0`
+* `^0.0.3` := `>=0.0.3 <0.0.4-0`
+* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0-0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4-0`  Note that prereleases in the
+  `0.0.3` version *only* will be allowed, if they are greater than or
+  equal to `beta`.  So, `0.0.3-pr.2` would be allowed.
+
+When parsing caret ranges, a missing `patch` value desugars to the
+number `0`, but will allow flexibility within that value, even if the
+major and minor versions are both `0`.
+
+* `^1.2.x` := `>=1.2.0 <2.0.0-0`
+* `^0.0.x` := `>=0.0.0 <0.1.0-0`
+* `^0.0` := `>=0.0.0 <0.1.0-0`
+
+A missing `minor` and `patch` values will desugar to zero, but also
+allow flexibility within those values, even if the major version is
+zero.
+
+* `^1.x` := `>=1.0.0 <2.0.0-0`
+* `^0.x` := `>=0.0.0 <1.0.0-0`
+
+### Range Grammar
+
+Putting all this together, here is a Backus-Naur grammar for ranges,
+for the benefit of parser authors:
+
+```bnf
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+
+```
+
+## Functions
+
+All methods and classes take a final `options` object argument.  All
+options in this object are `false` by default.  The options supported
+are:
+
+- `loose`: Be more forgiving about not-quite-valid semver strings.
+  (Any resulting output will always be 100% strict compliant, of
+  course.)  For backwards compatibility reasons, if the `options`
+  argument is a boolean value instead of an object, it is interpreted
+  to be the `loose` param.
+- `includePrerelease`: Set to suppress the [default
+  behavior](https://github.com/npm/node-semver#prerelease-tags) of
+  excluding prerelease tagged versions from ranges unless they are
+  explicitly opted into.
+
+Strict-mode Comparators and Ranges will be strict about the SemVer
+strings that they parse.
+
+* `valid(v)`: Return the parsed version, or null if it's not valid.
+* `inc(v, releaseType, options, identifier, identifierBase)`: 
+  Return the version incremented by the release
+  type (`major`, `premajor`, `minor`, `preminor`, `patch`,
+  `prepatch`, `prerelease`, or `release`), or null if it's not valid
+  * `premajor` in one call will bump the version up to the next major
+    version and down to a prerelease of that major version.
+    `preminor`, and `prepatch` work the same way.
+  * If called from a non-prerelease version, `prerelease` will work the
+    same as `prepatch`. It increments the patch version and then makes a
+    prerelease. If the input version is already a prerelease it simply
+    increments it.
+  * `release` will remove any prerelease part of the version.
+  * `identifier` can be used to prefix `premajor`, `preminor`,
+    `prepatch`, or `prerelease` version increments. `identifierBase`
+    is the base to be used for the `prerelease` identifier.
+* `prerelease(v)`: Returns an array of prerelease components, or null
+  if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
+* `major(v)`: Return the major version number.
+* `minor(v)`: Return the minor version number.
+* `patch(v)`: Return the patch version number.
+* `intersects(r1, r2, loose)`: Return true if the two supplied ranges
+  or comparators intersect.
+* `parse(v)`: Attempt to parse a string as a semantic version, returning either
+  a `SemVer` object or `null`.
+
+### Comparison
+
+* `gt(v1, v2)`: `v1 > v2`
+* `gte(v1, v2)`: `v1 >= v2`
+* `lt(v1, v2)`: `v1 < v2`
+* `lte(v1, v2)`: `v1 <= v2`
+* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
+  even if they're not the same string.  You already know how to
+  compare strings.
+* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
+* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
+  the corresponding function above.  `"==="` and `"!=="` do simple
+  string comparison, but are included for completeness.  Throws if an
+  invalid comparison string is provided.
+* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
+* `rcompare(v1, v2)`: The reverse of `compare`.  Sorts an array of versions
+  in descending order when passed to `Array.sort()`.
+* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions
+  are equal.  Sorts in ascending order if passed to `Array.sort()`.
+* `compareLoose(v1, v2)`: Short for `compare(v1, v2, { loose: true })`.
+* `diff(v1, v2)`: Returns the difference between two versions by the release type
+  (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
+  or null if the versions are the same.
+
+### Sorting
+
+* `sort(versions)`: Returns a sorted array of versions based on the `compareBuild` 
+  function.
+* `rsort(versions)`: The reverse of `sort`. Returns an array of versions based on
+  the `compareBuild` function in descending order.
+
+### Comparators
+
+* `intersects(comparator)`: Return true if the comparators intersect
+
+### Ranges
+
+* `validRange(range)`: Return the valid range or null if it's not valid.
+* `satisfies(version, range)`: Return true if the version satisfies the
+  range.
+* `maxSatisfying(versions, range)`: Return the highest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minSatisfying(versions, range)`: Return the lowest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minVersion(range)`: Return the lowest version that can match
+  the given range.
+* `gtr(version, range)`: Return `true` if the version is greater than all the
+  versions possible in the range.
+* `ltr(version, range)`: Return `true` if the version is less than all the
+  versions possible in the range.
+* `outside(version, range, hilo)`: Return true if the version is outside
+  the bounds of the range in either the high or low direction.  The
+  `hilo` argument must be either the string `'>'` or `'<'`.  (This is
+  the function called by `gtr` and `ltr`.)
+* `intersects(range)`: Return true if any of the range comparators intersect.
+* `simplifyRange(versions, range)`: Return a "simplified" range that
+  matches the same items in the `versions` list as the range specified.  Note
+  that it does *not* guarantee that it would match the same versions in all
+  cases, only for the set of versions provided.  This is useful when
+  generating ranges by joining together multiple versions with `||`
+  programmatically, to provide the user with something a bit more
+  ergonomic.  If the provided range is shorter in string-length than the
+  generated range, then that is returned.
+* `subset(subRange, superRange)`: Return `true` if the `subRange` range is
+  entirely contained by the `superRange` range.
+
+Note that, since ranges may be non-contiguous, a version might not be
+greater than a range, less than a range, *or* satisfy a range!  For
+example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
+until `2.0.0`, so version `1.2.10` would not be greater than the
+range (because `2.0.1` satisfies, which is higher), nor less than the
+range (since `1.2.8` satisfies, which is lower), and it also does not
+satisfy the range.
+
+If you want to know if a version satisfies or does not satisfy a
+range, use the `satisfies(version, range)` function.
+
+### Coercion
+
+* `coerce(version, options)`: Coerces a string to semver if possible
+
+This aims to provide a very forgiving translation of a non-semver string to
+semver. It looks for the first digit in a string and consumes all
+remaining characters which satisfy at least a partial semver (e.g., `1`,
+`1.2`, `1.2.3`) up to the max permitted length (256 characters).  Longer
+versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).  All
+surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
+`3.4.0`).  Only text which lacks digits will fail coercion (`version one`
+is not valid).  The maximum length for any semver component considered for
+coercion is 16 characters; longer components will be ignored
+(`10000000000000000.4.7.4` becomes `4.7.4`).  The maximum value for any
+semver component is `Number.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+components are invalid (`9999999999999999.4.7.4` is likely invalid).
+
+If the `options.rtl` flag is set, then `coerce` will return the right-most
+coercible tuple that does not share an ending index with a longer coercible
+tuple.  For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
+`4.0.0`.  `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
+any other overlapping SemVer tuple.
+
+If the `options.includePrerelease` flag is set, then the `coerce` result will contain
+prerelease and build parts of a version.  For example, `1.2.3.4-rc.1+rev.2`
+will preserve prerelease `rc.1` and build `rev.2` in the result.
+
+### Clean
+
+* `clean(version)`: Clean a string to be a valid semver if possible
+
+This will return a cleaned and trimmed semver version. If the provided
+version is not valid a null will be returned. This does not work for
+ranges.
+
+ex.
+* `s.clean(' = v 2.1.5foo')`: `null`
+* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean(' = v 2.1.5-foo')`: `null`
+* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean('=v2.1.5')`: `'2.1.5'`
+* `s.clean('  =v2.1.5')`: `'2.1.5'`
+* `s.clean('      2.1.5   ')`: `'2.1.5'`
+* `s.clean('~1.0.0')`: `null`
+
+## Constants
+
+As a convenience, helper constants are exported to provide information about what `node-semver` supports:
+
+### `RELEASE_TYPES`
+
+- major
+- premajor
+- minor
+- preminor
+- patch
+- prepatch
+- prerelease
+
+```
+const semver = require('semver');
+
+if (semver.RELEASE_TYPES.includes(arbitraryUserInput)) {
+  console.log('This is a valid release type!');
+} else {
+  console.warn('This is NOT a valid release type!');
+}
+```
+
+### `SEMVER_SPEC_VERSION`
+
+2.0.0
+
+```
+const semver = require('semver');
+
+console.log('We are currently using the semver specification version:', semver.SEMVER_SPEC_VERSION);
+```
+
+## Exported Modules
+
+<!--
+TODO: Make sure that all of these items are documented (classes aren't,
+eg), and then pull the module name into the documentation for that specific
+thing.
+-->
+
+You may pull in just the part of this semver utility that you need if you
+are sensitive to packing and tree-shaking concerns.  The main
+`require('semver')` export uses getter functions to lazily load the parts
+of the API that are used.
+
+The following modules are available:
+
+* `require('semver')`
+* `require('semver/classes')`
+* `require('semver/classes/comparator')`
+* `require('semver/classes/range')`
+* `require('semver/classes/semver')`
+* `require('semver/functions/clean')`
+* `require('semver/functions/cmp')`
+* `require('semver/functions/coerce')`
+* `require('semver/functions/compare')`
+* `require('semver/functions/compare-build')`
+* `require('semver/functions/compare-loose')`
+* `require('semver/functions/diff')`
+* `require('semver/functions/eq')`
+* `require('semver/functions/gt')`
+* `require('semver/functions/gte')`
+* `require('semver/functions/inc')`
+* `require('semver/functions/lt')`
+* `require('semver/functions/lte')`
+* `require('semver/functions/major')`
+* `require('semver/functions/minor')`
+* `require('semver/functions/neq')`
+* `require('semver/functions/parse')`
+* `require('semver/functions/patch')`
+* `require('semver/functions/prerelease')`
+* `require('semver/functions/rcompare')`
+* `require('semver/functions/rsort')`
+* `require('semver/functions/satisfies')`
+* `require('semver/functions/sort')`
+* `require('semver/functions/valid')`
+* `require('semver/ranges/gtr')`
+* `require('semver/ranges/intersects')`
+* `require('semver/ranges/ltr')`
+* `require('semver/ranges/max-satisfying')`
+* `require('semver/ranges/min-satisfying')`
+* `require('semver/ranges/min-version')`
+* `require('semver/ranges/outside')`
+* `require('semver/ranges/simplify')`
+* `require('semver/ranges/subset')`
+* `require('semver/ranges/to-comparators')`
+* `require('semver/ranges/valid')`
+

frontend-admin/node_modules/@expo/config/node_modules/semver/bin/semver.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+'use strict'
+
+const argv = process.argv.slice(2)
+
+let versions = []
+
+const range = []
+
+let inc = null
+
+const version = require('../package.json').version
+
+let loose = false
+
+let includePrerelease = false
+
+let coerce = false
+
+let rtl = false
+
+let identifier
+
+let identifierBase
+
+const semver = require('../')
+const parseOptions = require('../internal/parse-options')
+
+let reverse = false
+
+let options = {}
+
+const main = () => {
+  if (!argv.length) {
+    return help()
+  }
+  while (argv.length) {
+    let a = argv.shift()
+    const indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      const value = a.slice(indexOfEqualSign + 1)
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(value)
+    }
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        switch (argv[0]) {
+          case 'major': case 'minor': case 'patch': case 'prerelease':
+          case 'premajor': case 'preminor': case 'prepatch':
+          case 'release':
+            inc = argv.shift()
+            break
+          default:
+            inc = 'patch'
+            break
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-n':
+        identifierBase = argv.shift()
+        if (identifierBase === 'false') {
+          identifierBase = false
+        }
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '--rtl':
+        rtl = true
+        break
+      case '--ltr':
+        rtl = false
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  options = parseOptions({ loose, includePrerelease, rtl })
+
+  versions = versions.map((v) => {
+    return coerce ? (semver.coerce(v, options) || { version: v }).version : v
+  }).filter((v) => {
+    return semver.valid(v)
+  })
+  if (!versions.length) {
+    return fail()
+  }
+  if (inc && (versions.length !== 1 || range.length)) {
+    return failInc()
+  }
+
+  for (let i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter((v) => {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) {
+      return fail()
+    }
+  }
+  versions
+    .sort((a, b) => semver[reverse ? 'rcompare' : 'compare'](a, b, options))
+    .map(v => semver.clean(v, options))
+    .map(v => inc ? semver.inc(v, inc, options, identifier, identifierBase) : v)
+    .forEach(v => console.log(v))
+}
+
+const failInc = () => {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+const fail = () => process.exit(1)
+
+const help = () => console.log(
+`SemVer ${version}
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, prerelease, or release.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+-n <base>
+        Base number to be used for the prerelease identifier.
+        Can be either 0 or 1, or false to omit the number altogether.
+        Defaults to 0.
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.`)
+
+main()

frontend-admin/node_modules/@expo/config/node_modules/semver/classes/comparator.js

@@ -0,0 +1,143 @@
+'use strict'
+
+const ANY = Symbol('SemVer ANY')
+// hoisted class for cyclic dependency
+class Comparator {
+  static get ANY () {
+    return ANY
+  }
+
+  constructor (comp, options) {
+    options = parseOptions(options)
+
+    if (comp instanceof Comparator) {
+      if (comp.loose === !!options.loose) {
+        return comp
+      } else {
+        comp = comp.value
+      }
+    }
+
+    comp = comp.trim().split(/\s+/).join(' ')
+    debug('comparator', comp, options)
+    this.options = options
+    this.loose = !!options.loose
+    this.parse(comp)
+
+    if (this.semver === ANY) {
+      this.value = ''
+    } else {
+      this.value = this.operator + this.semver.version
+    }
+
+    debug('comp', this)
+  }
+
+  parse (comp) {
+    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
+    const m = comp.match(r)
+
+    if (!m) {
+      throw new TypeError(`Invalid comparator: ${comp}`)
+    }
+
+    this.operator = m[1] !== undefined ? m[1] : ''
+    if (this.operator === '=') {
+      this.operator = ''
+    }
+
+    // if it literally is just '>' or '' then allow anything.
+    if (!m[2]) {
+      this.semver = ANY
+    } else {
+      this.semver = new SemVer(m[2], this.options.loose)
+    }
+  }
+
+  toString () {
+    return this.value
+  }
+
+  test (version) {
+    debug('Comparator.test', version, this.options.loose)
+
+    if (this.semver === ANY || version === ANY) {
+      return true
+    }
+
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options)
+      } catch (er) {
+        return false
+      }
+    }
+
+    return cmp(version, this.operator, this.semver, this.options)
+  }
+
+  intersects (comp, options) {
+    if (!(comp instanceof Comparator)) {
+      throw new TypeError('a Comparator is required')
+    }
+
+    if (this.operator === '') {
+      if (this.value === '') {
+        return true
+      }
+      return new Range(comp.value, options).test(this.value)
+    } else if (comp.operator === '') {
+      if (comp.value === '') {
+        return true
+      }
+      return new Range(this.value, options).test(comp.semver)
+    }
+
+    options = parseOptions(options)
+
+    // Special cases where nothing can possibly be lower
+    if (options.includePrerelease &&
+      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
+      return false
+    }
+    if (!options.includePrerelease &&
+      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
+      return false
+    }
+
+    // Same direction increasing (> or >=)
+    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
+      return true
+    }
+    // Same direction decreasing (< or <=)
+    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
+      return true
+    }
+    // same SemVer and both sides are inclusive (<= or >=)
+    if (
+      (this.semver.version === comp.semver.version) &&
+      this.operator.includes('=') && comp.operator.includes('=')) {
+      return true
+    }
+    // opposite directions less than
+    if (cmp(this.semver, '<', comp.semver, options) &&
+      this.operator.startsWith('>') && comp.operator.startsWith('<')) {
+      return true
+    }
+    // opposite directions greater than
+    if (cmp(this.semver, '>', comp.semver, options) &&
+      this.operator.startsWith('<') && comp.operator.startsWith('>')) {
+      return true
+    }
+    return false
+  }
+}
+
+module.exports = Comparator
+
+const parseOptions = require('../internal/parse-options')
+const { safeRe: re, t } = require('../internal/re')
+const cmp = require('../functions/cmp')
+const debug = require('../internal/debug')
+const SemVer = require('./semver')
+const Range = require('./range')

frontend-admin/node_modules/@expo/config/node_modules/semver/classes/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+module.exports = {
+  SemVer: require('./semver.js'),
+  Range: require('./range.js'),
+  Comparator: require('./comparator.js'),
+}

frontend-admin/node_modules/@expo/config/node_modules/semver/classes/range.js

@@ -0,0 +1,557 @@
+'use strict'
+
+const SPACE_CHARACTERS = /\s+/g
+
+// hoisted class for cyclic dependency
+class Range {
+  constructor (range, options) {
+    options = parseOptions(options)
+
+    if (range instanceof Range) {
+      if (
+        range.loose === !!options.loose &&
+        range.includePrerelease === !!options.includePrerelease
+      ) {
+        return range
+      } else {
+        return new Range(range.raw, options)
+      }
+    }
+
+    if (range instanceof Comparator) {
+      // just put it in the set and return
+      this.raw = range.value
+      this.set = [[range]]
+      this.formatted = undefined
+      return this
+    }
+
+    this.options = options
+    this.loose = !!options.loose
+    this.includePrerelease = !!options.includePrerelease
+
+    // First reduce all whitespace as much as possible so we do not have to rely
+    // on potentially slow regexes like \s*. This is then stored and used for
+    // future error messages as well.
+    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ')
+
+    // First, split on ||
+    this.set = this.raw
+      .split('||')
+      // map the range to a 2d array of comparators
+      .map(r => this.parseRange(r.trim()))
+      // throw out any comparator lists that are empty
+      // this generally means that it was not a valid range, which is allowed
+      // in loose mode, but will still throw if the WHOLE range is invalid.
+      .filter(c => c.length)
+
+    if (!this.set.length) {
+      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
+    }
+
+    // if we have any that are not the null set, throw out null sets.
+    if (this.set.length > 1) {
+      // keep the first one, in case they're all null sets
+      const first = this.set[0]
+      this.set = this.set.filter(c => !isNullSet(c[0]))
+      if (this.set.length === 0) {
+        this.set = [first]
+      } else if (this.set.length > 1) {
+        // if we have any that are *, then the range is just *
+        for (const c of this.set) {
+          if (c.length === 1 && isAny(c[0])) {
+            this.set = [c]
+            break
+          }
+        }
+      }
+    }
+
+    this.formatted = undefined
+  }
+
+  get range () {
+    if (this.formatted === undefined) {
+      this.formatted = ''
+      for (let i = 0; i < this.set.length; i++) {
+        if (i > 0) {
+          this.formatted += '||'
+        }
+        const comps = this.set[i]
+        for (let k = 0; k < comps.length; k++) {
+          if (k > 0) {
+            this.formatted += ' '
+          }
+          this.formatted += comps[k].toString().trim()
+        }
+      }
+    }
+    return this.formatted
+  }
+
+  format () {
+    return this.range
+  }
+
+  toString () {
+    return this.range
+  }
+
+  parseRange (range) {
+    // memoize range parsing for performance.
+    // this is a very hot path, and fully deterministic.
+    const memoOpts =
+      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
+      (this.options.loose && FLAG_LOOSE)
+    const memoKey = memoOpts + ':' + range
+    const cached = cache.get(memoKey)
+    if (cached) {
+      return cached
+    }
+
+    const loose = this.options.loose
+    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
+    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))
+    debug('hyphen replace', range)
+
+    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
+    debug('comparator trim', range)
+
+    // `~ 1.2.3` => `~1.2.3`
+    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
+    debug('tilde trim', range)
+
+    // `^ 1.2.3` => `^1.2.3`
+    range = range.replace(re[t.CARETTRIM], caretTrimReplace)
+    debug('caret trim', range)
+
+    // At this point, the range is completely trimmed and
+    // ready to be split into comparators.
+
+    let rangeList = range
+      .split(' ')
+      .map(comp => parseComparator(comp, this.options))
+      .join(' ')
+      .split(/\s+/)
+      // >=0.0.0 is equivalent to *
+      .map(comp => replaceGTE0(comp, this.options))
+
+    if (loose) {
+      // in loose mode, throw out any that are not valid comparators
+      rangeList = rangeList.filter(comp => {
+        debug('loose invalid filter', comp, this.options)
+        return !!comp.match(re[t.COMPARATORLOOSE])
+      })
+    }
+    debug('range list', rangeList)
+
+    // if any comparators are the null set, then replace with JUST null set
+    // if more than one comparator, remove any * comparators
+    // also, don't include the same comparator more than once
+    const rangeMap = new Map()
+    const comparators = rangeList.map(comp => new Comparator(comp, this.options))
+    for (const comp of comparators) {
+      if (isNullSet(comp)) {
+        return [comp]
+      }
+      rangeMap.set(comp.value, comp)
+    }
+    if (rangeMap.size > 1 && rangeMap.has('')) {
+      rangeMap.delete('')
+    }
+
+    const result = [...rangeMap.values()]
+    cache.set(memoKey, result)
+    return result
+  }
+
+  intersects (range, options) {
+    if (!(range instanceof Range)) {
+      throw new TypeError('a Range is required')
+    }
+
+    return this.set.some((thisComparators) => {
+      return (
+        isSatisfiable(thisComparators, options) &&
+        range.set.some((rangeComparators) => {
+          return (
+            isSatisfiable(rangeComparators, options) &&
+            thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options)
+              })
+            })
+          )
+        })
+      )
+    })
+  }
+
+  // if ANY of the sets match ALL of its comparators, then pass
+  test (version) {
+    if (!version) {
+      return false
+    }
+
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options)
+      } catch (er) {
+        return false
+      }
+    }
+
+    for (let i = 0; i < this.set.length; i++) {
+      if (testSet(this.set[i], version, this.options)) {
+        return true
+      }
+    }
+    return false
+  }
+}
+
+module.exports = Range
+
+const LRU = require('../internal/lrucache')
+const cache = new LRU()
+
+const parseOptions = require('../internal/parse-options')
+const Comparator = require('./comparator')
+const debug = require('../internal/debug')
+const SemVer = require('./semver')
+const {
+  safeRe: re,
+  t,
+  comparatorTrimReplace,
+  tildeTrimReplace,
+  caretTrimReplace,
+} = require('../internal/re')
+const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require('../internal/constants')
+
+const isNullSet = c => c.value === '<0.0.0-0'
+const isAny = c => c.value === ''
+
+// take a set of comparators and determine whether there
+// exists a version which can satisfy it
+const isSatisfiable = (comparators, options) => {
+  let result = true
+  const remainingComparators = comparators.slice()
+  let testComparator = remainingComparators.pop()
+
+  while (result && remainingComparators.length) {
+    result = remainingComparators.every((otherComparator) => {
+      return testComparator.intersects(otherComparator, options)
+    })
+
+    testComparator = remainingComparators.pop()
+  }
+
+  return result
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+const parseComparator = (comp, options) => {
+  comp = comp.replace(re[t.BUILD], '')
+  debug('comp', comp, options)
+  comp = replaceCarets(comp, options)
+  debug('caret', comp)
+  comp = replaceTildes(comp, options)
+  debug('tildes', comp)
+  comp = replaceXRanges(comp, options)
+  debug('xrange', comp)
+  comp = replaceStars(comp, options)
+  debug('stars', comp)
+  return comp
+}
+
+const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+// ~0.0.1 --> >=0.0.1 <0.1.0-0
+const replaceTildes = (comp, options) => {
+  return comp
+    .trim()
+    .split(/\s+/)
+    .map((c) => replaceTilde(c, options))
+    .join(' ')
+}
+
+const replaceTilde = (comp, options) => {
+  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug('tilde', comp, _, M, m, p, pr)
+    let ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
+    } else if (isX(p)) {
+      // ~1.2 == >=1.2.0 <1.3.0-0
+      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
+    } else if (pr) {
+      debug('replaceTilde pr', pr)
+      ret = `>=${M}.${m}.${p}-${pr
+      } <${M}.${+m + 1}.0-0`
+    } else {
+      // ~1.2.3 == >=1.2.3 <1.3.0-0
+      ret = `>=${M}.${m}.${p
+      } <${M}.${+m + 1}.0-0`
+    }
+
+    debug('tilde return', ret)
+    return ret
+  })
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+// ^1.2.3 --> >=1.2.3 <2.0.0-0
+// ^1.2.0 --> >=1.2.0 <2.0.0-0
+// ^0.0.1 --> >=0.0.1 <0.0.2-0
+// ^0.1.0 --> >=0.1.0 <0.2.0-0
+const replaceCarets = (comp, options) => {
+  return comp
+    .trim()
+    .split(/\s+/)
+    .map((c) => replaceCaret(c, options))
+    .join(' ')
+}
+
+const replaceCaret = (comp, options) => {
+  debug('caret', comp, options)
+  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
+  const z = options.includePrerelease ? '-0' : ''
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug('caret', comp, _, M, m, p, pr)
+    let ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
+    } else if (isX(p)) {
+      if (M === '0') {
+        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
+      } else {
+        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`
+      }
+    } else if (pr) {
+      debug('replaceCaret pr', pr)
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${m}.${+p + 1}-0`
+        } else {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${+m + 1}.0-0`
+        }
+      } else {
+        ret = `>=${M}.${m}.${p}-${pr
+        } <${+M + 1}.0.0-0`
+      }
+    } else {
+      debug('no pr')
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${m}.${+p + 1}-0`
+        } else {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${+m + 1}.0-0`
+        }
+      } else {
+        ret = `>=${M}.${m}.${p
+        } <${+M + 1}.0.0-0`
+      }
+    }
+
+    debug('caret return', ret)
+    return ret
+  })
+}
+
+const replaceXRanges = (comp, options) => {
+  debug('replaceXRanges', comp, options)
+  return comp
+    .split(/\s+/)
+    .map((c) => replaceXRange(c, options))
+    .join(' ')
+}
+
+const replaceXRange = (comp, options) => {
+  comp = comp.trim()
+  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
+  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+    debug('xRange', comp, ret, gtlt, M, m, p, pr)
+    const xM = isX(M)
+    const xm = xM || isX(m)
+    const xp = xm || isX(p)
+    const anyX = xp
+
+    if (gtlt === '=' && anyX) {
+      gtlt = ''
+    }
+
+    // if we're including prereleases in the match, then we need
+    // to fix this to -0, the lowest possible prerelease value
+    pr = options.includePrerelease ? '-0' : ''
+
+    if (xM) {
+      if (gtlt === '>' || gtlt === '<') {
+        // nothing is allowed
+        ret = '<0.0.0-0'
+      } else {
+        // nothing is forbidden
+        ret = '*'
+      }
+    } else if (gtlt && anyX) {
+      // we know patch is an x, because we have any x at all.
+      // replace X with 0
+      if (xm) {
+        m = 0
+      }
+      p = 0
+
+      if (gtlt === '>') {
+        // >1 => >=2.0.0
+        // >1.2 => >=1.3.0
+        gtlt = '>='
+        if (xm) {
+          M = +M + 1
+          m = 0
+          p = 0
+        } else {
+          m = +m + 1
+          p = 0
+        }
+      } else if (gtlt === '<=') {
+        // <=0.7.x is actually <0.8.0, since any 0.7.x should
+        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+        gtlt = '<'
+        if (xm) {
+          M = +M + 1
+        } else {
+          m = +m + 1
+        }
+      }
+
+      if (gtlt === '<') {
+        pr = '-0'
+      }
+
+      ret = `${gtlt + M}.${m}.${p}${pr}`
+    } else if (xm) {
+      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`
+    } else if (xp) {
+      ret = `>=${M}.${m}.0${pr
+      } <${M}.${+m + 1}.0-0`
+    }
+
+    debug('xRange return', ret)
+
+    return ret
+  })
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+const replaceStars = (comp, options) => {
+  debug('replaceStars', comp, options)
+  // Looseness is ignored here.  star is always as loose as it gets!
+  return comp
+    .trim()
+    .replace(re[t.STAR], '')
+}
+
+const replaceGTE0 = (comp, options) => {
+  debug('replaceGTE0', comp, options)
+  return comp
+    .trim()
+    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
+}
+
+// This function is passed to string.replace(re[t.HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
+// TODO build?
+const hyphenReplace = incPr => ($0,
+  from, fM, fm, fp, fpr, fb,
+  to, tM, tm, tp, tpr) => {
+  if (isX(fM)) {
+    from = ''
+  } else if (isX(fm)) {
+    from = `>=${fM}.0.0${incPr ? '-0' : ''}`
+  } else if (isX(fp)) {
+    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`
+  } else if (fpr) {
+    from = `>=${from}`
+  } else {
+    from = `>=${from}${incPr ? '-0' : ''}`
+  }
+
+  if (isX(tM)) {
+    to = ''
+  } else if (isX(tm)) {
+    to = `<${+tM + 1}.0.0-0`
+  } else if (isX(tp)) {
+    to = `<${tM}.${+tm + 1}.0-0`
+  } else if (tpr) {
+    to = `<=${tM}.${tm}.${tp}-${tpr}`
+  } else if (incPr) {
+    to = `<${tM}.${tm}.${+tp + 1}-0`
+  } else {
+    to = `<=${to}`
+  }
+
+  return `${from} ${to}`.trim()
+}
+
+const testSet = (set, version, options) => {
+  for (let i = 0; i < set.length; i++) {
+    if (!set[i].test(version)) {
+      return false
+    }
+  }
+
+  if (version.prerelease.length && !options.includePrerelease) {
+    // Find the set of versions that are allowed to have prereleases
+    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+    // That should allow `1.2.3-pr.2` to pass.
+    // However, `1.2.4-alpha.notready` should NOT be allowed,
+    // even though it's within the range set by the comparators.
+    for (let i = 0; i < set.length; i++) {
+      debug(set[i].semver)
+      if (set[i].semver === Comparator.ANY) {
+        continue
+      }
+
+      if (set[i].semver.prerelease.length > 0) {
+        const allowed = set[i].semver
+        if (allowed.major === version.major &&
+            allowed.minor === version.minor &&
+            allowed.patch === version.patch) {
+          return true
+        }
+      }
+    }
+
+    // Version has a -pre, but it's not one of the ones we like.
+    return false
+  }
+
+  return true
+}

frontend-admin/node_modules/@expo/config/node_modules/semver/classes/semver.js

@@ -0,0 +1,333 @@
+'use strict'
+
+const debug = require('../internal/debug')
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')
+const { safeRe: re, t } = require('../internal/re')
+
+const parseOptions = require('../internal/parse-options')
+const { compareIdentifiers } = require('../internal/identifiers')
+class SemVer {
+  constructor (version, options) {
+    options = parseOptions(options)
+
+    if (version instanceof SemVer) {
+      if (version.loose === !!options.loose &&
+        version.includePrerelease === !!options.includePrerelease) {
+        return version
+      } else {
+        version = version.version
+      }
+    } else if (typeof version !== 'string') {
+      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
+    }
+
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH} characters`
+      )
+    }
+
+    debug('SemVer', version, options)
+    this.options = options
+    this.loose = !!options.loose
+    // this isn't actually relevant for versions, but keep it so that we
+    // don't run into trouble passing this.options around.
+    this.includePrerelease = !!options.includePrerelease
+
+    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
+
+    if (!m) {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
+
+    this.raw = version
+
+    // these are actually numbers
+    this.major = +m[1]
+    this.minor = +m[2]
+    this.patch = +m[3]
+
+    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+      throw new TypeError('Invalid major version')
+    }
+
+    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+      throw new TypeError('Invalid minor version')
+    }
+
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError('Invalid patch version')
+    }
+
+    // numberify any prerelease numeric ids
+    if (!m[4]) {
+      this.prerelease = []
+    } else {
+      this.prerelease = m[4].split('.').map((id) => {
+        if (/^[0-9]+$/.test(id)) {
+          const num = +id
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num
+          }
+        }
+        return id
+      })
+    }
+
+    this.build = m[5] ? m[5].split('.') : []
+    this.format()
+  }
+
+  format () {
+    this.version = `${this.major}.${this.minor}.${this.patch}`
+    if (this.prerelease.length) {
+      this.version += `-${this.prerelease.join('.')}`
+    }
+    return this.version
+  }
+
+  toString () {
+    return this.version
+  }
+
+  compare (other) {
+    debug('SemVer.compare', this.version, this.options, other)
+    if (!(other instanceof SemVer)) {
+      if (typeof other === 'string' && other === this.version) {
+        return 0
+      }
+      other = new SemVer(other, this.options)
+    }
+
+    if (other.version === this.version) {
+      return 0
+    }
+
+    return this.compareMain(other) || this.comparePre(other)
+  }
+
+  compareMain (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    if (this.major < other.major) {
+      return -1
+    }
+    if (this.major > other.major) {
+      return 1
+    }
+    if (this.minor < other.minor) {
+      return -1
+    }
+    if (this.minor > other.minor) {
+      return 1
+    }
+    if (this.patch < other.patch) {
+      return -1
+    }
+    if (this.patch > other.patch) {
+      return 1
+    }
+    return 0
+  }
+
+  comparePre (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    // NOT having a prerelease is > having one
+    if (this.prerelease.length && !other.prerelease.length) {
+      return -1
+    } else if (!this.prerelease.length && other.prerelease.length) {
+      return 1
+    } else if (!this.prerelease.length && !other.prerelease.length) {
+      return 0
+    }
+
+    let i = 0
+    do {
+      const a = this.prerelease[i]
+      const b = other.prerelease[i]
+      debug('prerelease compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  compareBuild (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    let i = 0
+    do {
+      const a = this.build[i]
+      const b = other.build[i]
+      debug('build compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  inc (release, identifier, identifierBase) {
+    if (release.startsWith('pre')) {
+      if (!identifier && identifierBase === false) {
+        throw new Error('invalid increment argument: identifier is empty')
+      }
+      // Avoid an invalid semver results
+      if (identifier) {
+        const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE])
+        if (!match || match[1] !== identifier) {
+          throw new Error(`invalid identifier: ${identifier}`)
+        }
+      }
+    }
+
+    switch (release) {
+      case 'premajor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor = 0
+        this.major++
+        this.inc('pre', identifier, identifierBase)
+        break
+      case 'preminor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor++
+        this.inc('pre', identifier, identifierBase)
+        break
+      case 'prepatch':
+        // If this is already a prerelease, it will bump to the next version
+        // drop any prereleases that might already exist, since they are not
+        // relevant at this point.
+        this.prerelease.length = 0
+        this.inc('patch', identifier, identifierBase)
+        this.inc('pre', identifier, identifierBase)
+        break
+      // If the input is a non-prerelease version, this acts the same as
+      // prepatch.
+      case 'prerelease':
+        if (this.prerelease.length === 0) {
+          this.inc('patch', identifier, identifierBase)
+        }
+        this.inc('pre', identifier, identifierBase)
+        break
+      case 'release':
+        if (this.prerelease.length === 0) {
+          throw new Error(`version ${this.raw} is not a prerelease`)
+        }
+        this.prerelease.length = 0
+        break
+
+      case 'major':
+        // If this is a pre-major version, bump up to the same major version.
+        // Otherwise increment major.
+        // 1.0.0-5 bumps to 1.0.0
+        // 1.1.0 bumps to 2.0.0
+        if (
+          this.minor !== 0 ||
+          this.patch !== 0 ||
+          this.prerelease.length === 0
+        ) {
+          this.major++
+        }
+        this.minor = 0
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'minor':
+        // If this is a pre-minor version, bump up to the same minor version.
+        // Otherwise increment minor.
+        // 1.2.0-5 bumps to 1.2.0
+        // 1.2.1 bumps to 1.3.0
+        if (this.patch !== 0 || this.prerelease.length === 0) {
+          this.minor++
+        }
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'patch':
+        // If this is not a pre-release version, it will increment the patch.
+        // If it is a pre-release it will bump up to the same patch version.
+        // 1.2.0-5 patches to 1.2.0
+        // 1.2.0 patches to 1.2.1
+        if (this.prerelease.length === 0) {
+          this.patch++
+        }
+        this.prerelease = []
+        break
+      // This probably shouldn't be used publicly.
+      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+      case 'pre': {
+        const base = Number(identifierBase) ? 1 : 0
+
+        if (this.prerelease.length === 0) {
+          this.prerelease = [base]
+        } else {
+          let i = this.prerelease.length
+          while (--i >= 0) {
+            if (typeof this.prerelease[i] === 'number') {
+              this.prerelease[i]++
+              i = -2
+            }
+          }
+          if (i === -1) {
+            // didn't increment anything
+            if (identifier === this.prerelease.join('.') && identifierBase === false) {
+              throw new Error('invalid increment argument: identifier already exists')
+            }
+            this.prerelease.push(base)
+          }
+        }
+        if (identifier) {
+          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+          let prerelease = [identifier, base]
+          if (identifierBase === false) {
+            prerelease = [identifier]
+          }
+          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = prerelease
+            }
+          } else {
+            this.prerelease = prerelease
+          }
+        }
+        break
+      }
+      default:
+        throw new Error(`invalid increment argument: ${release}`)
+    }
+    this.raw = this.format()
+    if (this.build.length) {
+      this.raw += `+${this.build.join('.')}`
+    }
+    return this
+  }
+}
+
+module.exports = SemVer

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/clean.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const parse = require('./parse')
+const clean = (version, options) => {
+  const s = parse(version.trim().replace(/^[=v]+/, ''), options)
+  return s ? s.version : null
+}
+module.exports = clean

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/cmp.js

@@ -0,0 +1,54 @@
+'use strict'
+
+const eq = require('./eq')
+const neq = require('./neq')
+const gt = require('./gt')
+const gte = require('./gte')
+const lt = require('./lt')
+const lte = require('./lte')
+
+const cmp = (a, op, b, loose) => {
+  switch (op) {
+    case '===':
+      if (typeof a === 'object') {
+        a = a.version
+      }
+      if (typeof b === 'object') {
+        b = b.version
+      }
+      return a === b
+
+    case '!==':
+      if (typeof a === 'object') {
+        a = a.version
+      }
+      if (typeof b === 'object') {
+        b = b.version
+      }
+      return a !== b
+
+    case '':
+    case '=':
+    case '==':
+      return eq(a, b, loose)
+
+    case '!=':
+      return neq(a, b, loose)
+
+    case '>':
+      return gt(a, b, loose)
+
+    case '>=':
+      return gte(a, b, loose)
+
+    case '<':
+      return lt(a, b, loose)
+
+    case '<=':
+      return lte(a, b, loose)
+
+    default:
+      throw new TypeError(`Invalid operator: ${op}`)
+  }
+}
+module.exports = cmp

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/coerce.js

@@ -0,0 +1,62 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const parse = require('./parse')
+const { safeRe: re, t } = require('../internal/re')
+
+const coerce = (version, options) => {
+  if (version instanceof SemVer) {
+    return version
+  }
+
+  if (typeof version === 'number') {
+    version = String(version)
+  }
+
+  if (typeof version !== 'string') {
+    return null
+  }
+
+  options = options || {}
+
+  let match = null
+  if (!options.rtl) {
+    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE])
+  } else {
+    // Find the right-most coercible string that does not share
+    // a terminus with a more left-ward coercible string.
+    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+    // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'
+    //
+    // Walk through the string checking with a /g regexp
+    // Manually set the index so as to pick up overlapping matches.
+    // Stop when we get a match that ends at the string end, since no
+    // coercible string can be more right-ward without the same terminus.
+    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]
+    let next
+    while ((next = coerceRtlRegex.exec(version)) &&
+        (!match || match.index + match[0].length !== version.length)
+    ) {
+      if (!match ||
+            next.index + next[0].length !== match.index + match[0].length) {
+        match = next
+      }
+      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length
+    }
+    // leave it in a clean state
+    coerceRtlRegex.lastIndex = -1
+  }
+
+  if (match === null) {
+    return null
+  }
+
+  const major = match[2]
+  const minor = match[3] || '0'
+  const patch = match[4] || '0'
+  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ''
+  const build = options.includePrerelease && match[6] ? `+${match[6]}` : ''
+
+  return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options)
+}
+module.exports = coerce

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/compare-build.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const compareBuild = (a, b, loose) => {
+  const versionA = new SemVer(a, loose)
+  const versionB = new SemVer(b, loose)
+  return versionA.compare(versionB) || versionA.compareBuild(versionB)
+}
+module.exports = compareBuild

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/compare-loose.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const compareLoose = (a, b) => compare(a, b, true)
+module.exports = compareLoose

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/compare.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const compare = (a, b, loose) =>
+  new SemVer(a, loose).compare(new SemVer(b, loose))
+
+module.exports = compare

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/diff.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const parse = require('./parse.js')
+
+const diff = (version1, version2) => {
+  const v1 = parse(version1, null, true)
+  const v2 = parse(version2, null, true)
+  const comparison = v1.compare(v2)
+
+  if (comparison === 0) {
+    return null
+  }
+
+  const v1Higher = comparison > 0
+  const highVersion = v1Higher ? v1 : v2
+  const lowVersion = v1Higher ? v2 : v1
+  const highHasPre = !!highVersion.prerelease.length
+  const lowHasPre = !!lowVersion.prerelease.length
+
+  if (lowHasPre && !highHasPre) {
+    // Going from prerelease -> no prerelease requires some special casing
+
+    // If the low version has only a major, then it will always be a major
+    // Some examples:
+    // 1.0.0-1 -> 1.0.0
+    // 1.0.0-1 -> 1.1.1
+    // 1.0.0-1 -> 2.0.0
+    if (!lowVersion.patch && !lowVersion.minor) {
+      return 'major'
+    }
+
+    // If the main part has no difference
+    if (lowVersion.compareMain(highVersion) === 0) {
+      if (lowVersion.minor && !lowVersion.patch) {
+        return 'minor'
+      }
+      return 'patch'
+    }
+  }
+
+  // add the `pre` prefix if we are going to a prerelease version
+  const prefix = highHasPre ? 'pre' : ''
+
+  if (v1.major !== v2.major) {
+    return prefix + 'major'
+  }
+
+  if (v1.minor !== v2.minor) {
+    return prefix + 'minor'
+  }
+
+  if (v1.patch !== v2.patch) {
+    return prefix + 'patch'
+  }
+
+  // high and low are preleases
+  return 'prerelease'
+}
+
+module.exports = diff

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/eq.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const eq = (a, b, loose) => compare(a, b, loose) === 0
+module.exports = eq

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/gt.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const gt = (a, b, loose) => compare(a, b, loose) > 0
+module.exports = gt

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/gte.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const gte = (a, b, loose) => compare(a, b, loose) >= 0
+module.exports = gte

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/inc.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+
+const inc = (version, release, options, identifier, identifierBase) => {
+  if (typeof (options) === 'string') {
+    identifierBase = identifier
+    identifier = options
+    options = undefined
+  }
+
+  try {
+    return new SemVer(
+      version instanceof SemVer ? version.version : version,
+      options
+    ).inc(release, identifier, identifierBase).version
+  } catch (er) {
+    return null
+  }
+}
+module.exports = inc

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/lt.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const lt = (a, b, loose) => compare(a, b, loose) < 0
+module.exports = lt

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/lte.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const lte = (a, b, loose) => compare(a, b, loose) <= 0
+module.exports = lte

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/major.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const major = (a, loose) => new SemVer(a, loose).major
+module.exports = major

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/minor.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const minor = (a, loose) => new SemVer(a, loose).minor
+module.exports = minor

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/neq.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const neq = (a, b, loose) => compare(a, b, loose) !== 0
+module.exports = neq

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/parse.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const parse = (version, options, throwErrors = false) => {
+  if (version instanceof SemVer) {
+    return version
+  }
+  try {
+    return new SemVer(version, options)
+  } catch (er) {
+    if (!throwErrors) {
+      return null
+    }
+    throw er
+  }
+}
+
+module.exports = parse

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/patch.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const patch = (a, loose) => new SemVer(a, loose).patch
+module.exports = patch

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/prerelease.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const parse = require('./parse')
+const prerelease = (version, options) => {
+  const parsed = parse(version, options)
+  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+}
+module.exports = prerelease

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/rcompare.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compare = require('./compare')
+const rcompare = (a, b, loose) => compare(b, a, loose)
+module.exports = rcompare

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/rsort.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compareBuild = require('./compare-build')
+const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
+module.exports = rsort

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/satisfies.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const Range = require('../classes/range')
+const satisfies = (version, range, options) => {
+  try {
+    range = new Range(range, options)
+  } catch (er) {
+    return false
+  }
+  return range.test(version)
+}
+module.exports = satisfies

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/sort.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const compareBuild = require('./compare-build')
+const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
+module.exports = sort

frontend-admin/node_modules/@expo/config/node_modules/semver/functions/valid.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const parse = require('./parse')
+const valid = (version, options) => {
+  const v = parse(version, options)
+  return v ? v.version : null
+}
+module.exports = valid

frontend-admin/node_modules/@expo/config/node_modules/semver/index.js

@@ -0,0 +1,91 @@
+'use strict'
+
+// just pre-load all the stuff that index.js lazily exports
+const internalRe = require('./internal/re')
+const constants = require('./internal/constants')
+const SemVer = require('./classes/semver')
+const identifiers = require('./internal/identifiers')
+const parse = require('./functions/parse')
+const valid = require('./functions/valid')
+const clean = require('./functions/clean')
+const inc = require('./functions/inc')
+const diff = require('./functions/diff')
+const major = require('./functions/major')
+const minor = require('./functions/minor')
+const patch = require('./functions/patch')
+const prerelease = require('./functions/prerelease')
+const compare = require('./functions/compare')
+const rcompare = require('./functions/rcompare')
+const compareLoose = require('./functions/compare-loose')
+const compareBuild = require('./functions/compare-build')
+const sort = require('./functions/sort')
+const rsort = require('./functions/rsort')
+const gt = require('./functions/gt')
+const lt = require('./functions/lt')
+const eq = require('./functions/eq')
+const neq = require('./functions/neq')
+const gte = require('./functions/gte')
+const lte = require('./functions/lte')
+const cmp = require('./functions/cmp')
+const coerce = require('./functions/coerce')
+const Comparator = require('./classes/comparator')
+const Range = require('./classes/range')
+const satisfies = require('./functions/satisfies')
+const toComparators = require('./ranges/to-comparators')
+const maxSatisfying = require('./ranges/max-satisfying')
+const minSatisfying = require('./ranges/min-satisfying')
+const minVersion = require('./ranges/min-version')
+const validRange = require('./ranges/valid')
+const outside = require('./ranges/outside')
+const gtr = require('./ranges/gtr')
+const ltr = require('./ranges/ltr')
+const intersects = require('./ranges/intersects')
+const simplifyRange = require('./ranges/simplify')
+const subset = require('./ranges/subset')
+module.exports = {
+  parse,
+  valid,
+  clean,
+  inc,
+  diff,
+  major,
+  minor,
+  patch,
+  prerelease,
+  compare,
+  rcompare,
+  compareLoose,
+  compareBuild,
+  sort,
+  rsort,
+  gt,
+  lt,
+  eq,
+  neq,
+  gte,
+  lte,
+  cmp,
+  coerce,
+  Comparator,
+  Range,
+  satisfies,
+  toComparators,
+  maxSatisfying,
+  minSatisfying,
+  minVersion,
+  validRange,
+  outside,
+  gtr,
+  ltr,
+  intersects,
+  simplifyRange,
+  subset,
+  SemVer,
+  re: internalRe.re,
+  src: internalRe.src,
+  tokens: internalRe.t,
+  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+  RELEASE_TYPES: constants.RELEASE_TYPES,
+  compareIdentifiers: identifiers.compareIdentifiers,
+  rcompareIdentifiers: identifiers.rcompareIdentifiers,
+}

frontend-admin/node_modules/@expo/config/node_modules/semver/internal/constants.js

@@ -0,0 +1,37 @@
+'use strict'
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+const SEMVER_SPEC_VERSION = '2.0.0'
+
+const MAX_LENGTH = 256
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
+/* istanbul ignore next */ 9007199254740991
+
+// Max safe segment length for coercion.
+const MAX_SAFE_COMPONENT_LENGTH = 16
+
+// Max safe length for a build identifier. The max length minus 6 characters for
+// the shortest version with a build 0.0.0+BUILD.
+const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6
+
+const RELEASE_TYPES = [
+  'major',
+  'premajor',
+  'minor',
+  'preminor',
+  'patch',
+  'prepatch',
+  'prerelease',
+]
+
+module.exports = {
+  MAX_LENGTH,
+  MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  MAX_SAFE_INTEGER,
+  RELEASE_TYPES,
+  SEMVER_SPEC_VERSION,
+  FLAG_INCLUDE_PRERELEASE: 0b001,
+  FLAG_LOOSE: 0b010,
+}

frontend-admin/node_modules/@expo/config/node_modules/semver/internal/debug.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const debug = (
+  typeof process === 'object' &&
+  process.env &&
+  process.env.NODE_DEBUG &&
+  /\bsemver\b/i.test(process.env.NODE_DEBUG)
+) ? (...args) => console.error('SEMVER', ...args)
+  : () => {}
+
+module.exports = debug

frontend-admin/node_modules/@expo/config/node_modules/semver/internal/identifiers.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const numeric = /^[0-9]+$/
+const compareIdentifiers = (a, b) => {
+  if (typeof a === 'number' && typeof b === 'number') {
+    return a === b ? 0 : a < b ? -1 : 1
+  }
+
+  const anum = numeric.test(a)
+  const bnum = numeric.test(b)
+
+  if (anum && bnum) {
+    a = +a
+    b = +b
+  }
+
+  return a === b ? 0
+    : (anum && !bnum) ? -1
+    : (bnum && !anum) ? 1
+    : a < b ? -1
+    : 1
+}
+
+const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)
+
+module.exports = {
+  compareIdentifiers,
+  rcompareIdentifiers,
+}

frontend-admin/node_modules/@expo/config/node_modules/semver/internal/lrucache.js

@@ -0,0 +1,42 @@
+'use strict'
+
+class LRUCache {
+  constructor () {
+    this.max = 1000
+    this.map = new Map()
+  }
+
+  get (key) {
+    const value = this.map.get(key)
+    if (value === undefined) {
+      return undefined
+    } else {
+      // Remove the key from the map and add it to the end
+      this.map.delete(key)
+      this.map.set(key, value)
+      return value
+    }
+  }
+
+  delete (key) {
+    return this.map.delete(key)
+  }
+
+  set (key, value) {
+    const deleted = this.delete(key)
+
+    if (!deleted && value !== undefined) {
+      // If cache is full, delete the least recently used item
+      if (this.map.size >= this.max) {
+        const firstKey = this.map.keys().next().value
+        this.delete(firstKey)
+      }
+
+      this.map.set(key, value)
+    }
+
+    return this
+  }
+}
+
+module.exports = LRUCache

frontend-admin/node_modules/@expo/config/node_modules/semver/internal/parse-options.js

@@ -0,0 +1,17 @@
+'use strict'
+
+// parse out just the options we care about
+const looseOption = Object.freeze({ loose: true })
+const emptyOpts = Object.freeze({ })
+const parseOptions = options => {
+  if (!options) {
+    return emptyOpts
+  }
+
+  if (typeof options !== 'object') {
+    return looseOption
+  }
+
+  return options
+}
+module.exports = parseOptions

frontend-admin/node_modules/@expo/config/node_modules/semver/internal/re.js

@@ -0,0 +1,223 @@
+'use strict'
+
+const {
+  MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  MAX_LENGTH,
+} = require('./constants')
+const debug = require('./debug')
+exports = module.exports = {}
+
+// The actual regexps go on exports.re
+const re = exports.re = []
+const safeRe = exports.safeRe = []
+const src = exports.src = []
+const safeSrc = exports.safeSrc = []
+const t = exports.t = {}
+let R = 0
+
+const LETTERDASHNUMBER = '[a-zA-Z0-9-]'
+
+// Replace some greedy regex tokens to prevent regex dos issues. These regex are
+// used internally via the safeRe object since all inputs in this library get
+// normalized first to trim and collapse all extra whitespace. The original
+// regexes are exported for userland consumption and lower level usage. A
+// future breaking change could export the safer regex only with a note that
+// all input should have extra whitespace removed.
+const safeRegexReplacements = [
+  ['\\s', 1],
+  ['\\d', MAX_LENGTH],
+  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
+]
+
+const makeSafeRegex = (value) => {
+  for (const [token, max] of safeRegexReplacements) {
+    value = value
+      .split(`${token}*`).join(`${token}{0,${max}}`)
+      .split(`${token}+`).join(`${token}{1,${max}}`)
+  }
+  return value
+}
+
+const createToken = (name, value, isGlobal) => {
+  const safe = makeSafeRegex(value)
+  const index = R++
+  debug(name, index, value)
+  t[name] = index
+  src[index] = value
+  safeSrc[index] = safe
+  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)
+  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)
+}
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*')
+createToken('NUMERICIDENTIFIERLOOSE', '\\d+')
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})`)
+
+createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+// Non-numberic identifiers include numberic identifiers but can be longer.
+// Therefore non-numberic identifiers must go first.
+
+createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]
+}|${src[t.NUMERICIDENTIFIER]})`)
+
+createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]
+}|${src[t.NUMERICIDENTIFIERLOOSE]})`)
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
+}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`)
+
+createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
+}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
+}(?:\\.${src[t.BUILDIDENTIFIER]})*))`)
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups.  The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
+}${src[t.PRERELEASE]}?${
+  src[t.BUILD]}?`)
+
+createToken('FULL', `^${src[t.FULLPLAIN]}$`)
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
+}${src[t.PRERELEASELOOSE]}?${
+  src[t.BUILD]}?`)
+
+createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
+
+createToken('GTLT', '((?:<|>)?=?)')
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
+createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)
+
+createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:${src[t.PRERELEASE]})?${
+                     src[t.BUILD]}?` +
+                   `)?)?`)
+
+createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:${src[t.PRERELEASELOOSE]})?${
+                          src[t.BUILD]}?` +
+                        `)?)?`)
+
+createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`)
+createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`)
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+createToken('COERCEPLAIN', `${'(^|[^\\d])' +
+              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`)
+createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`)
+createToken('COERCEFULL', src[t.COERCEPLAIN] +
+              `(?:${src[t.PRERELEASE]})?` +
+              `(?:${src[t.BUILD]})?` +
+              `(?:$|[^\\d])`)
+createToken('COERCERTL', src[t.COERCE], true)
+createToken('COERCERTLFULL', src[t.COERCEFULL], true)
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+createToken('LONETILDE', '(?:~>?)')
+
+createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true)
+exports.tildeTrimReplace = '$1~'
+
+createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)
+createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+createToken('LONECARET', '(?:\\^)')
+
+createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true)
+exports.caretTrimReplace = '$1^'
+
+createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)
+createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`)
+createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`)
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
+}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)
+exports.comparatorTrimReplace = '$1$2$3'
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
+                   `\\s+-\\s+` +
+                   `(${src[t.XRANGEPLAIN]})` +
+                   `\\s*$`)
+
+createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s+-\\s+` +
+                        `(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s*$`)
+
+// Star ranges basically just allow anything at all.
+createToken('STAR', '(<|>)?=?\\s*\\*')
+// >=0.0.0 is like a star
+createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$')
+createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$')

frontend-admin/node_modules/@expo/config/node_modules/semver/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "semver",
+  "version": "7.7.3",
+  "description": "The semantic version parser used by npm.",
+  "main": "index.js",
+  "scripts": {
+    "test": "tap",
+    "snap": "tap",
+    "lint": "npm run eslint",
+    "postlint": "template-oss-check",
+    "lintfix": "npm run eslint -- --fix",
+    "posttest": "npm run lint",
+    "template-oss-apply": "template-oss-apply --force",
+    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
+  },
+  "devDependencies": {
+    "@npmcli/eslint-config": "^5.0.0",
+    "@npmcli/template-oss": "4.25.1",
+    "benchmark": "^2.1.4",
+    "tap": "^16.0.0"
+  },
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/node-semver.git"
+  },
+  "bin": {
+    "semver": "bin/semver.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "classes/",
+    "functions/",
+    "internal/",
+    "ranges/",
+    "index.js",
+    "preload.js",
+    "range.bnf"
+  ],
+  "tap": {
+    "timeout": 30,
+    "coverage-map": "map.js",
+    "nyc-arg": [
+      "--exclude",
+      "tap-snapshots/**"
+    ]
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "author": "GitHub Inc.",
+  "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+    "version": "4.25.1",
+    "engines": ">=10",
+    "distPaths": [
+      "classes/",
+      "functions/",
+      "internal/",
+      "ranges/",
+      "index.js",
+      "preload.js",
+      "range.bnf"
+    ],
+    "allowPaths": [
+      "/classes/",
+      "/functions/",
+      "/internal/",
+      "/ranges/",
+      "/index.js",
+      "/preload.js",
+      "/range.bnf",
+      "/benchmarks"
+    ],
+    "publish": "true"
+  }
+}

frontend-admin/node_modules/@expo/config/node_modules/semver/preload.js

@@ -0,0 +1,4 @@
+'use strict'
+
+// XXX remove in v8 or beyond
+module.exports = require('./index.js')

frontend-admin/node_modules/@expo/config/node_modules/semver/range.bnf

@@ -0,0 +1,16 @@
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | [1-9] ( [0-9] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+

frontend-admin/node_modules/@expo/config/node_modules/semver/ranges/gtr.js

@@ -0,0 +1,6 @@
+'use strict'
+
+// Determine if version is greater than all the versions possible in the range.
+const outside = require('./outside')
+const gtr = (version, range, options) => outside(version, range, '>', options)
+module.exports = gtr