@embroider/core 2.0.2 → 2.1.1-unstable.21eae41

package/src/module-resolver.js

@@ -0,0 +1,589 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resolver = void 0;
+const shared_internals_1 = require("@embroider/shared-internals");
+const path_1 = require("path");
+const shared_internals_2 = require("@embroider/shared-internals");
+const debug_1 = __importDefault(require("debug"));
+const assert_never_1 = __importDefault(require("assert-never"));
+const resolve_1 = __importDefault(require("resolve"));
+const virtual_content_1 = require("./virtual-content");
+const debug = (0, debug_1.default)('embroider:resolver');
+function logTransition(reason, before, after = before) {
+    if (after.isVirtual) {
+        debug(`virtualized %s in %s because %s`, before.specifier, before.fromFile, reason);
+    }
+    else if (before.specifier !== after.specifier) {
+        if (before.fromFile !== after.fromFile) {
+            debug(`aliased and rehomed: %s to %s, from %s to %s because %s`, before.specifier, after.specifier, before.fromFile, after.fromFile, reason);
+        }
+        else {
+            debug(`aliased: %s to %s in %s because`, before.specifier, after.specifier, before.fromFile, reason);
+        }
+    }
+    else if (before.fromFile !== after.fromFile) {
+        debug(`rehomed: %s from %s to %s because`, before.specifier, before.fromFile, after.fromFile, reason);
+    }
+    else {
+        debug(`unchanged: %s in %s because %s`, before.specifier, before.fromFile, reason);
+    }
+    return after;
+}
+const compatPattern = /#embroider_compat\/(?<type>[^\/]+)\/(?<rest>.*)/;
+class NodeModuleRequest {
+    constructor(specifier, fromFile, isVirtual = false) {
+        this.specifier = specifier;
+        this.fromFile = fromFile;
+        this.isVirtual = isVirtual;
+    }
+    alias(specifier) {
+        return new NodeModuleRequest(specifier, this.fromFile);
+    }
+    rehome(fromFile) {
+        return new NodeModuleRequest(this.specifier, fromFile);
+    }
+    virtualize(filename) {
+        return new NodeModuleRequest(filename, this.fromFile, true);
+    }
+}
+class Resolver {
+    constructor(options) {
+        this.options = options;
+    }
+    beforeResolve(request) {
+        if (request.specifier === '@embroider/macros') {
+            // the macros package is always handled directly within babel (not
+            // necessarily as a real resolvable package), so we should not mess with it.
+            // It might not get compiled away until *after* our plugin has run, which is
+            // why we need to know about it.
+            return logTransition('early exit', request);
+        }
+        request = this.handleGlobalsCompat(request);
+        request = this.handleRenaming(request);
+        return this.preHandleExternal(request);
+    }
+    // This encapsulates the whole resolving process. Given a `defaultResolve`
+    // that calls your build system's normal module resolver, this does both pre-
+    // and post-resolution adjustments as needed to implement our compatibility
+    // rules.
+    //
+    // Depending on the plugin architecture you're working in, it may be easier to
+    // call beforeResolve and fallbackResolve directly, in which case matching the
+    // details of the recursion to what this method does are your responsibility.
+    async resolve(request, defaultResolve) {
+        let gen = this.internalResolve(request, defaultResolve);
+        let out = gen.next();
+        while (!out.done) {
+            out = gen.next(await out.value);
+        }
+        return out.value;
+    }
+    // synchronous alternative to resolve() above. Because our own internals are
+    // all synchronous, you can use this if your defaultResolve function is
+    // synchronous. At present, we need this for the case where we are compiling
+    // non-strict templates and doing component resolutions inside the template
+    // compiler inside babel, which is a synchronous context.
+    resolveSync(request, defaultResolve) {
+        let gen = this.internalResolve(request, defaultResolve);
+        let out = gen.next();
+        while (!out.done) {
+            out = gen.next(out.value);
+        }
+        return out.value;
+    }
+    // Our core implementation is a generator so it can power both resolve() and
+    // resolveSync()
+    *internalResolve(request, defaultResolve) {
+        request = this.beforeResolve(request);
+        let resolution = yield defaultResolve(request);
+        switch (resolution.type) {
+            case 'found':
+                return resolution;
+            case 'not_found':
+                break;
+            default:
+                throw (0, assert_never_1.default)(resolution);
+        }
+        let nextRequest = this.fallbackResolve(request);
+        if (nextRequest === request) {
+            // no additional fallback is available.
+            return resolution;
+        }
+        if (nextRequest.isVirtual) {
+            // virtual requests are terminal, there is no more beforeResolve or
+            // fallbackResolve around them. The defaultResolve is expected to know how
+            // to implement them.
+            return yield defaultResolve(nextRequest);
+        }
+        return yield* this.internalResolve(nextRequest, defaultResolve);
+    }
+    // Use standard NodeJS resolving, with our required compatibility rules on
+    // top. This is a convenience method for calling resolveSync with the
+    // defaultResolve already configured to be "do the normal node thing".
+    nodeResolve(specifier, fromFile) {
+        let resolution = this.resolveSync(new NodeModuleRequest(specifier, fromFile), request => {
+            if (request.isVirtual) {
+                return {
+                    type: 'found',
+                    result: {
+                        type: 'virtual',
+                        content: (0, virtual_content_1.virtualContent)(request.specifier),
+                        filename: request.specifier,
+                    },
+                };
+            }
+            try {
+                let filename = resolve_1.default.sync(request.specifier, {
+                    basedir: (0, path_1.dirname)(request.fromFile),
+                    extensions: this.options.resolvableExtensions,
+                });
+                return { type: 'found', result: { type: 'real', filename } };
+            }
+            catch (err) {
+                if (err.code !== 'MODULE_NOT_FOUND') {
+                    throw err;
+                }
+                return { type: 'not_found', err };
+            }
+        });
+        switch (resolution.type) {
+            case 'not_found':
+                return resolution;
+            case 'found':
+                return resolution.result;
+            default:
+                throw (0, assert_never_1.default)(resolution);
+        }
+    }
+    owningPackage(fromFile) {
+        return shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).ownerOfFile(fromFile);
+    }
+    originalPackage(fromFile) {
+        let originalFile = this.options.relocatedFiles[fromFile];
+        if (originalFile) {
+            let owning = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).ownerOfFile(originalFile);
+            if (owning && !owning.isV2Ember()) {
+                throw new Error(`bug: it should only be possible for a v2 ember package to own relocated files`);
+            }
+            return owning;
+        }
+    }
+    handleGlobalsCompat(request) {
+        let match = compatPattern.exec(request.specifier);
+        if (!match) {
+            return request;
+        }
+        let { type, rest } = match.groups;
+        let fromPkg = this.owningPackage(request.fromFile);
+        if (!(fromPkg === null || fromPkg === void 0 ? void 0 : fromPkg.isV2Ember())) {
+            return request;
+        }
+        let engine = this.owningEngine(fromPkg);
+        switch (type) {
+            case 'helpers':
+                return this.resolveHelper(rest, engine, request);
+            case 'components':
+                return this.resolveComponent(rest, engine, request);
+            case 'modifiers':
+                return this.resolveModifier(rest, engine, request);
+            case 'ambiguous':
+                return this.resolveHelperOrComponent(rest, engine, request);
+            default:
+                throw new Error(`bug: unexepected #embroider_compat specifier: ${request.specifier}`);
+        }
+    }
+    resolveHelper(path, inEngine, request) {
+        let target = this.parseGlobalPath(path, inEngine);
+        return request
+            .alias(`${target.packageName}/helpers/${target.memberName}`)
+            .rehome((0, path_1.resolve)(inEngine.root, 'package.json'));
+    }
+    resolveComponent(path, inEngine, request) {
+        let target = this.parseGlobalPath(path, inEngine);
+        let hbsModule = null;
+        let jsModule = null;
+        // first, the various places our template might be.
+        for (let candidate of this.componentTemplateCandidates(target.packageName)) {
+            let resolution = this.nodeResolve(`${target.packageName}${candidate.prefix}${target.memberName}${candidate.suffix}`, target.from);
+            if (resolution.type === 'real') {
+                hbsModule = resolution.filename;
+                break;
+            }
+        }
+        // then the various places our javascript might be.
+        for (let candidate of this.componentJSCandidates(target.packageName)) {
+            let resolution = this.nodeResolve(`${target.packageName}${candidate.prefix}${target.memberName}${candidate.suffix}`, target.from);
+            // .hbs is a resolvable extension for us, so we need to exclude it here.
+            // It matches as a priority lower than .js, so finding an .hbs means
+            // there's definitely not a .js.
+            if (resolution.type === 'real' && !resolution.filename.endsWith('.hbs')) {
+                jsModule = resolution.filename;
+                break;
+            }
+        }
+        if (hbsModule) {
+            return logTransition(`resolveComponent found legacy HBS`, request, request.virtualize((0, virtual_content_1.virtualPairComponent)(hbsModule, jsModule)));
+        }
+        else if (jsModule) {
+            return logTransition(`resolveComponent found only JS`, request, request.alias(jsModule).rehome(target.from));
+        }
+        else {
+            return logTransition(`resolveComponent failed`, request);
+        }
+    }
+    resolveHelperOrComponent(path, inEngine, request) {
+        // resolveHelper just rewrites our request to one that should target the
+        // component, so here to resolve the ambiguity we need to actually resolve
+        // that candidate to see if it works.
+        let helperCandidate = this.resolveHelper(path, inEngine, request);
+        let helperMatch = this.nodeResolve(helperCandidate.specifier, helperCandidate.fromFile);
+        if (helperMatch.type === 'real') {
+            return helperCandidate;
+        }
+        // unlike resolveHelper, resolveComponent already does pre-resolution in
+        // order to deal with its own internal ambiguity around JS vs HBS vs
+        // colocation.≥
+        let componentMatch = this.resolveComponent(path, inEngine, request);
+        if (componentMatch !== request) {
+            return componentMatch;
+        }
+        // this is the hard failure case -- we were supposed to find something and
+        // didn't. Let the normal resolution process progress so the user gets a
+        // normal build error.
+        return request;
+    }
+    resolveModifier(path, inEngine, request) {
+        let target = this.parseGlobalPath(path, inEngine);
+        return request
+            .alias(`${target.packageName}/modifiers/${target.memberName}`)
+            .rehome((0, path_1.resolve)(inEngine.root, 'package.json'));
+    }
+    *componentTemplateCandidates(inPackageName) {
+        yield { prefix: '/templates/components/', suffix: '' };
+        yield { prefix: '/components/', suffix: '/template' };
+        let pods = this.podPrefix(inPackageName);
+        if (pods) {
+            yield { prefix: `${pods}/components/`, suffix: '/template' };
+        }
+    }
+    *componentJSCandidates(inPackageName) {
+        yield { prefix: '/components/', suffix: '' };
+        yield { prefix: '/components/', suffix: '/component' };
+        let pods = this.podPrefix(inPackageName);
+        if (pods) {
+            yield { prefix: `${pods}/components/`, suffix: '/component' };
+        }
+    }
+    podPrefix(targetPackageName) {
+        if (targetPackageName === this.options.modulePrefix && this.options.podModulePrefix) {
+            if (!this.options.podModulePrefix.startsWith(this.options.modulePrefix)) {
+                throw new Error(`Your podModulePrefix (${this.options.podModulePrefix}) does not start with your app module prefix (${this.options.modulePrefix}). Not gonna support that silliness.`);
+            }
+            return this.options.podModulePrefix.slice(this.options.modulePrefix.length);
+        }
+    }
+    // for paths that come from non-strict templates
+    parseGlobalPath(path, inEngine) {
+        let parts = path.split('@');
+        if (parts.length > 1 && parts[0].length > 0) {
+            return { packageName: parts[0], memberName: parts[1], from: (0, path_1.resolve)(inEngine.root, 'pacakge.json') };
+        }
+        else {
+            return { packageName: inEngine.packageName, memberName: path, from: (0, path_1.resolve)(inEngine.root, 'pacakge.json') };
+        }
+    }
+    owningEngine(pkg) {
+        if (pkg.root === this.options.appRoot) {
+            // the app is always the first engine
+            return this.options.engines[0];
+        }
+        let owningEngine = this.options.engines.find(e => e.activeAddons.find(a => a.root === pkg.root));
+        if (!owningEngine) {
+            throw new Error(`bug in @embroider/core/src/module-resolver: cannot figure out the owning engine for ${pkg.root}`);
+        }
+        return owningEngine;
+    }
+    handleRenaming(request) {
+        if (request.isVirtual) {
+            return request;
+        }
+        let packageName = (0, shared_internals_1.packageName)(request.specifier);
+        if (!packageName) {
+            return request;
+        }
+        for (let [candidate, replacement] of Object.entries(this.options.renameModules)) {
+            if (candidate === request.specifier) {
+                return logTransition(`renameModules`, request, request.alias(replacement));
+            }
+            for (let extension of this.options.resolvableExtensions) {
+                if (candidate === request.specifier + '/index' + extension) {
+                    return logTransition(`renameModules`, request, request.alias(replacement));
+                }
+                if (candidate === request.specifier + extension) {
+                    return logTransition(`renameModules`, request, request.alias(replacement));
+                }
+            }
+        }
+        if (this.options.renamePackages[packageName]) {
+            return logTransition(`renamePackages`, request, request.alias(request.specifier.replace(packageName, this.options.renamePackages[packageName])));
+        }
+        let pkg = this.owningPackage(request.fromFile);
+        if (!pkg || !pkg.isV2Ember()) {
+            return request;
+        }
+        if (pkg.meta['auto-upgraded'] && pkg.name === packageName) {
+            // we found a self-import, resolve it for them. Only auto-upgraded
+            // packages get this help, v2 packages are natively supposed to make their
+            // own modules resolvable, and we want to push them all to do that
+            // correctly.
+            return logTransition(`v1 self-import`, request, this.resolveWithinPackage(request, pkg));
+        }
+        let originalPkg = this.originalPackage(request.fromFile);
+        if (originalPkg && pkg.meta['auto-upgraded'] && originalPkg.name === packageName) {
+            // A file that was relocated out of a package is importing that package's
+            // name, it should find its own original copy.
+            return logTransition(`self-import in app-js`, request, this.resolveWithinPackage(request, originalPkg));
+        }
+        return request;
+    }
+    resolveWithinPackage(request, pkg) {
+        if ('exports' in pkg.packageJSON) {
+            // this is the easy case -- a package that uses exports can safely resolve
+            // its own name, so it's enough to let it resolve the (self-targeting)
+            // specifier from its own package root.
+            return request.rehome((0, path_1.resolve)(pkg.root, 'package.json'));
+        }
+        else {
+            // otherwise we need to just assume that internal naming is simple
+            return request.alias(request.specifier.replace(pkg.name, '.')).rehome((0, path_1.resolve)(pkg.root, 'package.json'));
+        }
+    }
+    preHandleExternal(request) {
+        if (request.isVirtual) {
+            return request;
+        }
+        let { specifier, fromFile } = request;
+        let pkg = this.owningPackage(fromFile);
+        if (!pkg || !pkg.isV2Ember()) {
+            return request;
+        }
+        let packageName = (0, shared_internals_1.packageName)(specifier);
+        if (!packageName) {
+            // This is a relative import. We don't automatically externalize those
+            // because it's rare, and by keeping them static we give better errors. But
+            // we do allow them to be explicitly externalized by the package author (or
+            // a compat adapter). In the metadata, they would be listed in
+            // package-relative form, so we need to convert this specifier to that.
+            let absoluteSpecifier = (0, path_1.resolve)((0, path_1.dirname)(fromFile), specifier);
+            let packageRelativeSpecifier = (0, shared_internals_2.explicitRelative)(pkg.root, absoluteSpecifier);
+            if (isExplicitlyExternal(packageRelativeSpecifier, pkg)) {
+                let publicSpecifier = absoluteSpecifier.replace(pkg.root, pkg.name);
+                return external('beforeResolve', request, publicSpecifier);
+            }
+            else {
+                return request;
+            }
+        }
+        // absolute package imports can also be explicitly external based on their
+        // full specifier name
+        if (isExplicitlyExternal(specifier, pkg)) {
+            return external('beforeResolve', request, specifier);
+        }
+        if (!pkg.meta['auto-upgraded'] && shared_internals_1.emberVirtualPeerDeps.has(packageName)) {
+            // Native v2 addons are allowed to use the emberVirtualPeerDeps like
+            // `@glimmer/component`. And like all v2 addons, it's important that they
+            // see those dependencies after those dependencies have been converted to
+            // v2.
+            //
+            // But unlike auto-upgraded addons, native v2 addons are not necessarily
+            // copied out of their original place in node_modules. And from that
+            // original place they might accidentally resolve the emberVirtualPeerDeps
+            // that are present there in v1 format.
+            //
+            // So before we let normal resolving happen, we adjust these imports to
+            // point at the app's copies instead.
+            if (!this.options.activeAddons[packageName]) {
+                throw new Error(`${pkg.name} is trying to import the app's ${packageName} package, but it seems to be missing`);
+            }
+            let newHome = (0, path_1.resolve)(this.options.appRoot, 'package.json');
+            return logTransition(`emberVirtualPeerDeps in v2 addon`, request, request.rehome(newHome));
+        }
+        if (pkg.meta['auto-upgraded'] && !pkg.hasDependency('ember-auto-import')) {
+            try {
+                let dep = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).resolve(packageName, pkg);
+                if (!dep.isEmberPackage()) {
+                    // classic ember addons can only import non-ember dependencies if they
+                    // have ember-auto-import.
+                    return external('v1 package without auto-import', request, specifier);
+                }
+            }
+            catch (err) {
+                if (err.code !== 'MODULE_NOT_FOUND') {
+                    throw err;
+                }
+            }
+        }
+        // assertions on what native v2 addons can import
+        if (!pkg.meta['auto-upgraded']) {
+            let originalPkg = this.originalPackage(fromFile);
+            if (originalPkg) {
+                // this file has been moved into another package (presumably the app).
+                if (packageName !== pkg.name) {
+                    // the only thing that native v2 addons are allowed to import from
+                    // within the app tree is their own name.
+                    throw new Error(`${pkg.name} is trying to import ${packageName} from within its app tree. This is unsafe, because ${pkg.name} can't control which dependencies are resolvable from the app`);
+                }
+            }
+            else {
+                // this file has not been moved. The normal case.
+                if (!pkg.meta['auto-upgraded'] && !reliablyResolvable(pkg, packageName)) {
+                    throw new Error(`${pkg.name} is trying to import from ${packageName} but that is not one of its explicit dependencies`);
+                }
+            }
+        }
+        return request;
+    }
+    fallbackResolve(request) {
+        let { specifier, fromFile } = request;
+        if (compatPattern.test(specifier)) {
+            // Some kinds of compat requests get rewritten into other things
+            // deterministically. For example, "#embroider_compat/helpers/whatever"
+            // means only "the-current-engine/helpers/whatever", and if that doesn't
+            // actually exist it's that path that will show up as a missing import.
+            //
+            // But others have an ambiguous meaning. For example,
+            // #embroider_compat/components/whatever can mean several different
+            // things. If we're unable to find any of them, the actual
+            // "#embroider_compat" request will fall through all the way to here.
+            //
+            // In that case, we don't want to externalize that failure. We know it's
+            // not a classic runtime thing. It's better to let it be a build error
+            // here.
+            return request;
+        }
+        let pkg = this.owningPackage(fromFile);
+        if (!pkg || !pkg.isV2Ember()) {
+            return request;
+        }
+        let packageName = (0, shared_internals_1.packageName)(specifier);
+        if (!packageName) {
+            // this is a relative import, we have nothing more to for it.
+            return request;
+        }
+        let originalPkg = this.originalPackage(fromFile);
+        if (originalPkg) {
+            // we didn't find it from the original package, so try from the relocated
+            // package
+            return logTransition(`relocation fallback`, request, request.rehome((0, path_1.resolve)(originalPkg.root, 'package.json')));
+        }
+        // auto-upgraded packages can fall back to the set of known active addons
+        //
+        // v2 packages can fall back to the set of known active addons only to find
+        // themselves (which is needed due to app tree merging)
+        if ((pkg.meta['auto-upgraded'] || packageName === pkg.name) && this.options.activeAddons[packageName]) {
+            return logTransition(`activeAddons`, request, this.resolveWithinPackage(request, shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).get(this.options.activeAddons[packageName])));
+        }
+        if (pkg.meta['auto-upgraded']) {
+            // auto-upgraded packages can fall back to attempting to find dependencies at
+            // runtime. Native v2 packages can only get this behavior in the
+            // isExplicitlyExternal case above because they need to explicitly ask for
+            // externals.
+            return external('v1 catch-all fallback', request, specifier);
+        }
+        else {
+            // native v2 packages don't automatically externalize *everything* the way
+            // auto-upgraded packages do, but they still externalize known and approved
+            // ember virtual packages (like @ember/component)
+            if (shared_internals_1.emberVirtualPackages.has(packageName)) {
+                return external('emberVirtualPackages', request, specifier);
+            }
+        }
+        // this is falling through with the original specifier which was
+        // non-resolvable, which will presumably cause a static build error in stage3.
+        return request;
+    }
+    // check whether the given file with the given owningPackage is an addon's
+    // appTree, and if so return the notional location within the app (or owning
+    // engine) that it "logically" lives at.
+    reverseSearchAppTree(owningPackage, fromFile) {
+        // if the requesting file is in an addon's app-js, the request should
+        // really be understood as a request for a module in the containing engine
+        if (owningPackage.isV2Addon()) {
+            let appJS = owningPackage.meta['app-js'];
+            if (appJS) {
+                let fromPackageRelativePath = (0, shared_internals_2.explicitRelative)(owningPackage.root, fromFile);
+                for (let [inAppName, inAddonName] of Object.entries(appJS)) {
+                    if (inAddonName === fromPackageRelativePath) {
+                        return { owningEngine: this.owningEngine(owningPackage), inAppName };
+                    }
+                }
+            }
+        }
+    }
+    // check if this file is resolvable as a global component, and if so return
+    // its dasherized name
+    reverseComponentLookup(filename) {
+        const owningPackage = this.owningPackage(filename);
+        if (!(owningPackage === null || owningPackage === void 0 ? void 0 : owningPackage.isV2Ember())) {
+            return;
+        }
+        let engineConfig = this.options.engines.find(e => e.root === owningPackage.root);
+        if (engineConfig) {
+            // we're directly inside an engine, so we're potentially resolvable as a
+            // global component
+            // this kind of mapping is not true in general for all packages, but it
+            // *is* true for all classical engines (which includes apps) since they
+            // don't support package.json `exports`. As for a future v2 engine or app:
+            // this whole method is only relevant for implementing packageRules, which
+            // should only be for classic stuff. v2 packages should do the right
+            // things from the beginning and not need packageRules about themselves.
+            let inAppName = (0, shared_internals_2.explicitRelative)(engineConfig.root, filename);
+            return this.tryReverseComponent(engineConfig.packageName, inAppName);
+        }
+        let engineInfo = this.reverseSearchAppTree(owningPackage, filename);
+        if (engineInfo) {
+            // we're in some addon's app tree, so we're potentially resolvable as a
+            // global component
+            return this.tryReverseComponent(engineInfo.owningEngine.packageName, engineInfo.inAppName);
+        }
+    }
+    tryReverseComponent(inEngineName, relativePath) {
+        let extensionless = relativePath.replace((0, shared_internals_1.extensionsPattern)(this.options.resolvableExtensions), '');
+        let candidates = [...this.componentJSCandidates(inEngineName), ...this.componentTemplateCandidates(inEngineName)];
+        for (let candidate of candidates) {
+            if (extensionless.startsWith(`.${candidate.prefix}`) && extensionless.endsWith(candidate.suffix)) {
+                return extensionless.slice(candidate.prefix.length + 1, extensionless.length - candidate.suffix.length);
+            }
+        }
+        return undefined;
+    }
+}
+exports.Resolver = Resolver;
+function isExplicitlyExternal(specifier, fromPkg) {
+    return Boolean(fromPkg.isV2Addon() && fromPkg.meta['externals'] && fromPkg.meta['externals'].includes(specifier));
+}
+// we don't want to allow things that resolve only by accident that are likely
+// to break in other setups. For example: import your dependencies'
+// dependencies, or importing your own name from within a monorepo (which will
+// work because of the symlinking) without setting up "exports" (which makes
+// your own name reliably resolvable)
+function reliablyResolvable(pkg, packageName) {
+    if (pkg.hasDependency(packageName)) {
+        return true;
+    }
+    if (pkg.name === packageName && pkg.packageJSON.exports) {
+        return true;
+    }
+    if (shared_internals_1.emberVirtualPeerDeps.has(packageName) || shared_internals_1.emberVirtualPackages.has(packageName)) {
+        return true;
+    }
+    return false;
+}
+function external(label, request, specifier) {
+    let filename = (0, virtual_content_1.virtualExternalModule)(specifier);
+    return logTransition(label, request, request.virtualize(filename));
+}
+//# sourceMappingURL=module-resolver.js.map