@depup/expo__cli 55.0.16-depup.0

package/build/metro-require/require.js

@@ -0,0 +1,608 @@
+'use strict';
+if (__DEV__ || !global[`${__METRO_GLOBAL_PREFIX__}__d`]) {
+    global.__r = metroRequire;
+    global[`${__METRO_GLOBAL_PREFIX__}__d`] = define;
+    global.__c = clear;
+    global.__registerSegment = registerSegment;
+}
+var modules = clear();
+const EMPTY = {};
+const CYCLE_DETECTED = {};
+const { hasOwnProperty } = {};
+if (__DEV__) {
+    global.$RefreshReg$ = global.$RefreshReg$ ?? (()=>{});
+    global.$RefreshSig$ = global.$RefreshSig$ ?? (()=>(type)=>type);
+}
+function clear() {
+    modules = new Map();
+    return modules;
+}
+if (__DEV__) {
+    var initializingModuleIds = [];
+}
+function define(factory, moduleId, dependencyMap) {
+    if (modules.has(moduleId)) {
+        if (__DEV__) {
+            const inverseDependencies = arguments[4];
+            if (inverseDependencies) {
+                global.__accept(moduleId, factory, dependencyMap, inverseDependencies);
+            }
+        }
+        return;
+    }
+    const mod = {
+        dependencyMap,
+        factory,
+        hasError: false,
+        importedAll: EMPTY,
+        importedDefault: EMPTY,
+        isInitialized: false,
+        publicModule: {
+            exports: {}
+        }
+    };
+    modules.set(moduleId, mod);
+    if (__DEV__) {
+        mod.hot = createHotReloadingObject();
+        const verboseName = arguments[3];
+        if (verboseName) {
+            mod.verboseName = verboseName;
+        }
+    }
+}
+function metroRequire(moduleId, moduleIdHint) {
+    if (moduleId === null) {
+        if (__DEV__ && typeof moduleIdHint === 'string') {
+            throw new Error("Cannot find module '" + moduleIdHint + "'");
+        }
+        throw new Error('Cannot find module');
+    }
+    if (__DEV__) {
+        const initializingIndex = initializingModuleIds.indexOf(moduleId);
+        if (initializingIndex !== -1) {
+            const cycle = initializingModuleIds.slice(initializingIndex).map((id)=>{
+                var _modules_get;
+                return ((_modules_get = modules.get(id)) == null ? void 0 : _modules_get.verboseName) ?? '[unknown]';
+            });
+            if (shouldPrintRequireCycle(cycle)) {
+                cycle.push(cycle[0]);
+                console.warn(`Require cycle: ${cycle.join(' -> ')}\n\n` + 'Require cycles are allowed, but can result in uninitialized values. ' + 'Consider refactoring to remove the need for a cycle.');
+            }
+        }
+    }
+    const module = modules.get(moduleId);
+    return module && module.isInitialized ? module.publicModule.exports : guardedLoadModule(moduleId, module, moduleIdHint);
+}
+function shouldPrintRequireCycle(modules) {
+    const rcip = __METRO_GLOBAL_PREFIX__ + '__requireCycleIgnorePatterns';
+    const regExps = globalThis[rcip] ?? global[rcip] ?? [
+        /(^|\/|\\)node_modules($|\/|\\)/
+    ];
+    if (!Array.isArray(regExps)) {
+        return true;
+    }
+    const isIgnored = (module)=>module != null && regExps.some((regExp)=>regExp.test(module));
+    return modules.every((module)=>!isIgnored(module));
+}
+function metroImportDefault(moduleId) {
+    var _modules_get;
+    if (modules.has(moduleId) && ((_modules_get = modules.get(moduleId)) == null ? void 0 : _modules_get.importedDefault) !== EMPTY) {
+        return modules.get(moduleId).importedDefault;
+    }
+    const exports = metroRequire(moduleId);
+    const importedDefault = exports && exports.__esModule ? exports.default : exports;
+    return modules.get(moduleId).importedDefault = importedDefault;
+}
+metroRequire.importDefault = metroImportDefault;
+function metroImportAll(moduleId) {
+    var _modules_get;
+    if (modules.has(moduleId) && ((_modules_get = modules.get(moduleId)) == null ? void 0 : _modules_get.importedAll) !== EMPTY) {
+        return modules.get(moduleId).importedAll;
+    }
+    const exports = metroRequire(moduleId);
+    let importedAll;
+    if (exports && exports.__esModule) {
+        importedAll = exports;
+    } else {
+        importedAll = {};
+        if (exports) {
+            for(const key in exports){
+                if (hasOwnProperty.call(exports, key)) {
+                    importedAll[key] = exports[key];
+                }
+            }
+        }
+        importedAll.default = exports;
+    }
+    return modules.get(moduleId).importedAll = importedAll;
+}
+metroRequire[Symbol.for('expo.require')] = true;
+metroRequire.importAll = metroImportAll;
+metroRequire.context = function fallbackRequireContext() {
+    if (__DEV__) {
+        throw new Error('The experimental Metro feature `require.context` is not enabled in your project.\nThis can be enabled by setting the `transformer.unstable_allowRequireContext` property to `true` in your Metro configuration.');
+    }
+    throw new Error('The experimental Metro feature `require.context` is not enabled in your project.');
+};
+metroRequire.resolveWeak = function fallbackRequireResolveWeak() {
+    if (__DEV__) {
+        throw new Error('require.resolveWeak cannot be called dynamically. Ensure you are using the same version of `metro` and `metro-runtime`.');
+    }
+    throw new Error('require.resolveWeak cannot be called dynamically.');
+};
+metroRequire.unguarded = function requireUnguarded(moduleId, moduleIdHint) {
+    if (__DEV__) {
+        const initializingIndex = initializingModuleIds.indexOf(moduleId);
+        if (initializingIndex !== -1) {
+            const cycle = initializingModuleIds.slice(initializingIndex).map((id)=>{
+                var _modules_get;
+                return ((_modules_get = modules.get(id)) == null ? void 0 : _modules_get.verboseName) ?? '[unknown]';
+            });
+            if (shouldPrintRequireCycle(cycle)) {
+                cycle.push(cycle[0]);
+                console.warn(`Require cycle: ${cycle.join(' -> ')}\n\n` + 'Require cycles are allowed, but can result in uninitialized values. ' + 'Consider refactoring to remove the need for a cycle.');
+            }
+        }
+    }
+    const module = modules.get(moduleId);
+    return module && module.isInitialized ? module.publicModule.exports : loadModuleImplementation(moduleId, module, moduleIdHint);
+};
+let inGuard = false;
+function guardedLoadModule(moduleId, module, moduleIdHint) {
+    if (!inGuard && global.ErrorUtils) {
+        inGuard = true;
+        let returnValue;
+        try {
+            returnValue = loadModuleImplementation(moduleId, module, moduleIdHint);
+        } catch (e) {
+            global.ErrorUtils.reportFatalError(e);
+        }
+        inGuard = false;
+        return returnValue;
+    } else {
+        return loadModuleImplementation(moduleId, module, moduleIdHint);
+    }
+}
+const ID_MASK_SHIFT = 16;
+const LOCAL_ID_MASK = ~0 >>> ID_MASK_SHIFT;
+function unpackModuleId(moduleId) {
+    if (typeof moduleId !== 'number') {
+        throw new Error('Module ID must be a number in unpackModuleId.');
+    }
+    const segmentId = moduleId >>> ID_MASK_SHIFT;
+    const localId = moduleId & LOCAL_ID_MASK;
+    return {
+        segmentId,
+        localId
+    };
+}
+metroRequire.unpackModuleId = unpackModuleId;
+function packModuleId(value) {
+    return (value.segmentId << ID_MASK_SHIFT) + value.localId;
+}
+metroRequire.packModuleId = packModuleId;
+const moduleDefinersBySegmentID = [];
+const definingSegmentByModuleID = new Map();
+function registerSegment(segmentId, moduleDefiner, moduleIds) {
+    moduleDefinersBySegmentID[segmentId] = moduleDefiner;
+    if (__DEV__) {
+        if (segmentId === 0 && moduleIds) {
+            throw new Error('registerSegment: Expected moduleIds to be null for main segment');
+        }
+        if (segmentId !== 0 && !moduleIds) {
+            throw new Error('registerSegment: Expected moduleIds to be passed for segment #' + segmentId);
+        }
+    }
+    if (moduleIds) {
+        moduleIds.forEach((moduleId)=>{
+            if (!modules.has(moduleId) && !definingSegmentByModuleID.has(moduleId)) {
+                definingSegmentByModuleID.set(moduleId, segmentId);
+            }
+        });
+    }
+}
+function loadModuleImplementation(moduleId, module, moduleIdHint) {
+    if (!module && moduleDefinersBySegmentID.length > 0) {
+        const segmentId = definingSegmentByModuleID.get(moduleId) ?? 0;
+        const definer = moduleDefinersBySegmentID[segmentId];
+        if (definer != null) {
+            definer(moduleId);
+            module = modules.get(moduleId);
+            definingSegmentByModuleID.delete(moduleId);
+        }
+    }
+    if (!module) {
+        throw unknownModuleError(moduleId, moduleIdHint);
+    }
+    if (module.hasError) {
+        throw module.error;
+    }
+    if (__DEV__) {
+        var Systrace = requireSystrace();
+        var Refresh = requireRefresh();
+    }
+    module.isInitialized = true;
+    const { factory, dependencyMap } = module;
+    if (__DEV__) {
+        initializingModuleIds.push(moduleId);
+    }
+    try {
+        if (__DEV__) {
+            Systrace.beginEvent('JS_require_' + (module.verboseName || moduleId));
+        }
+        const moduleObject = module.publicModule;
+        if (__DEV__) {
+            moduleObject.hot = module.hot;
+            var prevRefreshReg = global.$RefreshReg$;
+            var prevRefreshSig = global.$RefreshSig$;
+            if (Refresh != null) {
+                const RefreshRuntime = Refresh;
+                global.$RefreshReg$ = (type, id)=>{
+                    const prefixedModuleId = __METRO_GLOBAL_PREFIX__ + ' ' + moduleId + ' ' + id;
+                    RefreshRuntime.register(type, prefixedModuleId);
+                };
+                global.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+            }
+        }
+        moduleObject.id = moduleId;
+        factory == null ? void 0 : factory(global, metroRequire, metroImportDefault, metroImportAll, moduleObject, moduleObject.exports, dependencyMap);
+        if (!__DEV__) {
+            module.factory = undefined;
+            module.dependencyMap = undefined;
+        }
+        if (__DEV__) {
+            Systrace.endEvent();
+            if (Refresh != null) {
+                const prefixedModuleId = __METRO_GLOBAL_PREFIX__ + ' ' + moduleId;
+                registerExportsForReactRefresh(Refresh, moduleObject.exports, prefixedModuleId);
+            }
+        }
+        return moduleObject.exports;
+    } catch (e) {
+        module.hasError = true;
+        module.error = e;
+        module.isInitialized = false;
+        module.publicModule.exports = undefined;
+        throw e;
+    } finally{
+        if (__DEV__) {
+            if (initializingModuleIds.pop() !== moduleId) {
+                throw new Error('initializingModuleIds is corrupt; something is terribly wrong');
+            }
+            global.$RefreshReg$ = prevRefreshReg;
+            global.$RefreshSig$ = prevRefreshSig;
+        }
+    }
+}
+function unknownModuleError(id, moduleIdHint) {
+    let message = 'Requiring unknown module "' + (id ?? moduleIdHint ?? `[unknown optional import]`) + '".';
+    if (__DEV__) {
+        message += ' If you are sure the module exists, try restarting Metro. ' + 'You may also want to run `yarn` or `npm install`.';
+    }
+    return Error(message);
+}
+if (__DEV__) {
+    metroRequire.Systrace = {
+        beginEvent: ()=>{},
+        endEvent: ()=>{}
+    };
+    metroRequire.getModules = ()=>{
+        return modules;
+    };
+    var createHotReloadingObject = function() {
+        const hot = {
+            _acceptCallback: null,
+            _disposeCallback: null,
+            _didAccept: false,
+            accept: (callback)=>{
+                hot._didAccept = true;
+                hot._acceptCallback = callback;
+            },
+            dispose: (callback)=>{
+                hot._disposeCallback = callback;
+            }
+        };
+        return hot;
+    };
+    let reactRefreshTimeout = null;
+    const metroHotUpdateModule = function(id, factory, dependencyMap, inverseDependencies) {
+        const mod = modules.get(id);
+        if (!mod) {
+            if (factory) {
+                return;
+            }
+            throw unknownModuleError(id);
+        }
+        if (!mod.hasError && !mod.isInitialized) {
+            mod.factory = factory;
+            mod.dependencyMap = dependencyMap;
+            return;
+        }
+        const Refresh = requireRefresh();
+        const refreshBoundaryIDs = new Set();
+        let didBailOut = false;
+        let updatedModuleIDs;
+        try {
+            updatedModuleIDs = topologicalSort([
+                id
+            ], (pendingID)=>{
+                const pendingModule = modules.get(pendingID);
+                if (pendingModule == null) {
+                    return [];
+                }
+                const pendingHot = pendingModule.hot;
+                if (pendingHot == null) {
+                    throw new Error('[Refresh] Expected module.hot to always exist in DEV.');
+                }
+                let canAccept = pendingHot._didAccept;
+                if (!canAccept && Refresh != null) {
+                    const isBoundary = isReactRefreshBoundary(Refresh, pendingModule.publicModule.exports);
+                    if (isBoundary) {
+                        canAccept = true;
+                        refreshBoundaryIDs.add(pendingID);
+                    }
+                }
+                if (canAccept) {
+                    return [];
+                }
+                const parentIDs = inverseDependencies[pendingID];
+                if (parentIDs.length === 0) {
+                    performFullRefresh('No root boundary', {
+                        source: mod,
+                        failed: pendingModule
+                    });
+                    didBailOut = true;
+                    return [];
+                }
+                return parentIDs;
+            }, ()=>didBailOut).reverse();
+        } catch (e) {
+            if (e === CYCLE_DETECTED) {
+                performFullRefresh('Dependency cycle', {
+                    source: mod
+                });
+                return;
+            }
+            throw e;
+        }
+        if (didBailOut) {
+            return;
+        }
+        const seenModuleIDs = new Set();
+        for(let i = 0; i < updatedModuleIDs.length; i++){
+            const updatedID = updatedModuleIDs[i];
+            if (seenModuleIDs.has(updatedID)) {
+                continue;
+            }
+            seenModuleIDs.add(updatedID);
+            const updatedMod = modules.get(updatedID);
+            if (updatedMod == null) {
+                throw new Error('[Refresh] Expected to find the updated module.');
+            }
+            const prevExports = updatedMod.publicModule.exports;
+            const didError = runUpdatedModule(updatedID, updatedID === id ? factory : undefined, updatedID === id ? dependencyMap : undefined);
+            const nextExports = updatedMod.publicModule.exports;
+            if (didError) {
+                return;
+            }
+            if (refreshBoundaryIDs.has(updatedID)) {
+                const isNoLongerABoundary = !isReactRefreshBoundary(Refresh, nextExports);
+                const didInvalidate = shouldInvalidateReactRefreshBoundary(Refresh, prevExports, nextExports);
+                if (isNoLongerABoundary || didInvalidate) {
+                    const parentIDs = inverseDependencies[updatedID];
+                    if (parentIDs.length === 0) {
+                        performFullRefresh(isNoLongerABoundary ? 'No longer a boundary' : 'Invalidated boundary', {
+                            source: mod,
+                            failed: updatedMod
+                        });
+                        return;
+                    }
+                    for(let j = 0; j < parentIDs.length; j++){
+                        const parentID = parentIDs[j];
+                        const parentMod = modules.get(parentID);
+                        if (parentMod == null) {
+                            throw new Error('[Refresh] Expected to find parent module.');
+                        }
+                        const canAcceptParent = isReactRefreshBoundary(Refresh, parentMod.publicModule.exports);
+                        if (canAcceptParent) {
+                            refreshBoundaryIDs.add(parentID);
+                            updatedModuleIDs.push(parentID);
+                        } else {
+                            performFullRefresh('Invalidated boundary', {
+                                source: mod,
+                                failed: parentMod
+                            });
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        if (Refresh != null) {
+            if (reactRefreshTimeout == null) {
+                reactRefreshTimeout = setTimeout(()=>{
+                    reactRefreshTimeout = null;
+                    Refresh.performReactRefresh();
+                }, 30);
+            }
+        }
+    };
+    const topologicalSort = function(roots, getEdges, earlyStop) {
+        const result = [];
+        const visited = new Set();
+        const stack = new Set();
+        function traverseDependentNodes(node) {
+            if (stack.has(node)) {
+                throw CYCLE_DETECTED;
+            }
+            if (visited.has(node)) {
+                return;
+            }
+            visited.add(node);
+            stack.add(node);
+            const dependentNodes = getEdges(node);
+            if (earlyStop(node)) {
+                stack.delete(node);
+                return;
+            }
+            dependentNodes.forEach((dependent)=>{
+                traverseDependentNodes(dependent);
+            });
+            stack.delete(node);
+            result.push(node);
+        }
+        roots.forEach((root)=>{
+            traverseDependentNodes(root);
+        });
+        return result;
+    };
+    const runUpdatedModule = function(id, factory, dependencyMap) {
+        const mod = modules.get(id);
+        if (mod == null) {
+            throw new Error('[Refresh] Expected to find the module.');
+        }
+        const { hot } = mod;
+        if (!hot) {
+            throw new Error('[Refresh] Expected module.hot to always exist in DEV.');
+        }
+        if (hot._disposeCallback) {
+            try {
+                hot._disposeCallback();
+            } catch (error) {
+                console.error(`Error while calling dispose handler for module ${id}: `, error);
+            }
+        }
+        if (factory) {
+            mod.factory = factory;
+        }
+        if (dependencyMap) {
+            mod.dependencyMap = dependencyMap;
+        }
+        mod.hasError = false;
+        mod.error = undefined;
+        mod.importedAll = EMPTY;
+        mod.importedDefault = EMPTY;
+        mod.isInitialized = false;
+        const prevExports = mod.publicModule.exports;
+        mod.publicModule.exports = {};
+        hot._didAccept = false;
+        hot._acceptCallback = null;
+        hot._disposeCallback = null;
+        metroRequire(id);
+        if (mod.hasError) {
+            mod.hasError = false;
+            mod.isInitialized = true;
+            mod.error = null;
+            mod.publicModule.exports = prevExports;
+            return true;
+        }
+        if (hot._acceptCallback) {
+            try {
+                hot._acceptCallback();
+            } catch (error) {
+                console.error(`Error while calling accept handler for module ${id}: `, error);
+            }
+        }
+        return false;
+    };
+    const performFullRefresh = (reason, modules)=>{
+        if (typeof window !== 'undefined' && window.location != null && typeof window.location.reload === 'function') {
+            window.location.reload();
+        } else {
+            const Refresh = requireRefresh();
+            if (Refresh != null) {
+                var _modules_source, _modules_failed;
+                const sourceName = ((_modules_source = modules.source) == null ? void 0 : _modules_source.verboseName) ?? 'unknown';
+                const failedName = ((_modules_failed = modules.failed) == null ? void 0 : _modules_failed.verboseName) ?? 'unknown';
+                Refresh.performFullRefresh(`Fast Refresh - ${reason} <${sourceName}> <${failedName}>`);
+            } else {
+                console.warn('Could not reload the application after an edit.');
+            }
+        }
+    };
+    var isSpecifierSafeToCheck = (moduleExports, key)=>{
+        if (moduleExports && moduleExports.__esModule) {
+            return true;
+        } else {
+            const desc = Object.getOwnPropertyDescriptor(moduleExports, key);
+            return !desc || !desc.get;
+        }
+    };
+    var isReactRefreshBoundary = function(Refresh, moduleExports) {
+        if (Refresh.isLikelyComponentType(moduleExports)) {
+            return true;
+        }
+        if (moduleExports == null || typeof moduleExports !== 'object') {
+            return false;
+        }
+        let hasExports = false;
+        let areAllExportsComponents = true;
+        for(const key in moduleExports){
+            hasExports = true;
+            if (key === '__esModule') {
+                continue;
+            } else if (!isSpecifierSafeToCheck(moduleExports, key)) {
+                return false;
+            }
+            const exportValue = moduleExports[key];
+            if (!Refresh.isLikelyComponentType(exportValue)) {
+                areAllExportsComponents = false;
+            }
+        }
+        return hasExports && areAllExportsComponents;
+    };
+    var shouldInvalidateReactRefreshBoundary = (Refresh, prevExports, nextExports)=>{
+        const prevSignature = getRefreshBoundarySignature(Refresh, prevExports);
+        const nextSignature = getRefreshBoundarySignature(Refresh, nextExports);
+        if (prevSignature.length !== nextSignature.length) {
+            return true;
+        }
+        for(let i = 0; i < nextSignature.length; i++){
+            if (prevSignature[i] !== nextSignature[i]) {
+                return true;
+            }
+        }
+        return false;
+    };
+    var getRefreshBoundarySignature = (Refresh, moduleExports)=>{
+        const signature = [];
+        signature.push(Refresh.getFamilyByType(moduleExports));
+        if (moduleExports == null || typeof moduleExports !== 'object') {
+            return signature;
+        }
+        for(const key in moduleExports){
+            if (key === '__esModule') {
+                continue;
+            } else if (!isSpecifierSafeToCheck(moduleExports, key)) {
+                continue;
+            }
+            const exportValue = moduleExports[key];
+            signature.push(key);
+            signature.push(Refresh.getFamilyByType(exportValue));
+        }
+        return signature;
+    };
+    var registerExportsForReactRefresh = (Refresh, moduleExports, moduleID)=>{
+        Refresh.register(moduleExports, moduleID + ' %exports%');
+        if (moduleExports == null || typeof moduleExports !== 'object') {
+            return;
+        }
+        for(const key in moduleExports){
+            if (!isSpecifierSafeToCheck(moduleExports, key)) {
+                continue;
+            }
+            const exportValue = moduleExports[key];
+            const typeID = moduleID + ' %exports% ' + key;
+            Refresh.register(exportValue, typeID);
+        }
+    };
+    global.__accept = metroHotUpdateModule;
+}
+if (__DEV__) {
+    var requireSystrace = function requireSystrace() {
+        return global[__METRO_GLOBAL_PREFIX__ + '__SYSTRACE'] || metroRequire.Systrace;
+    };
+    var requireRefresh = function requireRefresh() {
+        return global[__METRO_GLOBAL_PREFIX__ + '__ReactRefresh'] || global[global.__METRO_GLOBAL_PREFIX__ + '__ReactRefresh'] || metroRequire.Refresh;
+    };
+}

package/build/src/api/endpoint.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getExpoApiBaseUrl: function() {
+        return getExpoApiBaseUrl;
+    },
+    getExpoWebsiteBaseUrl: function() {
+        return getExpoWebsiteBaseUrl;
+    }
+});
+const _env = require("../utils/env");
+function getExpoApiBaseUrl() {
+    if (_env.env.EXPO_STAGING) {
+        return `https://staging-api.expo.dev`;
+    } else if (_env.env.EXPO_LOCAL) {
+        return `http://127.0.0.1:3000`;
+    } else {
+        return `https://api.expo.dev`;
+    }
+}
+function getExpoWebsiteBaseUrl() {
+    if (_env.env.EXPO_STAGING) {
+        return `https://staging.expo.dev`;
+    } else if (_env.env.EXPO_LOCAL) {
+        return `http://127.0.0.1:3001`;
+    } else {
+        return `https://expo.dev`;
+    }
+}
+
+//# sourceMappingURL=endpoint.js.map

package/build/src/api/endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/api/endpoint.ts"],"sourcesContent":["import { env } from '../utils/env';\n\n/** Get the URL for the expo.dev API. */\nexport function getExpoApiBaseUrl(): string {\n  if (env.EXPO_STAGING) {\n    return `https://staging-api.expo.dev`;\n  } else if (env.EXPO_LOCAL) {\n    return `http://127.0.0.1:3000`;\n  } else {\n    return `https://api.expo.dev`;\n  }\n}\n\n/** Get the URL for the expo.dev website. */\nexport function getExpoWebsiteBaseUrl(): string {\n  if (env.EXPO_STAGING) {\n    return `https://staging.expo.dev`;\n  } else if (env.EXPO_LOCAL) {\n    return `http://127.0.0.1:3001`;\n  } else {\n    return `https://expo.dev`;\n  }\n}\n"],"names":["getExpoApiBaseUrl","getExpoWebsiteBaseUrl","env","EXPO_STAGING","EXPO_LOCAL"],"mappings":";;;;;;;;;;;IAGgBA,iBAAiB;eAAjBA;;IAWAC,qBAAqB;eAArBA;;;qBAdI;AAGb,SAASD;IACd,IAAIE,QAAG,CAACC,YAAY,EAAE;QACpB,OAAO,CAAC,4BAA4B,CAAC;IACvC,OAAO,IAAID,QAAG,CAACE,UAAU,EAAE;QACzB,OAAO,CAAC,qBAAqB,CAAC;IAChC,OAAO;QACL,OAAO,CAAC,oBAAoB,CAAC;IAC/B;AACF;AAGO,SAASH;IACd,IAAIC,QAAG,CAACC,YAAY,EAAE;QACpB,OAAO,CAAC,wBAAwB,CAAC;IACnC,OAAO,IAAID,QAAG,CAACE,UAAU,EAAE;QACzB,OAAO,CAAC,qBAAqB,CAAC;IAChC,OAAO;QACL,OAAO,CAAC,gBAAgB,CAAC;IAC3B;AACF"}

package/build/src/api/getExpoGoIntermediateCertificate.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getExpoGoIntermediateCertificateAsync", {
+    enumerable: true,
+    get: function() {
+        return getExpoGoIntermediateCertificateAsync;
+    }
+});
+const _client = require("./rest/client");
+const _errors = require("../utils/errors");
+async function getExpoGoIntermediateCertificateAsync(easProjectId) {
+    const response = await (0, _client.fetchAsync)(`projects/${encodeURIComponent(easProjectId)}/development-certificates/expo-go-intermediate-certificate`, {
+        method: 'GET'
+    });
+    if (!response.ok) {
+        throw new _errors.CommandError('API', `Unexpected error from Expo servers: ${response.statusText}.`);
+    }
+    return await response.text();
+}
+
+//# sourceMappingURL=getExpoGoIntermediateCertificate.js.map

package/build/src/api/getExpoGoIntermediateCertificate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/api/getExpoGoIntermediateCertificate.ts"],"sourcesContent":["import { fetchAsync } from './rest/client';\nimport { CommandError } from '../utils/errors';\n\nexport async function getExpoGoIntermediateCertificateAsync(easProjectId: string): Promise<string> {\n  const response = await fetchAsync(\n    `projects/${encodeURIComponent(\n      easProjectId\n    )}/development-certificates/expo-go-intermediate-certificate`,\n    {\n      method: 'GET',\n    }\n  );\n  if (!response.ok) {\n    throw new CommandError('API', `Unexpected error from Expo servers: ${response.statusText}.`);\n  }\n\n  return await response.text();\n}\n"],"names":["getExpoGoIntermediateCertificateAsync","easProjectId","response","fetchAsync","encodeURIComponent","method","ok","CommandError","statusText","text"],"mappings":";;;;+BAGsBA;;;eAAAA;;;wBAHK;wBACE;AAEtB,eAAeA,sCAAsCC,YAAoB;IAC9E,MAAMC,WAAW,MAAMC,IAAAA,kBAAU,EAC/B,CAAC,SAAS,EAAEC,mBACVH,cACA,0DAA0D,CAAC,EAC7D;QACEI,QAAQ;IACV;IAEF,IAAI,CAACH,SAASI,EAAE,EAAE;QAChB,MAAM,IAAIC,oBAAY,CAAC,OAAO,CAAC,oCAAoC,EAAEL,SAASM,UAAU,CAAC,CAAC,CAAC;IAC7F;IAEA,OAAO,MAAMN,SAASO,IAAI;AAC5B"}