Function getLoadModuleFromTargetImportOrExport

test/fixtures/snapshot/typescript.js:44072–44280

* Gets the self-recursive function specialized to retrieving the targeted import/export element for the given resolution configuration

(extensions, state, cache, redirectedReference, moduleName, scope, isImports)

     * Gets the self-recursive function specialized to retrieving the targeted import/export element for the given resolution configuration
     */
    function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
        return loadModuleFromTargetImportOrExport;
        function loadModuleFromTargetImportOrExport(target, subpath, pattern) {
            if (typeof target === "string") {
                if (!pattern && subpath.length > 0 && !ts.endsWith(target, "/")) {
                    if (state.traceEnabled) {
                        trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
                    }
                    return toSearchResult(/*value*/ undefined);
                }
                if (!ts.startsWith(target, "./")) {
                    if (isImports && !ts.startsWith(target, "../") && !ts.startsWith(target, "/") && !ts.isRootedDiskPath(target)) {
                        var combinedLookup = pattern ? target.replace(/\*/g, subpath) : target + subpath;
                        var result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, [extensions], redirectedReference);
                        return toSearchResult(result.resolvedModule ? { path: result.resolvedModule.resolvedFileName, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId, originalPath: result.resolvedModule.originalPath } : undefined);
                    }
                    if (state.traceEnabled) {
                        trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
                    }
                    return toSearchResult(/*value*/ undefined);
                }
                var parts = ts.pathIsRelative(target) ? ts.getPathComponents(target).slice(1) : ts.getPathComponents(target);
                var partsAfterFirst = parts.slice(1);
                if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
                    if (state.traceEnabled) {
                        trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
                    }
                    return toSearchResult(/*value*/ undefined);
                }
                var resolvedTarget = ts.combinePaths(scope.packageDirectory, target);
                // TODO: Assert that `resolvedTarget` is actually within the package directory? That's what the spec says.... but I'm not sure we need
                // to be in the business of validating everyone's import and export map correctness.
                var subpathParts = ts.getPathComponents(subpath);
                if (subpathParts.indexOf("..") >= 0 || subpathParts.indexOf(".") >= 0 || subpathParts.indexOf("node_modules") >= 0) {
                    if (state.traceEnabled) {
                        trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
                    }
                    return toSearchResult(/*value*/ undefined);
                }
                var finalPath = toAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath);
                var inputLink = tryLoadInputFileForPath(finalPath, subpath, ts.combinePaths(scope.packageDirectory, "package.json"), isImports);
                if (inputLink)
                    return inputLink;
                return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, finalPath, /*onlyRecordFailures*/ false, state)));
            }
            else if (typeof target === "object" && target !== null) { // eslint-disable-line no-null/no-null
                if (!Array.isArray(target)) {
                    for (var _i = 0, _a = ts.getOwnKeys(target); _i < _a.length; _i++) {
                        var key = _a[_i];
                        if (key === "default" || state.conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(state.conditions, key)) {
                            var subTarget = target[key];
                            var result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern);
                            if (result) {
                                return result;
                            }
                        }
                    }
                    return undefined;