"use strict";

var __assign = (this && this.__assign) || function () {

__assign = Object.assign || function(t) {

for (var s, i = 1, n = arguments.length; i < n; i++) {

s = arguments[i];

for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))

t[p] = s[p];

}

return t;

};

return __assign.apply(this, arguments);

};

var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {

if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {

if (ar || !(i in from)) {

if (!ar) ar = Array.prototype.slice.call(from, 0, i);

ar[i] = from[i];

}

}

return to.concat(ar || Array.prototype.slice.call(from));

};

Object.defineProperty(exports, "__esModule", { value: true });

exports.loadModuleFromGlobalCache = exports.shouldAllowImportingTsExtension = exports.classicNameResolver = exports.unmangleScopedPackageName = exports.getPackageNameFromTypesPackageName = exports.mangleScopedPackageName = exports.getTypesPackageName = exports.isApplicableVersionedTypesKey = exports.comparePatternKeys = exports.allKeysStartWithDot = exports.parsePackageName = exports.getPackageJsonInfo = exports.getPackageScopeForPath = exports.getTemporaryModuleResolutionState = exports.getEntrypointsFromPackageJsonInfo = exports.parseNodeModuleFromPath = exports.pathContainsNodeModules = exports.nodeModulesPathPart = exports.nodeNextJsonConfigResolver = exports.nodeModuleNameResolver = exports.bundlerModuleNameResolver = exports.NodeResolutionFeatures = exports.resolveJSModule = exports.resolveModuleName = exports.resolveModuleNameFromCache = exports.resolveLibrary = exports.getOptionsForLibraryResolution = exports.createTypeReferenceDirectiveResolutionCache = exports.createModuleResolutionCache = exports.zipToModeAwareCache = exports.createModeAwareCache = exports.createModeAwareCacheKey = exports.createCacheWithRedirects = exports.getKeyForCompilerOptions = exports.getAutomaticTypeDirectiveNames = exports.resolvePackageNameToPackageJson = exports.getConditions = exports.resolveTypeReferenceDirective = exports.getEffectiveTypeRoots = exports.getPackageJsonTypesVersionsPaths = exports.updateResolutionField = exports.isTraceEnabled = exports.trace = void 0;

var ts_1 = require("./_namespaces/ts");

function trace(host) {

host.trace(ts_1.formatMessage.apply(undefined, arguments));

}

exports.trace = trace;

/** @internal */

function isTraceEnabled(compilerOptions, host) {

return !!compilerOptions.traceResolution && host.trace !== undefined;

}

exports.isTraceEnabled = isTraceEnabled;

function withPackageId(packageInfo, r) {

var packageId;

if (r && packageInfo) {

var packageJsonContent = packageInfo.contents.packageJsonContent;

if (typeof packageJsonContent.name === "string" && typeof packageJsonContent.version === "string") {

packageId = {

name: packageJsonContent.name,

subModuleName: r.path.slice(packageInfo.packageDirectory.length + ts_1.directorySeparator.length),

version: packageJsonContent.version

};

}

}

return r && { path: r.path, extension: r.ext, packageId: packageId, resolvedUsingTsExtension: r.resolvedUsingTsExtension };

}

function noPackageId(r) {

return withPackageId(/*packageInfo*/ undefined, r);

}

function removeIgnoredPackageId(r) {

if (r) {

ts_1.Debug.assert(r.packageId === undefined);

return { path: r.path, ext: r.extension, resolvedUsingTsExtension: r.resolvedUsingTsExtension };

}

}

function formatExtensions(extensions) {

var result = [];

if (extensions & 1 /* Extensions.TypeScript */)

result.push("TypeScript");

if (extensions & 2 /* Extensions.JavaScript */)

result.push("JavaScript");

if (extensions & 4 /* Extensions.Declaration */)

result.push("Declaration");

if (extensions & 8 /* Extensions.Json */)

result.push("JSON");

return result.join(", ");

}

/** Used with `Extensions.DtsOnly` to extract the path from TypeScript results. */

function resolvedTypeScriptOnly(resolved) {

if (!resolved) {

return undefined;

}

ts_1.Debug.assert((0, ts_1.extensionIsTS)(resolved.extension));

return { fileName: resolved.path, packageId: resolved.packageId };

}

function createResolvedModuleWithFailedLookupLocationsHandlingSymlink(moduleName, resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, state, legacyResult) {

// If this is from node_modules for non relative name, always respect preserveSymlinks

if (!state.resultFromCache &&

!state.compilerOptions.preserveSymlinks &&

resolved &&

isExternalLibraryImport &&

!resolved.originalPath &&

!(0, ts_1.isExternalModuleNameRelative)(moduleName)) {

var _a = getOriginalAndResolvedFileName(resolved.path, state.host, state.traceEnabled), resolvedFileName = _a.resolvedFileName, originalPath = _a.originalPath;

if (originalPath)

resolved = __assign(__assign({}, resolved), { path: resolvedFileName, originalPath: originalPath });

}

return createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache, legacyResult);

}

function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache, legacyResult) {

if (resultFromCache) {

resultFromCache.failedLookupLocations = updateResolutionField(resultFromCache.failedLookupLocations, failedLookupLocations);

resultFromCache.affectingLocations = updateResolutionField(resultFromCache.affectingLocations, affectingLocations);

resultFromCache.resolutionDiagnostics = updateResolutionField(resultFromCache.resolutionDiagnostics, diagnostics);

return resultFromCache;

}

return {

resolvedModule: resolved && {

resolvedFileName: resolved.path,

originalPath: resolved.originalPath === true ? undefined : resolved.originalPath,

extension: resolved.extension,

isExternalLibraryImport: isExternalLibraryImport,

packageId: resolved.packageId,

resolvedUsingTsExtension: !!resolved.resolvedUsingTsExtension,

},

failedLookupLocations: initializeResolutionField(failedLookupLocations),

affectingLocations: initializeResolutionField(affectingLocations),

resolutionDiagnostics: initializeResolutionField(diagnostics),

node10Result: legacyResult,

};

}

function initializeResolutionField(value) {

return value.length ? value : undefined;

}

/** @internal */

function updateResolutionField(to, value) {

if (!(value === null || value === void 0 ? void 0 : value.length))

return to;

if (!(to === null || to === void 0 ? void 0 : to.length))

return value;

to.push.apply(to, value);

return to;

}

exports.updateResolutionField = updateResolutionField;

function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {

if (!(0, ts_1.hasProperty)(jsonContent, fieldName)) {

if (state.traceEnabled) {

trace(state.host, ts_1.Diagnostics.package_json_does_not_have_a_0_field, fieldName);

}

return;

}

var value = jsonContent[fieldName];

if (typeof value !== typeOfTag || value === null) { // eslint-disable-line no-null/no-null

if (state.traceEnabled) {

// eslint-disable-next-line no-null/no-null

trace(state.host, ts_1.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, fieldName, typeOfTag, value === null ? "null" : typeof value);

}

return;

}

return value;

}

function readPackageJsonPathField(jsonContent, fieldName, baseDirectory, state) {

var fileName = readPackageJsonField(jsonContent, fieldName, "string", state);

if (fileName === undefined) {

return;

}

if (!fileName) {

if (state.traceEnabled) {

trace(state.host, ts_1.Diagnostics.package_json_had_a_falsy_0_field, fieldName);

}

return;

}

var path = (0, ts_1.normalizePath)((0, ts_1.combinePaths)(baseDirectory, fileName));

if (state.traceEnabled) {

trace(state.host, ts_1.Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path);

}

return path;

}

function readPackageJsonTypesFields(jsonContent, baseDirectory, state) {

return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state)

|| readPackageJsonPathField(jsonContent, "types", baseDirectory, state);

}

function readPackageJsonTSConfigField(jsonContent, baseDirectory, state) {

return readPackageJsonPathField(jsonContent, "tsconfig", baseDirectory, state);

}

function readPackageJsonMainField(jsonContent, baseDirectory, state) {

return readPackageJsonPathField(jsonContent, "main", baseDirectory, state);

}

function readPackageJsonTypesVersionsField(jsonContent, state) {

var typesVersions = readPackageJsonField(jsonContent, "typesVersions", "object", state);

if (typesVersions === undefined)

return;

if (state.traceEnabled) {

trace(state.host, ts_1.Diagnostics.package_json_has_a_typesVersions_field_with_version_specific_path_mappings);

}

return typesVersions;

}

function readPackageJsonTypesVersionPaths(jsonContent, state) {

var typesVersions = readPackageJsonTypesVersionsField(jsonContent, state);

if (typesVersions === undefined)

return;

if (state.traceEnabled) {

for (var key in typesVersions) {

if ((0, ts_1.hasProperty)(typesVersions, key) && !ts_1.VersionRange.tryParse(key)) {

trace(state.host, ts_1.Diagnostics.package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range, key);

}

}

}

var result = getPackageJsonTypesVersionsPaths(typesVersions);

if (!result) {

if (state.traceEnabled) {

trace(state.host, ts_1.Diagnostics.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, ts_1.versionMajorMinor);

}

return;

}

var bestVersionKey = result.version, bestVersionPaths = result.paths;

if (typeof bestVersionPaths !== "object") {

if (state.traceEnabled) {

trace(state.host, ts_1.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, "typesVersions['".concat(bestVersionKey, "']"), "object", typeof bestVersionPaths);

}

return;

}

return result;

}

var typeScriptVersion;

/** @internal */

function getPackageJsonTypesVersionsPaths(typesVersions) {

if (!typeScriptVersion)

typeScriptVersion = new ts_1.Version(ts_1.version);

for (var key in typesVersions) {

if (!(0, ts_1.hasProperty)(typesVersions, key))

continue;

var keyRange = ts_1.VersionRange.tryParse(key);

if (keyRange === undefined) {

continue;

}

// return the first entry whose range matches the current compiler version.

if (keyRange.test(typeScriptVersion)) {

return { version: key, paths: typesVersions[key] };

}

}

}

exports.getPackageJsonTypesVersionsPaths = getPackageJsonTypesVersionsPaths;

function getEffectiveTypeRoots(options, host) {

if (options.typeRoots) {

return options.typeRoots;

}

var currentDirectory;

if (options.configFilePath) {

currentDirectory = (0, ts_1.getDirectoryPath)(options.configFilePath);

}

else if (host.getCurrentDirectory) {

currentDirectory = host.getCurrentDirectory();

}

if (currentDirectory !== undefined) {

return getDefaultTypeRoots(currentDirectory);

}

}

exports.getEffectiveTypeRoots = getEffectiveTypeRoots;

/**

* Returns the path to every node_modules/@types directory from some ancestor directory.

* Returns undefined if there are none.

*/

function getDefaultTypeRoots(currentDirectory) {

var typeRoots;

(0, ts_1.forEachAncestorDirectory)((0, ts_1.normalizePath)(currentDirectory), function (directory) {

var atTypes = (0, ts_1.combinePaths)(directory, nodeModulesAtTypes);

(typeRoots !== null && typeRoots !== void 0 ? typeRoots : (typeRoots = [])).push(atTypes);

});

return typeRoots;

}

var nodeModulesAtTypes = (0, ts_1.combinePaths)("node_modules", "@types");

function arePathsEqual(path1, path2, host) {

var useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;

return (0, ts_1.comparePaths)(path1, path2, !useCaseSensitiveFileNames) === 0 /* Comparison.EqualTo */;

}

function getOriginalAndResolvedFileName(fileName, host, traceEnabled) {

var resolvedFileName = realPath(fileName, host, traceEnabled);

var pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host);

return {

// If the fileName and realpath are differing only in casing prefer fileName so that we can issue correct errors for casing under forceConsistentCasingInFileNames

resolvedFileName: pathsAreEqual ? fileName : resolvedFileName,

originalPath: pathsAreEqual ? undefined : fileName,

};

}

function getCandidateFromTypeRoot(typeRoot, typeReferenceDirectiveName, moduleResolutionState) {

var nameForLookup = (0, ts_1.endsWith)(typeRoot, "/node_modules/@types") || (0, ts_1.endsWith)(typeRoot, "/node_modules/@types/") ?

mangleScopedPackageNameWithTrace(typeReferenceDirectiveName, moduleResolutionState) :

typeReferenceDirectiveName;

return (0, ts_1.combinePaths)(typeRoot, nameForLookup);

}

/**

* @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.

* This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups

* is assumed to be the same as root directory of the project.

*/

function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache, resolutionMode) {

var _a;

ts_1.Debug.assert(typeof typeReferenceDirectiveName === "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself.");

var traceEnabled = isTraceEnabled(options, host);

if (redirectedReference) {

options = redirectedReference.commandLine.options;

}

var containingDirectory = containingFile ? (0, ts_1.getDirectoryPath)(containingFile) : undefined;

var result = containingDirectory ? cache === null || cache === void 0 ? void 0 : cache.getFromDirectoryCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference) : undefined;

if (!result && containingDirectory && !(0, ts_1.isExternalModuleNameRelative)(typeReferenceDirectiveName)) {

result = cache === null || cache === void 0 ? void 0 : cache.getFromNonRelativeNameCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference);

}

if (result) {

if (traceEnabled) {

trace(host, ts_1.Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile);

if (redirectedReference)

trace(host, ts_1.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);

trace(host, ts_1.Diagnostics.Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1, typeReferenceDirectiveName, containingDirectory);

traceResult(result);

}

return result;

}

var typeRoots = getEffectiveTypeRoots(options, host);

if (traceEnabled) {

if (containingFile === undefined) {

if (typeRoots === undefined) {

trace(host, ts_1.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);

}

else {

trace(host, ts_1.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);

}

}

else {

if (typeRoots === undefined) {

trace(host, ts_1.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);

}

else {

trace(host, ts_1.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);

}

}

if (redirectedReference) {

trace(host, ts_1.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);

}

}

var failedLookupLocations = [];

var affectingLocations = [];

var features = getNodeResolutionFeatures(options);

// Unlike `import` statements, whose mode-calculating APIs are all guaranteed to return `undefined` if we're in an un-mode-ed module resolution

// setting, type references will return their target mode regardless of options because of how the parser works, so we guard against the mode being

// set in a non-modal module resolution setting here. Do note that our behavior is not particularly well defined when these mode-overriding imports

// are present in a non-modal project; while in theory we'd like to either ignore the mode or provide faithful modern resolution, depending on what we feel is best,

// in practice, not every cache has the options available to intelligently make the choice to ignore the mode request, and it's unclear how modern "faithful modern

// resolution" should be (`node16`? `nodenext`?). As such, witnessing a mode-overriding triple-slash reference in a non-modal module resolution

// context should _probably_ be an error - and that should likely be handled by the `Program` (which is what we do).

if (resolutionMode === ts_1.ModuleKind.ESNext && ((0, ts_1.getEmitModuleResolutionKind)(options) === ts_1.ModuleResolutionKind.Node16 || (0, ts_1.getEmitModuleResolutionKind)(options) === ts_1.ModuleResolutionKind.NodeNext)) {

features |= NodeResolutionFeatures.EsmMode;

}

var conditions = features & NodeResolutionFeatures.Exports ? getConditions(options, !!(features & NodeResolutionFeatures.EsmMode)) : [];

var diagnostics = [];

var moduleResolutionState = {

compilerOptions: options,

host: host,

traceEnabled: traceEnabled,

failedLookupLocations: failedLookupLocations,

affectingLocations: affectingLocations,

packageJsonInfoCache: cache,

features: features,

conditions: conditions,

requestContainingDirectory: containingDirectory,

reportDiagnostic: function (diag) { return void diagnostics.push(diag); },

isConfigLookup: false,

candidateIsFromPackageJsonField: false,

};

var resolved = primaryLookup();

var primary = true;

if (!resolved) {

resolved = secondaryLookup();

primary = false;

}

var resolvedTypeReferenceDirective;

if (resolved) {

var fileName = resolved.fileName, packageId = resolved.packageId;

var resolvedFileName = fileName, originalPath = void 0;

if (!options.preserveSymlinks)

(_a = getOriginalAndResolvedFileName(fileName, host, traceEnabled), resolvedFileName = _a.resolvedFileName, originalPath = _a.originalPath);

resolvedTypeReferenceDirective = {

primary: primary,

resolvedFileName: resolvedFileName,

originalPath: originalPath,

packageId: packageId,

isExternalLibraryImport: pathContainsNodeModules(fileName),

};

}

result = {

resolvedTypeReferenceDirective: resolvedTypeReferenceDirective,

failedLookupLocations: initializeResolutionField(failedLookupLocations),

affectingLocations: initializeResolutionField(affectingLocations),

resolutionDiagnostics: initializeResolutionField(diagnostics),

};

if (containingDirectory) {

cache === null || cache === void 0 ? void 0 : cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result);

if (!(0, ts_1.isExternalModuleNameRelative)(typeReferenceDirectiveName)) {

cache === null || cache === void 0 ? void 0 : cache.getOrCreateCacheForNonRelativeName(typeReferenceDirectiveName, resolutionMode, redirectedReference).set(containingDirectory, result);

}

}

if (traceEnabled)

traceResult(result);

return result;

function traceResult(result) {

var _a;

if (!((_a = result.resolvedTypeReferenceDirective) === null || _a === void 0 ? void 0 : _a.resolvedFileName)) {

trace(host, ts_1.Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);

}

else if (result.resolvedTypeReferenceDirective.packageId) {

trace(host, ts_1.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, (0, ts_1.packageIdToString)(result.resolvedTypeReferenceDirective.packageId), result.resolvedTypeReferenceDirective.primary);

}

else {

trace(host, ts_1.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, result.resolvedTypeReferenceDirective.primary);

}

}

function primaryLookup() {

// Check primary library paths

if (typeRoots && typeRoots.length) {

if (traceEnabled) {

trace(host, ts_1.Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));

}

return (0, ts_1.firstDefined)(typeRoots, function (typeRoot) {

var candidate = getCandidateFromTypeRoot(typeRoot, typeReferenceDirectiveName, moduleResolutionState);

var directoryExists = (0, ts_1.directoryProbablyExists)(typeRoot, host);

if (!directoryExists && traceEnabled) {

trace(host, ts_1.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);

}

if (options.typeRoots) {

// Custom typeRoots resolve as file or directory just like we do modules

var resolvedFromFile = loadModuleFromFile(4 /* Extensions.Declaration */, candidate, !directoryExists, moduleResolutionState);

if (resolvedFromFile) {

var packageDirectory = parseNodeModuleFromPath(resolvedFromFile.path);

var packageInfo = packageDirectory ? getPackageJsonInfo(packageDirectory, /*onlyRecordFailures*/ false, moduleResolutionState) : undefined;

return resolvedTypeScriptOnly(withPackageId(packageInfo, resolvedFromFile));

}

}

return resolvedTypeScriptOnly(loadNodeModuleFromDirectory(4 /* Extensions.Declaration */, candidate, !directoryExists, moduleResolutionState));

});

}

else {

if (traceEnabled) {

trace(host, ts_1.Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);

}

}

}

function secondaryLookup() {

var initialLocationForSecondaryLookup = containingFile && (0, ts_1.getDirectoryPath)(containingFile);

if (initialLocationForSecondaryLookup !== undefined) {

var result_1;

if (!options.typeRoots || !(0, ts_1.endsWith)(containingFile, ts_1.inferredTypesContainingFile)) {

// check secondary locations

if (traceEnabled) {

trace(host, ts_1.Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);

}

if (!(0, ts_1.isExternalModuleNameRelative)(typeReferenceDirectiveName)) {

var searchResult = loadModuleFromNearestNodeModulesDirectory(4 /* Extensions.Declaration */, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, /*cache*/ undefined, /*redirectedReference*/ undefined);

result_1 = searchResult && searchResult.value;

}

else {

var candidate = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName).path;

result_1 = nodeLoadModuleByRelativeName(4 /* Extensions.Declaration */, candidate, /*onlyRecordFailures*/ false, moduleResolutionState, /*considerPackageJson*/ true);

}

}

else if (traceEnabled) {

trace(host, ts_1.Diagnostics.Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder);

}

return resolvedTypeScriptOnly(result_1);

}

else {

if (traceEnabled) {

trace(host, ts_1.Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);

}

}

}

}

exports.resolveTypeReferenceDirective = resolveTypeReferenceDirective;

function getNodeResolutionFeatures(options) {

var features = NodeResolutionFeatures.None;

switch ((0, ts_1.getEmitModuleResolutionKind)(options)) {

case ts_1.ModuleResolutionKind.Node16:

features = NodeResolutionFeatures.Node16Default;

break;

case ts_1.ModuleResolutionKind.NodeNext:

features = NodeResolutionFeatures.NodeNextDefault;

break;

case ts_1.ModuleResolutionKind.Bundler:

features = NodeResolutionFeatures.BundlerDefault;

break;

}

if (options.resolvePackageJsonExports) {

features |= NodeResolutionFeatures.Exports;

}

else if (options.resolvePackageJsonExports === false) {

features &= ~NodeResolutionFeatures.Exports;

}

if (options.resolvePackageJsonImports) {

features |= NodeResolutionFeatures.Imports;

}

else if (options.resolvePackageJsonImports === false) {

features &= ~NodeResolutionFeatures.Imports;

}

return features;

}

/** @internal */

function getConditions(options, esmMode) {

// conditions are only used by the node16/nodenext/bundler resolvers - there's no priority order in the list,

// it's essentially a set (priority is determined by object insertion order in the object we look at).

var conditions = esmMode || (0, ts_1.getEmitModuleResolutionKind)(options) === ts_1.ModuleResolutionKind.Bundler

? ["import"]

: ["require"];

if (!options.noDtsResolution) {

conditions.push("types");

}

if ((0, ts_1.getEmitModuleResolutionKind)(options) !== ts_1.ModuleResolutionKind.Bundler) {

conditions.push("node");

}

return (0, ts_1.concatenate)(conditions, options.customConditions);

}

exports.getConditions = getConditions;

/**

* @internal

* Does not try `@types/${packageName}` - use a second pass if needed.

*/

function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) {

var moduleResolutionState = getTemporaryModuleResolutionState(cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(), host, options);

return (0, ts_1.forEachAncestorDirectory)(containingDirectory, function (ancestorDirectory) {

if ((0, ts_1.getBaseFileName)(ancestorDirectory) !== "node_modules") {

var nodeModulesFolder = (0, ts_1.combinePaths)(ancestorDirectory, "node_modules");

var candidate = (0, ts_1.combinePaths)(nodeModulesFolder, packageName);

return getPackageJsonInfo(candidate, /*onlyRecordFailures*/ false, moduleResolutionState);

}

});

}

exports.resolvePackageNameToPackageJson = resolvePackageNameToPackageJson;

/**

* Given a set of options, returns the set of type directive names

* that should be included for this program automatically.

* This list could either come from the config file,

* or from enumerating the types root + initial secondary types lookup location.

* More type directives might appear in the program later as a result of loading actual source files;

* this list is only the set of defaults that are implicitly included.

*/

function getAutomaticTypeDirectiveNames(options, host) {

// Use explicit type list from tsconfig.json

if (options.types) {

return options.types;

}

// Walk the primary type lookup locations

var result = [];

if (host.directoryExists && host.getDirectories) {

var typeRoots = getEffectiveTypeRoots(options, host);

if (typeRoots) {

for (var _i = 0, typeRoots_1 = typeRoots; _i < typeRoots_1.length; _i++) {

var root = typeRoots_1[_i];

if (host.directoryExists(root)) {

for (var _a = 0, _b = host.getDirectories(root); _a < _b.length; _a++) {

var typeDirectivePath = _b[_a];

var normalized = (0, ts_1.normalizePath)(typeDirectivePath);

var packageJsonPath = (0, ts_1.combinePaths)(root, normalized, "package.json");

// `types-publisher` sometimes creates packages with `"typings": null` for packages that don't provide their own types.

// See `createNotNeededPackageJSON` in the types-publisher` repo.

// eslint-disable-next-line no-null/no-null

var isNotNeededPackage = host.fileExists(packageJsonPath) && (0, ts_1.readJson)(packageJsonPath, host).typings === null;

if (!isNotNeededPackage) {

var baseFileName = (0, ts_1.getBaseFileName)(normalized);

// At this stage, skip results with leading dot.

if (baseFileName.charCodeAt(0) !== 46 /* CharacterCodes.dot */) {

// Return just the type directive names

result.push(baseFileName);

}

}

}

}

}

}

}

return result;

}

exports.getAutomaticTypeDirectiveNames = getAutomaticTypeDirectiveNames;

function compilerOptionValueToString(value) {

var _a;

if (value === null || typeof value !== "object") { // eslint-disable-line no-null/no-null

return "" + value;

}

if ((0, ts_1.isArray)(value)) {

return "[".concat((_a = value.map(function (e) { return compilerOptionValueToString(e); })) === null || _a === void 0 ? void 0 : _a.join(","), "]");

}

var str = "{";

for (var key in value) {

if ((0, ts_1.hasProperty)(value, key)) {

str += "".concat(key, ": ").concat(compilerOptionValueToString(value[key]));

}

}

return str + "}";

}

/** @internal */

function getKeyForCompilerOptions(options, affectingOptionDeclarations) {

return affectingOptionDeclarations.map(function (option) { return compilerOptionValueToString((0, ts_1.getCompilerOptionValue)(options, option)); }).join("|") + "|".concat(options.pathsBasePath);

}

exports.getKeyForCompilerOptions = getKeyForCompilerOptions;

/** @internal */

function createCacheWithRedirects(ownOptions) {

var redirectsMap = new Map();

var optionsToRedirectsKey = new Map();

var redirectsKeyToMap = new Map();

var ownMap = new Map();

if (ownOptions)

redirectsMap.set(ownOptions, ownMap);

return {

getMapOfCacheRedirects: getMapOfCacheRedirects,

getOrCreateMapOfCacheRedirects: getOrCreateMapOfCacheRedirects,

update: update,

clear: clear,

};

function getMapOfCacheRedirects(redirectedReference) {

return redirectedReference ?

getOrCreateMap(redirectedReference.commandLine.options, /*create*/ false) :

ownMap;

}

function getOrCreateMapOfCacheRedirects(redirectedReference) {

return redirectedReference ?

getOrCreateMap(redirectedReference.commandLine.options, /*create*/ true) :

ownMap;

}

function update(newOptions) {

if (ownOptions !== newOptions) {

if (ownOptions)

ownMap = getOrCreateMap(newOptions, /*create*/ true); // set new map for new options as ownMap

else

redirectsMap.set(newOptions, ownMap); // Use existing map if oldOptions = undefined

ownOptions = newOptions;

}

}

function getOrCreateMap(redirectOptions, create) {

var result = redirectsMap.get(redirectOptions);

if (result)

return result;

var key = getRedirectsCacheKey(redirectOptions);

result = redirectsKeyToMap.get(key);

if (!result) {

if (ownOptions) {

var ownKey = getRedirectsCacheKey(ownOptions);

if (ownKey === key)

result = ownMap;

else if (!redirectsKeyToMap.has(ownKey))

redirectsKeyToMap.set(ownKey, ownMap);

}

if (create)

result !== null && result !== void 0 ? result : (result = new Map());

if (result)

redirectsKeyToMap.set(key, result);

}

if (result)

redirectsMap.set(redirectOptions, result);

return result;

}

function clear() {

var ownKey = ownOptions && optionsToRedirectsKey.get(ownOptions);

ownMap.clear();

redirectsMap.clear();

optionsToRedirectsKey.clear();

redirectsKeyToMap.clear();

if (ownOptions) {

if (ownKey)

optionsToRedirectsKey.set(ownOptions, ownKey);

redirectsMap.set(ownOptions, ownMap);

}

}

function getRedirectsCacheKey(options) {

var result = optionsToRedirectsKey.get(options);

if (!result) {

optionsToRedirectsKey.set(options, result = getKeyForCompilerOptions(options, ts_1.moduleResolutionOptionDeclarations));

}

return result;

}

}

exports.createCacheWithRedirects = createCacheWithRedirects;

function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {

var cache;

return { getPackageJsonInfo: getPackageJsonInfo, setPackageJsonInfo: setPackageJsonInfo, clear: clear, entries: entries, getInternalMap: getInternalMap };

function getPackageJsonInfo(packageJsonPath) {

return cache === null || cache === void 0 ? void 0 : cache.get((0, ts_1.toPath)(packageJsonPath, currentDirectory, getCanonicalFileName));

}

function setPackageJsonInfo(packageJsonPath, info) {

(cache || (cache = new Map())).set((0, ts_1.toPath)(packageJsonPath, currentDirectory, getCanonicalFileName), info);

}

function clear() {

cache = undefined;

}

function entries() {

var iter = cache === null || cache === void 0 ? void 0 : cache.entries();

return iter ? (0, ts_1.arrayFrom)(iter) : [];

}

function getInternalMap() {

return cache;

}

}

function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {

var cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);

var result = cache.get(key);

if (!result) {

result = create();

cache.set(key, result);

}

return result;

}

function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, options) {

var directoryToModuleNameMap = createCacheWithRedirects(options);

return {

getFromDirectoryCache: getFromDirectoryCache,

getOrCreateCacheForDirectory: getOrCreateCacheForDirectory,

clear: clear,

update: update,

};

function clear() {

directoryToModuleNameMap.clear();

}

function update(options) {

directoryToModuleNameMap.update(options);

}

function getOrCreateCacheForDirectory(directoryName, redirectedReference) {

var path = (0, ts_1.toPath)(directoryName, currentDirectory, getCanonicalFileName);

return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, function () { return createModeAwareCache(); });

}

function getFromDirectoryCache(name, mode, directoryName, redirectedReference) {

var _a, _b;

var path = (0, ts_1.toPath)(directoryName, currentDirectory, getCanonicalFileName);

return (_b = (_a = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) === null || _a === void 0 ? void 0 : _a.get(path)) === null || _b === void 0 ? void 0 : _b.get(name, mode);

}

}

/** @internal */

function createModeAwareCacheKey(specifier, mode) {

return (mode === undefined ? specifier : "".concat(mode, "|").concat(specifier));

}

exports.createModeAwareCacheKey = createModeAwareCacheKey;

/** @internal */

function createModeAwareCache() {

var underlying = new Map();

var memoizedReverseKeys = new Map();

var cache = {

get: function (specifier, mode) {

return underlying.get(getUnderlyingCacheKey(specifier, mode));

},

set: function (specifier, mode, value) {

underlying.set(getUnderlyingCacheKey(specifier, mode), value);

return cache;

},

delete: function (specifier, mode) {

underlying.delete(getUnderlyingCacheKey(specifier, mode));

return cache;

},

has: function (specifier, mode) {

return underlying.has(getUnderlyingCacheKey(specifier, mode));

},

forEach: function (cb) {

return underlying.forEach(function (elem, key) {

var _a = memoizedReverseKeys.get(key), specifier = _a[0], mode = _a[1];

return cb(elem, specifier, mode);

});

},

size: function () {

return underlying.size;

}

};

return cache;

function getUnderlyingCacheKey(specifier, mode) {

var result = createModeAwareCacheKey(specifier, mode);

memoizedReverseKeys.set(result, [specifier, mode]);

return result;

}

}

exports.createModeAwareCache = createModeAwareCache;

/** @internal */

function zipToModeAwareCache(file, keys, values, nameAndModeGetter) {

ts_1.Debug.assert(keys.length === values.length);

var map = createModeAwareCache();

for (var i = 0; i < keys.length; ++i) {

var entry = keys[i];

map.set(nameAndModeGetter.getName(entry), nameAndModeGetter.getMode(entry, file), values[i]);

}

return map;

}

exports.zipToModeAwareCache = zipToModeAwareCache;

function getOriginalOrResolvedModuleFileName(result) {

return result.resolvedModule && (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);

}

function getOriginalOrResolvedTypeReferenceFileName(result) {

return result.resolvedTypeReferenceDirective &&

(result.resolvedTypeReferenceDirective.originalPath || result.resolvedTypeReferenceDirective.resolvedFileName);

}

function createNonRelativeNameResolutionCache(currentDirectory, getCanonicalFileName, options, getResolvedFileName) {

var moduleNameToDirectoryMap = createCacheWithRedirects(options);

return {

getFromNonRelativeNameCache: getFromNonRelativeNameCache,

getOrCreateCacheForNonRelativeName: getOrCreateCacheForNonRelativeName,

clear: clear,

update: update,

};

function clear() {

moduleNameToDirectoryMap.clear();

}

function update(options) {

moduleNameToDirectoryMap.update(options);

}

function getFromNonRelativeNameCache(nonRelativeModuleName, mode, directoryName, redirectedReference) {

var _a, _b;

ts_1.Debug.assert(!(0, ts_1.isExternalModuleNameRelative)(nonRelativeModuleName));

return (_b = (_a = moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)) === null || _a === void 0 ? void 0 : _a.get(createModeAwareCacheKey(nonRelativeModuleName, mode))) === null || _b === void 0 ? void 0 : _b.get(directoryName);

}

function getOrCreateCacheForNonRelativeName(nonRelativeModuleName, mode, redirectedReference) {

ts_1.Debug.assert(!(0, ts_1.isExternalModuleNameRelative)(nonRelativeModuleName));

return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, createModeAwareCacheKey(nonRelativeModuleName, mode), createPerModuleNameCache);

}

function createPerModuleNameCache() {

var directoryPathMap = new Map();

return { get: get, set: set };

function get(directory) {

return directoryPathMap.get((0, ts_1.toPath)(directory, currentDirectory, getCanonicalFileName));

}

/**

* At first this function add entry directory -> module resolution result to the table.

* Then it computes the set of parent folders for 'directory' that should have the same module resolution result

* and for every parent folder in set it adds entry: parent -> module resolution. .

* Lets say we first directory name: /a/b/c/d/e and resolution result is: /a/b/bar.ts.

* Set of parent folders that should have the same result will be:

* [

* /a/b/c/d, /a/b/c, /a/b

* ]

* this means that request for module resolution from file in any of these folder will be immediately found in cache.

*/

function set(directory, result) {

var path = (0, ts_1.toPath)(directory, currentDirectory, getCanonicalFileName);

// if entry is already in cache do nothing

if (directoryPathMap.has(path)) {

return;

}

directoryPathMap.set(path, result);

var resolvedFileName = getResolvedFileName(result);

// find common prefix between directory and resolved file name

// this common prefix should be the shortest path that has the same resolution

// directory: /a/b/c/d/e

// resolvedFileName: /a/b/foo.d.ts

// commonPrefix: /a/b

// for failed lookups cache the result for every directory up to root

var commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName);

var current = path;

while (current !== commonPrefix) {

var parent_1 = (0, ts_1.getDirectoryPath)(current);

if (parent_1 === current || directoryPathMap.has(parent_1)) {

break;

}

directoryPathMap.set(parent_1, result);

current = parent_1;

}

}

function getCommonPrefix(directory, resolution) {

var resolutionDirectory = (0, ts_1.toPath)((0, ts_1.getDirectoryPath)(resolution), currentDirectory, getCanonicalFileName);

// find first position where directory and resolution differs

var i = 0;

var limit = Math.min(directory.length, resolutionDirectory.length);

while (i < limit && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) {

i++;

}

if (i === directory.length && (resolutionDirectory.length === i || resolutionDirectory[i] === ts_1.directorySeparator)) {

return directory;

}

var rootLength = (0, ts_1.getRootLength)(directory);

if (i < rootLength) {

return undefined;

}

var sep = directory.lastIndexOf(ts_1.directorySeparator, i - 1);

if (sep === -1) {

return undefined;

}

return directory.substr(0, Math.max(sep, rootLength));

}

}

}

function createModuleOrTypeReferenceResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, getResolvedFileName) {

var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, options);

var nonRelativeNameResolutionCache = createNonRelativeNameResolutionCache(currentDirectory, getCanonicalFileName, options, getResolvedFileName);

packageJsonInfoCache !== null && packageJsonInfoCache !== void 0 ? packageJsonInfoCache : (packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName));

return __assign(__assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), nonRelativeNameResolutionCache), { clear: clear, update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; }, clearAllExceptPackageJsonInfoCache: clearAllExceptPackageJsonInfoCache });

function clear() {

clearAllExceptPackageJsonInfoCache();

packageJsonInfoCache.clear();

}

function clearAllExceptPackageJsonInfoCache() {

perDirectoryResolutionCache.clear();

nonRelativeNameResolutionCache.clear();

}

function update(options) {

perDirectoryResolutionCache.update(options);

nonRelativeNameResolutionCache.update(options);

}

}

function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache) {

var result = createModuleOrTypeReferenceResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, getOriginalOrResolvedModuleFileName);

result.getOrCreateCacheForModuleName = function (nonRelativeName, mode, redirectedReference) { return result.getOrCreateCacheForNonRelativeName(nonRelativeName, mode, redirectedReference); };

return result;

}

exports.createModuleResolutionCache = createModuleResolutionCache;

function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache) {

return createModuleOrTypeReferenceResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, getOriginalOrResolvedTypeReferenceFileName);

}

exports.createTypeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache;

/** @internal */

function getOptionsForLibraryResolution(options) {

return { moduleResolution: ts_1.ModuleResolutionKind.Node10, traceResolution: options.traceResolution };

}

exports.getOptionsForLibraryResolution = getOptionsForLibraryResolution;

/** @internal */

function resolveLibrary(libraryName, resolveFrom, compilerOptions, host, cache) {

return resolveModuleName(libraryName, resolveFrom, getOptionsForLibraryResolution(compilerOptions), host, cache);

}

exports.resolveLibrary = resolveLibrary;

function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) {

var containingDirectory = (0, ts_1.getDirectoryPath)(containingFile);

return cache.getFromDirectoryCache(moduleName, mode, containingDirectory, /*redirectedReference*/ undefined);

}

exports.resolveModuleNameFromCache = resolveModuleNameFromCache;

function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {

var traceEnabled = isTraceEnabled(compilerOptions, host);

if (redirectedReference) {

compilerOptions = redirectedReference.commandLine.options;

}

if (traceEnabled) {

trace(host, ts_1.Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);

if (redirectedReference) {

trace(host, ts_1.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);

}

}

var containingDirectory = (0, ts_1.getDirectoryPath)(containingFile);

var result = cache === null || cache === void 0 ? void 0 : cache.getFromDirectoryCache(moduleName, resolutionMode, containingDirectory, redirectedReference);

if (result) {

if (traceEnabled) {

trace(host, ts_1.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);

}

}

else {

var moduleResolution = compilerOptions.moduleResolution;

if (moduleResolution === undefined) {

switch ((0, ts_1.getEmitModuleKind)(compilerOptions)) {

case ts_1.ModuleKind.CommonJS:

moduleResolution = ts_1.ModuleResolutionKind.Node10;

break;

case ts_1.ModuleKind.Node16:

moduleResolution = ts_1.ModuleResolutionKind.Node16;

break;

case ts_1.ModuleKind.NodeNext:

moduleResolution = ts_1.ModuleResolutionKind.NodeNext;

break;

default:

moduleResolution = ts_1.ModuleResolutionKind.Classic;

break;

}

if (traceEnabled) {

trace(host, ts_1.Diagnostics.Module_resolution_kind_is_not_specified_using_0, ts_1.ModuleResolutionKind[moduleResolution]);

}

}

else {

if (traceEnabled) {

trace(host, ts_1.Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ts_1.ModuleResolutionKind[moduleResolution]);

}

}

ts_1.perfLogger === null || ts_1.perfLogger === void 0 ? void 0 : ts_1.perfLogger.logStartResolveModule(moduleName /* , containingFile, ModuleResolutionKind[moduleResolution]*/);

switch (moduleResolution) {

case ts_1.ModuleResolutionKind.Node16:

result = node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);

break;

case ts_1.ModuleResolutionKind.NodeNext:

result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);

break;

case ts_1.ModuleResolutionKind.Node10:

result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);

break;

case ts_1.ModuleResolutionKind.Classic:

result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);

break;

case ts_1.ModuleResolutionKind.Bundler:

result = bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);

break;

default:

return ts_1.Debug.fail("Unexpected moduleResolution: ".concat(moduleResolution));

}

if (result && result.resolvedModule)

ts_1.perfLogger === null || ts_1.perfLogger === void 0 ? void 0 : ts_1.perfLogger.logInfoEvent("Module \"".concat(moduleName, "\" resolved to \"").concat(result.resolvedModule.resolvedFileName, "\""));

ts_1.perfLogger === null || ts_1.perfLogger === void 0 ? void 0 : ts_1.perfLogger.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null");

cache === null || cache === void 0 ? void 0 : cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(moduleName, resolutionMode, result);

if (!(0, ts_1.isExternalModuleNameRelative)(moduleName)) {

// put result in per-module name cache

cache === null || cache === void 0 ? void 0 : cache.getOrCreateCacheForNonRelativeName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);

}

}

if (traceEnabled) {

if (result.resolvedModule) {

if (result.resolvedModule.packageId) {

trace(host, ts_1.Diagnostics.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2, moduleName, result.resolvedModule.resolvedFileName, (0, ts_1.packageIdToString)(result.resolvedModule.packageId));

}

else {

trace(host, ts_1.Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);

}

}

else {

trace(host, ts_1.Diagnostics.Module_name_0_was_not_resolved, moduleName);

}

}

return result;

}

exports.resolveModuleName = resolveModuleName;

/**

* Any module resolution kind can be augmented with optional settings: 'baseUrl', 'paths' and 'rootDirs' - they are used to

* mitigate differences between design time structure of the project and its runtime counterpart so the same import name

* can be resolved successfully by TypeScript compiler and runtime module loader.

* If these settings are set then loading procedure will try to use them to resolve module name and it can of failure it will

* fallback to standard resolution routine.

*

* - baseUrl - this setting controls how non-relative module names are resolved. If this setting is specified then non-relative