Updating NPM dependencies

node_modules/ts-jest/dist/cli/config/init.js

@@ -47,6 +47,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.run = void 0;
 var fs_1 = require("fs");
 var json5_1 = require("json5");
 var path_1 = require("path");
@@ -122,19 +123,19 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
                 content.push("  preset: '" + preset.name + "',");
             }
             else {
-                content.push("  ...tsjPreset,");
+                content.push('  ...tsjPreset,');
             }
             if (!jsdom)
                 content.push("  testEnvironment: 'node',");
             if (tsconfig || shouldPostProcessWithBabel) {
-                content.push("  globals: {");
+                content.push('  globals: {');
                 content.push("    'ts-jest': {");
                 if (tsconfig)
                     content.push("      tsconfig: " + json5_1.stringify(tsconfig) + ",");
                 if (shouldPostProcessWithBabel)
-                    content.push("      babelConfig: true,");
-                content.push("    },");
-                content.push("  },");
+                    content.push('      babelConfig: true,');
+                content.push('    },');
+                content.push('  },');
             }
             content.push('};');
             body = content.join('\n');

node_modules/ts-jest/dist/cli/config/migrate.js

@@ -56,12 +56,13 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.run = void 0;
 var bs_logger_1 = require("bs-logger");
-var stringifyJson = require("fast-json-stable-stringify");
+var stableStringify = require("fast-json-stable-stringify");
 var fs_1 = require("fs");
 var json5_1 = require("json5");
 var path_1 = require("path");
-var backports_1 = require("../../util/backports");
+var backports_1 = require("../../utils/backports");
 var presets_1 = require("../helpers/presets");
 exports.run = function (args) { return __awaiter(void 0, void 0, void 0, function () {
     var nullLogger, file, filePath, footNotes, name, isPackage, actualConfig, migratedConfig, presetName, preset, jsTransformers, jsWithTs, jsWithBabel, presetValue, migratedValue, presetValue, migratedValue, before, after, stringify, prefix;
@@ -87,7 +88,7 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
         migratedConfig = backports_1.backportJestConfig(nullLogger, actualConfig);
         if (!migratedConfig.preset && args.jestPreset) {
             if (args.js) {
-                presetName = args.js === 'babel' ? presets_1.JestPresetNames.jsWIthBabel : presets_1.JestPresetNames.jsWithTs;
+                presetName = args.js === 'babel' ? "ts-jest/presets/js-with-babel" : "ts-jest/presets/js-with-ts";
             }
             else {
                 jsTransformers = Object.keys(migratedConfig.transform || {}).reduce(function (list, pattern) {
@@ -104,16 +105,16 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
                 jsWithTs = jsTransformers.includes('ts-jest');
                 jsWithBabel = jsTransformers.includes('babel-jest');
                 if (jsWithBabel && !jsWithTs) {
-                    presetName = presets_1.JestPresetNames.jsWIthBabel;
+                    presetName = "ts-jest/presets/js-with-babel";
                 }
                 else if (jsWithTs && !jsWithBabel) {
-                    presetName = presets_1.JestPresetNames.jsWithTs;
+                    presetName = "ts-jest/presets/js-with-ts";
                 }
                 else {
-                    presetName = presets_1.JestPresetNames.default;
+                    presetName = "ts-jest/presets/default";
                 }
             }
-            presetName = presetName || presets_1.JestPresetNames.default;
+            presetName = presetName || "ts-jest/presets/default";
             preset = presets_1.allPresets[presetName];
             footNotes.push("Detected preset '" + preset.label + "' as the best matching preset for your configuration.\nVisit https://kulshekhar.github.io/ts-jest/user/config/#jest-preset for more information about presets.\n");
         }
@@ -155,19 +156,19 @@ exports.run = function (args) { return __awaiter(void 0, void 0, void 0, functio
         }
         if (preset &&
             migratedConfig.transform &&
-            stringifyJson(migratedConfig.transform) === stringifyJson(preset.value.transform)) {
+            stableStringify(migratedConfig.transform) === stableStringify(preset.value.transform)) {
             delete migratedConfig.transform;
         }
         cleanupConfig(actualConfig);
         cleanupConfig(migratedConfig);
-        before = stringifyJson(actualConfig);
-        after = stringifyJson(migratedConfig);
+        before = stableStringify(actualConfig);
+        after = stableStringify(migratedConfig);
         if (after === before) {
             process.stderr.write("\nNo migration needed for given Jest configuration\n    ");
             return [2];
         }
-        stringify = /\.json$/.test(file) ? JSON.stringify : json5_1.stringify;
-        prefix = /\.json$/.test(file) ? '"jest": ' : 'module.exports = ';
+        stringify = file.endsWith('.json') ? JSON.stringify : json5_1.stringify;
+        prefix = file.endsWith('.json') ? '"jest": ' : 'module.exports = ';
         if (preset && migratedConfig.transform) {
             footNotes.push("\nI couldn't check if your \"transform\" value is the same as mine which is: " + stringify(preset.value.transform, undefined, '  ') + "\nIf it is the case, you can safely remove the \"transform\" from what I've migrated.\n");
         }
@@ -201,7 +202,7 @@ function cleanupConfig(config) {
         if (config.testMatch.length === 0)
             delete config.testMatch;
     }
-    if (config.preset === presets_1.JestPresetNames.default)
+    if (config.preset === "ts-jest/presets/default")
         config.preset = presets_1.defaults.name;
 }
 function dedupSort(arr) {

node_modules/ts-jest/dist/cli/help.js

@@ -36,6 +36,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.run = void 0;
 exports.run = function (_) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         process.stdout.write("\nUsage:\n  ts-jest command [options] [...args]\n\nCommands:\n  config:init           Creates initial Jest configuration\n  config:migrate        Migrates a given Jest configuration\n  help [command]        Show this help, or help about a command\n\nExample:\n  ts-jest help config:migrate\n");

node_modules/ts-jest/dist/cli/helpers/presets.js

@@ -1,11 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var JestPresetNames;
-(function (JestPresetNames) {
-    JestPresetNames["default"] = "ts-jest/presets/default";
-    JestPresetNames["jsWithTs"] = "ts-jest/presets/js-with-ts";
-    JestPresetNames["jsWIthBabel"] = "ts-jest/presets/js-with-babel";
-})(JestPresetNames = exports.JestPresetNames || (exports.JestPresetNames = {}));
+exports.jsWIthBabel = exports.jsWithTs = exports.defaults = exports.allPresets = void 0;
 var definePreset = function (fullName) { return ({
     fullName: fullName,
     get name() {
@@ -17,10 +12,11 @@ var definePreset = function (fullName) { return ({
     get jsVarName() {
         return this.isDefault
             ? 'defaults'
-            : fullName
-                .split('/')
-                .pop()
-                .replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
+            :
+                fullName
+                    .split('/')
+                    .pop()
+                    .replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
     },
     get value() {
         return require("../../../" + fullName.replace(/^ts-jest\//, '') + "/jest-preset");
@@ -30,10 +26,10 @@ var definePreset = function (fullName) { return ({
         return "const { " + this.jsVarName + ": " + varName + " } = require('ts-jest/presets')";
     },
     get isDefault() {
-        return fullName === JestPresetNames.default;
+        return fullName === "ts-jest/presets/default";
     },
 }); };
 exports.allPresets = {};
-exports.defaults = (exports.allPresets[JestPresetNames.default] = definePreset(JestPresetNames.default));
-exports.jsWithTs = (exports.allPresets[JestPresetNames.jsWithTs] = definePreset(JestPresetNames.jsWithTs));
-exports.jsWIthBabel = (exports.allPresets[JestPresetNames.jsWIthBabel] = definePreset(JestPresetNames.jsWIthBabel));
+exports.defaults = (exports.allPresets["ts-jest/presets/default"] = definePreset("ts-jest/presets/default"));
+exports.jsWithTs = (exports.allPresets["ts-jest/presets/js-with-ts"] = definePreset("ts-jest/presets/js-with-ts"));
+exports.jsWIthBabel = (exports.allPresets["ts-jest/presets/js-with-babel"] = definePreset("ts-jest/presets/js-with-babel"));

node_modules/ts-jest/dist/cli/index.js

@@ -35,18 +35,22 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.processArgv = void 0;
 var bs_logger_1 = require("bs-logger");
-var yargsParser = require("yargs-parser");
-var logger_1 = require("../util/logger");
+var yargs_parser_1 = __importDefault(require("yargs-parser"));
+var logger_1 = require("../utils/logger");
 var VALID_COMMANDS = ['help', 'config:migrate', 'config:init'];
 var logger = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'cli', _a[bs_logger_1.LogContexts.application] = 'ts-jest', _a));
 function cli(args) {
     return __awaiter(this, void 0, void 0, function () {
         var parsedArgv, command, isHelp, _a, run, help, cmd;
         return __generator(this, function (_b) {
-            parsedArgv = yargsParser(args, {
+            parsedArgv = yargs_parser_1.default(args, {
                 boolean: ['dry-run', 'jest-preset', 'allow-js', 'diff', 'babel', 'force', 'jsdom'],
                 string: ['tsconfig', 'js'],
                 count: ['verbose'],

node_modules/ts-jest/dist/compiler.js

@@ -1,235 +0,0 @@
-"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 __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var bs_logger_1 = require("bs-logger");
-var bufferFrom = require("buffer-from");
-var stableStringify = require("fast-json-stable-stringify");
-var fs_1 = require("fs");
-var memoize = require("lodash.memoize");
-var mkdirp = require("mkdirp");
-var path_1 = require("path");
-var messages_1 = require("./util/messages");
-var sha1_1 = require("./util/sha1");
-var hasOwn = Object.prototype.hasOwnProperty;
-function createCompiler(configs) {
-    var e_1, _a, _b, _c;
-    var logger = configs.logger.child({ namespace: 'ts-compiler' });
-    logger.debug('creating typescript compiler', configs.tsJest.isolatedModules ? '(isolated modules)' : '(language service)');
-    var cachedir = configs.tsCacheDir;
-    var memoryCache = {
-        contents: Object.create(null),
-        versions: Object.create(null),
-        outputs: Object.create(null),
-    };
-    var ts = configs.compilerModule;
-    var cwd = configs.cwd;
-    var extensions = ['.ts', '.tsx'];
-    var _d = configs.typescript, compilerOptions = _d.options, fileNames = _d.fileNames;
-    if (compilerOptions.allowJs) {
-        extensions.push('.js');
-        extensions.push('.jsx');
-    }
-    try {
-        for (var fileNames_1 = __values(fileNames), fileNames_1_1 = fileNames_1.next(); !fileNames_1_1.done; fileNames_1_1 = fileNames_1.next()) {
-            var path = fileNames_1_1.value;
-            memoryCache.versions[path] = 1;
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (fileNames_1_1 && !fileNames_1_1.done && (_a = fileNames_1.return)) _a.call(fileNames_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    var getExtension = compilerOptions.jsx === ts.JsxEmit.Preserve
-        ? function (path) { return (/\.[tj]sx$/.test(path) ? '.jsx' : '.js'); }
-        : function (_) { return '.js'; };
-    var transformers = configs.tsCustomTransformers;
-    var getOutput = function (code, fileName) {
-        logger.debug({ fileName: fileName }, 'getOutput(): compiling as isolated module');
-        var result = ts.transpileModule(code, {
-            fileName: fileName,
-            transformers: transformers,
-            compilerOptions: compilerOptions,
-            reportDiagnostics: configs.shouldReportDiagnostic(fileName),
-        });
-        if (result.diagnostics)
-            configs.raiseDiagnostics(result.diagnostics, fileName, logger);
-        return [result.outputText, result.sourceMapText];
-    };
-    var getTypeInfo = function (_code, _fileName, _position) {
-        throw new TypeError(messages_1.Errors.TypesUnavailableWithoutTypeCheck);
-    };
-    if (!configs.tsJest.isolatedModules) {
-        var updateMemoryCache_1 = function (code, fileName) {
-            logger.debug({ fileName: fileName }, "updateMemoryCache()");
-            if (memoryCache.contents[fileName] !== code) {
-                memoryCache.contents[fileName] = code;
-                memoryCache.versions[fileName] = (memoryCache.versions[fileName] || 0) + 1;
-            }
-        };
-        var serviceHostDebugCtx = (_b = {},
-            _b[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.debug,
-            _b.namespace = 'ts:serviceHost',
-            _b.call = null,
-            _b);
-        var serviceHostTraceCtx = __assign(__assign({}, serviceHostDebugCtx), (_c = {}, _c[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace, _c));
-        var serviceHost = {
-            getScriptFileNames: function () { return Object.keys(memoryCache.versions); },
-            getScriptVersion: function (fileName) {
-                var normalizedFileName = path_1.normalize(fileName);
-                var version = memoryCache.versions[normalizedFileName];
-                return version === undefined ? undefined : String(version);
-            },
-            getScriptSnapshot: function (fileName) {
-                var normalizedFileName = path_1.normalize(fileName);
-                var hit = hasOwn.call(memoryCache.contents, normalizedFileName);
-                logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, "getScriptSnapshot():", 'cache', hit ? 'hit' : 'miss');
-                if (!hit) {
-                    memoryCache.contents[normalizedFileName] = ts.sys.readFile(normalizedFileName);
-                }
-                var contents = memoryCache.contents[normalizedFileName];
-                if (contents === undefined) {
-                    return;
-                }
-                return ts.ScriptSnapshot.fromString(contents);
-            },
-            fileExists: memoize(ts.sys.fileExists),
-            readFile: logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile)),
-            readDirectory: memoize(ts.sys.readDirectory),
-            getDirectories: memoize(ts.sys.getDirectories),
-            directoryExists: memoize(ts.sys.directoryExists),
-            realpath: memoize(ts.sys.realpath),
-            getNewLine: function () { return '\n'; },
-            getCurrentDirectory: function () { return cwd; },
-            getCompilationSettings: function () { return compilerOptions; },
-            getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(compilerOptions); },
-            getCustomTransformers: function () { return transformers; },
-        };
-        logger.debug('creating language service');
-        var service_1 = ts.createLanguageService(serviceHost);
-        getOutput = function (code, fileName) {
-            logger.debug({ fileName: fileName }, 'getOutput(): compiling using language service');
-            updateMemoryCache_1(code, fileName);
-            var output = service_1.getEmitOutput(fileName);
-            if (configs.shouldReportDiagnostic(fileName)) {
-                logger.debug({ fileName: fileName }, 'getOutput(): computing diagnostics');
-                var diagnostics = service_1
-                    .getCompilerOptionsDiagnostics()
-                    .concat(service_1.getSyntacticDiagnostics(fileName))
-                    .concat(service_1.getSemanticDiagnostics(fileName));
-                configs.raiseDiagnostics(diagnostics, fileName, logger);
-            }
-            if (output.emitSkipped) {
-                throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped");
-            }
-            if (output.outputFiles.length === 0) {
-                throw new TypeError(messages_1.interpolate(messages_1.Errors.UnableToRequireDefinitionFile, {
-                    file: path_1.basename(fileName),
-                }));
-            }
-            return [output.outputFiles[1].text, output.outputFiles[0].text];
-        };
-        getTypeInfo = function (code, fileName, position) {
-            updateMemoryCache_1(code, fileName);
-            var info = service_1.getQuickInfoAtPosition(fileName, position);
-            var name = ts.displayPartsToString(info ? info.displayParts : []);
-            var comment = ts.displayPartsToString(info ? info.documentation : []);
-            return { name: name, comment: comment };
-        };
-    }
-    var compile = readThrough(cachedir, memoryCache, getOutput, getExtension, cwd, logger);
-    return { cwd: cwd, compile: compile, getTypeInfo: getTypeInfo, extensions: extensions, cachedir: cachedir, ts: ts };
-}
-exports.createCompiler = createCompiler;
-function readThrough(cachedir, memoryCache, compile, getExtension, cwd, logger) {
-    if (!cachedir) {
-        return function (code, fileName, lineOffset) {
-            logger.debug({ fileName: fileName }, 'readThrough(): no cache');
-            var _a = __read(compile(code, fileName, lineOffset), 2), value = _a[0], sourceMap = _a[1];
-            var output = updateOutput(value, fileName, sourceMap, getExtension, cwd);
-            memoryCache.outputs[fileName] = output;
-            return output;
-        };
-    }
-    mkdirp.sync(cachedir);
-    return function (code, fileName, lineOffset) {
-        var cachePath = path_1.join(cachedir, getCacheName(code, fileName));
-        var extension = getExtension(fileName);
-        var outputPath = "" + cachePath + extension;
-        try {
-            var output_1 = fs_1.readFileSync(outputPath, 'utf8');
-            if (isValidCacheContent(output_1)) {
-                logger.debug({ fileName: fileName }, 'readThrough(): cache hit');
-                memoryCache.outputs[fileName] = output_1;
-                return output_1;
-            }
-        }
-        catch (err) { }
-        logger.debug({ fileName: fileName }, 'readThrough(): cache miss');
-        var _a = __read(compile(code, fileName, lineOffset), 2), value = _a[0], sourceMap = _a[1];
-        var output = updateOutput(value, fileName, sourceMap, getExtension, cwd);
-        logger.debug({ fileName: fileName, outputPath: outputPath }, 'readThrough(): writing caches');
-        memoryCache.outputs[fileName] = output;
-        fs_1.writeFileSync(outputPath, output);
-        return output;
-    };
-}
-function updateOutput(outputText, fileName, sourceMap, getExtension, sourceRoot) {
-    var base = path_1.basename(fileName);
-    var base64Map = bufferFrom(updateSourceMap(sourceMap, fileName, sourceRoot), 'utf8').toString('base64');
-    var sourceMapContent = "data:application/json;charset=utf-8;base64," + base64Map;
-    var sourceMapLength = (base + ".map").length + (getExtension(fileName).length - path_1.extname(fileName).length);
-    return outputText.slice(0, -sourceMapLength) + sourceMapContent;
-}
-function updateSourceMap(sourceMapText, fileName, _sourceRoot) {
-    var sourceMap = JSON.parse(sourceMapText);
-    sourceMap.file = fileName;
-    sourceMap.sources = [fileName];
-    delete sourceMap.sourceRoot;
-    return stableStringify(sourceMap);
-}
-function getCacheName(sourceCode, fileName) {
-    return sha1_1.sha1(fileName, '\x00', sourceCode);
-}
-function isValidCacheContent(contents) {
-    return /(?:9|0=|Q==)$/.test(contents.slice(-3));
-}

node_modules/ts-jest/dist/compiler/instance.d.ts

@@ -0,0 +1,2 @@
+export declare const SOURCE_MAPPING_PREFIX = "sourceMappingURL=";
+export declare function updateOutput(outputText: string, normalizedFileName: string, sourceMap: string): string;

node_modules/ts-jest/dist/compiler/instance.js

@@ -0,0 +1,55 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompilerInstance = exports.updateOutput = exports.SOURCE_MAPPING_PREFIX = void 0;
+var language_service_1 = require("./language-service");
+var transpiler_1 = require("./transpiler");
+var json_1 = require("../utils/json");
+exports.SOURCE_MAPPING_PREFIX = 'sourceMappingURL=';
+function updateOutput(outputText, normalizedFileName, sourceMap) {
+    var base64Map = Buffer.from(updateSourceMap(sourceMap, normalizedFileName), 'utf8').toString('base64');
+    var sourceMapContent = "data:application/json;charset=utf-8;base64," + base64Map;
+    return (outputText.slice(0, outputText.lastIndexOf(exports.SOURCE_MAPPING_PREFIX) + exports.SOURCE_MAPPING_PREFIX.length) + sourceMapContent);
+}
+exports.updateOutput = updateOutput;
+var updateSourceMap = function (sourceMapText, normalizedFileName) {
+    var sourceMap = JSON.parse(sourceMapText);
+    sourceMap.file = normalizedFileName;
+    sourceMap.sources = [normalizedFileName];
+    delete sourceMap.sourceRoot;
+    return json_1.stringify(sourceMap);
+};
+var compileAndUpdateOutput = function (compileFn, logger) { return function (code, fileName, lineOffset) {
+    logger.debug({ fileName: fileName }, 'compileAndUpdateOutput(): get compile output');
+    var _a = __read(compileFn(code, fileName, lineOffset), 2), value = _a[0], sourceMap = _a[1];
+    return updateOutput(value, fileName, sourceMap);
+}; };
+exports.createCompilerInstance = function (configs) {
+    var logger = configs.logger.child({ namespace: 'ts-compiler' });
+    var compilerOptions = configs.parsedTsConfig.options;
+    var extensions = ['.ts', '.tsx'];
+    if (compilerOptions.allowJs) {
+        extensions.push('.js');
+        extensions.push('.jsx');
+    }
+    var compilerInstance = !configs.isolatedModules
+        ? language_service_1.initializeLanguageServiceInstance(configs, logger)
+        : transpiler_1.initializeTranspilerInstance(configs, logger);
+    var compile = compileAndUpdateOutput(compilerInstance.compileFn, logger);
+    return { cwd: configs.cwd, compile: compile, program: compilerInstance.program };
+};

node_modules/ts-jest/dist/compiler/language-service.js

@@ -0,0 +1,280 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeLanguageServiceInstance = void 0;
+var bs_logger_1 = require("bs-logger");
+var fs_1 = require("fs");
+var path_1 = require("path");
+var memoize = require("lodash.memoize");
+var mkdirp = require("mkdirp");
+var constants_1 = require("../constants");
+var messages_1 = require("../utils/messages");
+var json_1 = require("../utils/json");
+var sha1_1 = require("../utils/sha1");
+function doTypeChecking(configs, diagnosedFiles, fileName, service, logger) {
+    if (configs.shouldReportDiagnostics(fileName)) {
+        var diagnostics = service.getSemanticDiagnostics(fileName).concat(service.getSyntacticDiagnostics(fileName));
+        diagnosedFiles.push(fileName);
+        configs.raiseDiagnostics(diagnostics, fileName, logger);
+    }
+}
+exports.initializeLanguageServiceInstance = function (configs, logger) {
+    var _a;
+    logger.debug('initializeLanguageServiceInstance(): create typescript compiler');
+    var ts = configs.compilerModule;
+    var cwd = configs.cwd;
+    var cacheDir = configs.tsCacheDir;
+    var _b = configs.parsedTsConfig, options = _b.options, fileNames = _b.fileNames;
+    var diagnosedFiles = [];
+    var serviceHostTraceCtx = (_a = {
+            namespace: 'ts:serviceHost',
+            call: null
+        },
+        _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
+        _a);
+    var memoryCache = {
+        files: new Map(),
+        resolvedModules: new Map(),
+    };
+    var tsResolvedModulesCachePath;
+    if (cacheDir) {
+        mkdirp.sync(cacheDir);
+        tsResolvedModulesCachePath = path_1.join(cacheDir, sha1_1.sha1('ts-jest-resolved-modules', '\x00'));
+        try {
+            var cachedTSResolvedModules = fs_1.readFileSync(tsResolvedModulesCachePath, 'utf-8');
+            memoryCache.resolvedModules = new Map(json_1.parse(cachedTSResolvedModules));
+        }
+        catch (e) { }
+    }
+    configs.parsedTsConfig.fileNames
+        .filter(function (fileName) { return !configs.isTestFile(fileName); })
+        .forEach(function (fileName) {
+        memoryCache.files.set(fileName, {
+            version: 0,
+        });
+    });
+    function isFileInCache(fileName) {
+        return memoryCache.files.has(fileName) && memoryCache.files.get(fileName).version !== 0;
+    }
+    var cacheReadFile = logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile));
+    var moduleResolutionHost = {
+        fileExists: memoize(ts.sys.fileExists),
+        readFile: cacheReadFile,
+        directoryExists: memoize(ts.sys.directoryExists),
+        getCurrentDirectory: function () { return cwd; },
+        realpath: ts.sys.realpath && memoize(ts.sys.realpath),
+        getDirectories: memoize(ts.sys.getDirectories),
+    };
+    var moduleResolutionCache = ts.createModuleResolutionCache(cwd, function (x) { return x; }, options);
+    function resolveModuleNames(moduleNames, containingFile) {
+        var _a;
+        var normalizedContainingFile = path_1.normalize(containingFile);
+        var currentResolvedModules = (_a = memoryCache.resolvedModules.get(normalizedContainingFile)) !== null && _a !== void 0 ? _a : [];
+        return moduleNames.map(function (moduleName) {
+            var resolveModuleName = ts.resolveModuleName(moduleName, containingFile, options, moduleResolutionHost, moduleResolutionCache);
+            var resolvedModule = resolveModuleName.resolvedModule;
+            if (configs.isTestFile(normalizedContainingFile) && resolvedModule) {
+                var normalizedResolvedFileName = path_1.normalize(resolvedModule.resolvedFileName);
+                if (!currentResolvedModules.includes(normalizedResolvedFileName)) {
+                    currentResolvedModules.push(normalizedResolvedFileName);
+                    memoryCache.resolvedModules.set(normalizedContainingFile, currentResolvedModules);
+                }
+            }
+            return resolvedModule;
+        });
+    }
+    var projectVersion = 1;
+    var updateMemoryCache = function (contents, fileName) {
+        logger.debug({ fileName: fileName }, 'updateMemoryCache(): update memory cache for language service');
+        var shouldIncrementProjectVersion = false;
+        var hit = isFileInCache(fileName);
+        if (!hit) {
+            memoryCache.files.set(fileName, {
+                text: contents,
+                version: 1,
+            });
+            shouldIncrementProjectVersion = true;
+        }
+        else {
+            var previousContents = memoryCache.files.get(fileName).text;
+            if (previousContents !== contents) {
+                memoryCache.files.set(fileName, {
+                    text: contents,
+                    version: memoryCache.files.get(fileName).version + 1,
+                });
+                if (hit)
+                    shouldIncrementProjectVersion = true;
+            }
+            if (!fileNames.includes(fileName)) {
+                shouldIncrementProjectVersion = true;
+            }
+        }
+        if (shouldIncrementProjectVersion)
+            projectVersion++;
+    };
+    var serviceHost = {
+        getProjectVersion: function () { return String(projectVersion); },
+        getScriptFileNames: function () { return __spread(memoryCache.files.keys()); },
+        getScriptVersion: function (fileName) {
+            var _a;
+            var normalizedFileName = path_1.normalize(fileName);
+            var version = (_a = memoryCache.files.get(normalizedFileName)) === null || _a === void 0 ? void 0 : _a.version;
+            return version === undefined ? undefined : String(version);
+        },
+        getScriptSnapshot: function (fileName) {
+            var _a;
+            var normalizedFileName = path_1.normalize(fileName);
+            var hit = isFileInCache(normalizedFileName);
+            logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
+            if (!hit) {
+                memoryCache.files.set(normalizedFileName, {
+                    text: cacheReadFile(normalizedFileName),
+                    version: 1,
+                });
+            }
+            var contents = (_a = memoryCache.files.get(normalizedFileName)) === null || _a === void 0 ? void 0 : _a.text;
+            if (contents === undefined)
+                return;
+            return ts.ScriptSnapshot.fromString(contents);
+        },
+        fileExists: memoize(ts.sys.fileExists),
+        readFile: cacheReadFile,
+        readDirectory: memoize(ts.sys.readDirectory),
+        getDirectories: memoize(ts.sys.getDirectories),
+        directoryExists: memoize(ts.sys.directoryExists),
+        realpath: ts.sys.realpath && memoize(ts.sys.realpath),
+        getNewLine: function () { return constants_1.LINE_FEED; },
+        getCurrentDirectory: function () { return cwd; },
+        getCompilationSettings: function () { return options; },
+        getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(options); },
+        getCustomTransformers: function () { return configs.customTransformers; },
+        resolveModuleNames: resolveModuleNames,
+    };
+    logger.debug('initializeLanguageServiceInstance(): creating language service');
+    var service = ts.createLanguageService(serviceHost, ts.createDocumentRegistry());
+    return {
+        compileFn: function (code, fileName) {
+            var e_1, _a;
+            var _b;
+            logger.debug({ fileName: fileName }, 'compileFn(): compiling using language service');
+            updateMemoryCache(code, fileName);
+            var output = service.getEmitOutput(fileName);
+            if (tsResolvedModulesCachePath) {
+                void (function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4, fs_1.writeFile(tsResolvedModulesCachePath, json_1.stringify(__spread(memoryCache.resolvedModules)), function () { })];
+                            case 1:
+                                _a.sent();
+                                return [2];
+                        }
+                    });
+                }); })();
+            }
+            if (!diagnosedFiles.includes(fileName)) {
+                logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
+                doTypeChecking(configs, diagnosedFiles, fileName, service, logger);
+            }
+            if (!configs.isTestFile(fileName)) {
+                try {
+                    for (var _c = __values(memoryCache.resolvedModules.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var _e = __read(_d.value, 2), testFileName = _e[0], resolvedModules = _e[1];
+                        if (resolvedModules.includes(fileName) &&
+                            !diagnosedFiles.includes(testFileName) &&
+                            fs_1.existsSync(testFileName)) {
+                            var testFileContent = (_b = memoryCache.files.get(testFileName)) === null || _b === void 0 ? void 0 : _b.text;
+                            if (!testFileContent) {
+                                updateMemoryCache(cacheReadFile(testFileName), testFileName);
+                            }
+                            logger.debug({ testFileName: testFileName }, 'compileFn(): computing diagnostics using language service for test file which uses the module');
+                            doTypeChecking(configs, diagnosedFiles, testFileName, service, logger);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            if (output.emitSkipped) {
+                throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped for language service");
+            }
+            if (!output.outputFiles.length) {
+                throw new TypeError(messages_1.interpolate("Unable to require `.d.ts` file for file: {{file}}.\nThis is usually the result of a faulty configuration or import. Make sure there is a `.js`, `.json` or another executable extension available alongside `{{file}}`.", {
+                    file: path_1.basename(fileName),
+                }));
+            }
+            return [output.outputFiles[1].text, output.outputFiles[0].text];
+        },
+        program: service.getProgram(),
+    };
+};

node_modules/ts-jest/dist/compiler/transpiler.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeTranspilerInstance = void 0;
+exports.initializeTranspilerInstance = function (configs, logger) {
+    logger.debug('initializeTranspilerInstance(): create typescript compiler');
+    var options = configs.parsedTsConfig.options;
+    var ts = configs.compilerModule;
+    return {
+        compileFn: function (code, fileName) {
+            logger.debug({ fileName: fileName }, 'compileFn(): compiling as isolated module');
+            var result = ts.transpileModule(code, {
+                fileName: fileName,
+                transformers: configs.customTransformers,
+                compilerOptions: options,
+                reportDiagnostics: configs.shouldReportDiagnostics(fileName),
+            });
+            if (result.diagnostics && configs.shouldReportDiagnostics(fileName)) {
+                configs.raiseDiagnostics(result.diagnostics, fileName, logger);
+            }
+            return [result.outputText, result.sourceMapText];
+        },
+        program: undefined,
+    };
+};

node_modules/ts-jest/dist/config/config-set.d.ts

@@ -1,34 +1,24 @@
-/// <reference types="jest" />
+import type { Config } from '@jest/types';
 import { Logger } from 'bs-logger';
-import { CompilerOptions, CustomTransformers, ParsedCommandLine } from 'typescript';
-import { AstTransformerDesc, BabelConfig, BabelJestTransformer, TTypeScript, TsCompiler, TsJestConfig, TsJestGlobalOptions, TsJestHooksMap } from '../types';
+import { CompilerOptions, CustomTransformers, Diagnostic, ParsedCommandLine } from 'typescript';
+import type { TTypeScript } from '../types';
 export declare class ConfigSet {
-    readonly parentOptions?: TsJestGlobalOptions | undefined;
-    get projectPackageJson(): Record<string, any>;
-    get projectDependencies(): Record<string, string>;
-    get jest(): jest.ProjectConfig;
-    get tsJest(): TsJestConfig;
-    get typescript(): ParsedCommandLine;
-    get tsconfig(): any;
-    get versions(): Record<string, string>;
-    private static loadConfig;
-    get babel(): BabelConfig | undefined;
-    get compilerModule(): TTypeScript;
-    get babelJestTransformer(): BabelJestTransformer | undefined;
-    get tsCompiler(): TsCompiler;
-    get astTransformers(): AstTransformerDesc[];
-    get tsCustomTransformers(): CustomTransformers;
-    get hooks(): TsJestHooksMap;
-    get shouldReportDiagnostic(): (filePath: string) => boolean;
-    get shouldStringifyContent(): (filePath: string) => boolean;
-    get tsCacheDir(): string | undefined;
-    get overriddenCompilerOptions(): Partial<CompilerOptions>;
-    get rootDir(): string;
-    get cwd(): string;
-    get tsJestDigest(): string;
-    get cacheKey(): string;
     readonly logger: Logger;
-    constructor(jestConfig: jest.ProjectConfig, parentOptions?: TsJestGlobalOptions | undefined, parentLogger?: Logger);
+    readonly compilerModule: TTypeScript;
+    readonly isolatedModules: boolean;
+    readonly cwd: string;
+    tsCacheDir: string | undefined;
+    parsedTsConfig: ParsedCommandLine | Record<string, any>;
+    customTransformers: CustomTransformers;
+    readonly rootDir: string;
+    protected _overriddenCompilerOptions: Partial<CompilerOptions>;
+    constructor(jestConfig: Config.ProjectConfig, parentLogger?: Logger | undefined);
+    protected _resolveTsConfig(compilerOptions?: CompilerOptions, resolvedConfigFile?: string): Record<string, any>;
+    get tsJestDigest(): string;
+    get isTestFile(): (fileName: string) => boolean;
+    shouldStringifyContent(filePath: string): boolean;
+    raiseDiagnostics(diagnostics: Diagnostic[], filePath?: string, logger?: Logger): void;
+    shouldReportDiagnostics(filePath: string): boolean;
     resolvePath(inputPath: string, { throwIfMissing, nodeResolve }?: {
         throwIfMissing?: boolean;
         nodeResolve?: boolean;

node_modules/ts-jest/dist/config/create-jest-preset.d.ts

@@ -1,10 +0,0 @@
-/// <reference types="jest" />
-export interface TsJestPresets {
-    transform: Record<string, string>;
-    testMatch?: string[];
-    moduleFileExtensions?: string[];
-}
-export interface CreateJestPresetOptions {
-    allowJs?: boolean;
-}
-export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: jest.InitialOptions): TsJestPresets;

node_modules/ts-jest/dist/config/paths-to-module-name-mapper.d.ts

@@ -1,5 +1,6 @@
+import type { Config } from '@jest/types';
+declare type JestPathMapping = Config.InitialOptions['moduleNameMapper'];
 export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
-    prefix?: string | undefined;
-}) => {
-    [key: string]: string;
-} | undefined;
+    prefix: string;
+}) => JestPathMapping;
+export {};

node_modules/ts-jest/dist/config/paths-to-module-name-mapper.js

@@ -12,14 +12,15 @@ var __values = (this && this.__values) || function(o) {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathsToModuleNameMapper = void 0;
 var bs_logger_1 = require("bs-logger");
-var logger_1 = require("../util/logger");
-var messages_1 = require("../util/messages");
+var logger_1 = require("../utils/logger");
+var messages_1 = require("../utils/messages");
 var escapeRegex = function (str) { return str.replace(/[-\\^$*+?.()|[\]{}]/g, '\\$&'); };
 var logger = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'path-mapper', _a));
 exports.pathsToModuleNameMapper = function (mapping, _a) {
     var e_1, _b;
-    var _c = (_a === void 0 ? {} : _a).prefix, prefix = _c === void 0 ? '' : _c;
+    var _c = (_a === void 0 ? Object.create(null) : _a).prefix, prefix = _c === void 0 ? '' : _c;
     var jestMap = {};
     try {
         for (var _d = __values(Object.keys(mapping)), _e = _d.next(); !_e.done; _e = _d.next()) {
@@ -27,28 +28,28 @@ exports.pathsToModuleNameMapper = function (mapping, _a) {
             var pattern = void 0;
             var toPaths = mapping[fromPath];
             if (toPaths.length === 0) {
-                logger.warn(messages_1.interpolate(messages_1.Errors.NotMappingPathWithEmptyMap, { path: fromPath }));
+                logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has no target.", { path: fromPath }));
                 continue;
             }
-            else if (toPaths.length > 1) {
-                logger.warn(messages_1.interpolate(messages_1.Errors.MappingOnlyFirstTargetOfPath, {
-                    path: fromPath,
-                    count: toPaths.length,
-                }));
-            }
-            var target = toPaths[0];
             var segments = fromPath.split(/\*/g);
             if (segments.length === 1) {
+                var paths = toPaths.map(function (target) {
+                    var enrichedPrefix = prefix !== '' && !prefix.endsWith('/') ? prefix + "/" : prefix;
+                    return "" + enrichedPrefix + target;
+                });
                 pattern = "^" + escapeRegex(fromPath) + "$";
-                jestMap[pattern] = "" + prefix + target;
+                jestMap[pattern] = paths.length === 1 ? paths[0] : paths;
             }
             else if (segments.length === 2) {
+                var paths = toPaths.map(function (target) {
+                    var enrichedPrefix = prefix !== '' && !prefix.endsWith('/') ? prefix + "/" : prefix;
+                    return "" + enrichedPrefix + target.replace(/\*/g, '$1');
+                });
                 pattern = "^" + escapeRegex(segments[0]) + "(.*)" + escapeRegex(segments[1]) + "$";
-                jestMap[pattern] = "" + prefix + target.replace(/\*/g, '$1');
+                jestMap[pattern] = paths.length === 1 ? paths[0] : paths;
             }
             else {
-                logger.warn(messages_1.interpolate(messages_1.Errors.NotMappingMultiStarPath, { path: fromPath }));
-                continue;
+                logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has more than one star (`*`).", { path: fromPath }));
             }
         }
     }

node_modules/ts-jest/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const LINE_FEED = "\n";
+export declare const TS_TSX_REGEX: RegExp;
+export declare const JS_JSX_REGEX: RegExp;
+export declare const DECLARATION_TYPE_EXT = ".d.ts";

node_modules/ts-jest/dist/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_JEST_TEST_MATCH = exports.DECLARATION_TYPE_EXT = exports.JS_JSX_REGEX = exports.TS_TSX_REGEX = exports.LINE_FEED = void 0;
+exports.LINE_FEED = '\n';
+exports.TS_TSX_REGEX = /\.tsx?$/;
+exports.JS_JSX_REGEX = /\.jsx?$/;
+exports.DECLARATION_TYPE_EXT = '.d.ts';
+exports.DEFAULT_JEST_TEST_MATCH = ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'];

node_modules/ts-jest/dist/index.d.ts

@@ -1,16 +1,19 @@
-import { createJestPreset as createJestPresetCore } from './config/create-jest-preset';
+import { createJestPreset as createJestPresetCore } from './presets/create-jest-preset';
 import { TsJestTransformer } from './ts-jest-transformer';
-import { TsJestGlobalOptions } from './types';
-import { mocked as mockedCore } from './util/testing';
+import type { TsJestGlobalOptions } from './types';
+import { mocked as mockedCore } from './utils/testing';
+declare module '@jest/types' {
+    namespace Config {
+        interface ConfigGlobals {
+            'ts-jest': TsJestGlobalOptions;
+        }
+    }
+}
 export declare const mocked: typeof mockedCore;
 export declare const createJestPreset: typeof createJestPresetCore;
 export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
-    prefix?: string | undefined;
+    prefix: string;
 }) => {
-    [key: string]: string;
+    [key: string]: string | string[];
 } | undefined;
-export declare const version: string;
-export declare const digest: string;
-export declare function createTransformer(baseConfig?: TsJestGlobalOptions): TsJestTransformer;
-declare const jestPreset: import("./config/create-jest-preset").TsJestPresets;
-export { jestPreset, };
+export declare function createTransformer(): TsJestTransformer;

node_modules/ts-jest/dist/index.js

@@ -1,74 +1,24 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spread = (this && this.__spread) || function () {
-    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
-    return ar;
-};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformer = exports.pathsToModuleNameMapper = exports.createJestPreset = exports.mocked = void 0;
 var bs_logger_1 = require("bs-logger");
-var fs_1 = require("fs");
-var path_1 = require("path");
-var create_jest_preset_1 = require("./config/create-jest-preset");
+var create_jest_preset_1 = require("./presets/create-jest-preset");
 var paths_to_module_name_mapper_1 = require("./config/paths-to-module-name-mapper");
 var ts_jest_transformer_1 = require("./ts-jest-transformer");
-var logger_1 = require("./util/logger");
-var messages_1 = require("./util/messages");
-var testing_1 = require("./util/testing");
-var version_checkers_1 = require("./util/version-checkers");
+var logger_1 = require("./utils/logger");
+var messages_1 = require("./utils/messages");
+var testing_1 = require("./utils/testing");
+var version_checkers_1 = require("./utils/version-checkers");
 var warn = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.warn, _a));
 var helperMoved = function (name, helper) {
-    return warn.wrap(messages_1.interpolate(messages_1.Deprecateds.HelperMovedToUtils, { helper: name }), helper);
+    return warn.wrap(messages_1.interpolate("The `{{helper}}` helper has been moved to `ts-jest/utils`. Use `import { {{helper}} } from 'ts-jest/utils'` instead.", { helper: name }), helper);
 };
 exports.mocked = helperMoved('mocked', testing_1.mocked);
 exports.createJestPreset = helperMoved('createJestPreset', create_jest_preset_1.createJestPreset);
 exports.pathsToModuleNameMapper = helperMoved('pathsToModuleNameMapper', paths_to_module_name_mapper_1.pathsToModuleNameMapper);
-exports.version = require('../package.json').version;
-exports.digest = fs_1.readFileSync(path_1.resolve(__dirname, '..', '.ts-jest-digest'), 'utf8');
-var transformer;
-function defaultTransformer() {
-    return transformer || (transformer = createTransformer());
-}
-function createTransformer(baseConfig) {
+function createTransformer() {
     version_checkers_1.VersionCheckers.jest.warn();
-    return new ts_jest_transformer_1.TsJestTransformer(baseConfig);
+    return new ts_jest_transformer_1.TsJestTransformer();
 }
 exports.createTransformer = createTransformer;
-function process() {
-    var _a;
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return (_a = defaultTransformer()).process.apply(_a, __spread(args));
-}
-exports.process = process;
-function getCacheKey() {
-    var _a;
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return (_a = defaultTransformer()).getCacheKey.apply(_a, __spread(args));
-}
-exports.getCacheKey = getCacheKey;
-exports.canInstrument = false;
-var jestPreset = create_jest_preset_1.createJestPreset();
-exports.jestPreset = jestPreset;
-exports.__singleton = function () { return transformer; };
-exports.__resetModule = function () { return (transformer = undefined); };

node_modules/ts-jest/dist/presets/create-jest-preset.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '@jest/types';
+export declare type TsJestPresets = Pick<Config.InitialOptions, 'moduleFileExtensions' | 'transform' | 'testMatch'>;
+interface CreateJestPresetOptions {
+    allowJs?: boolean;
+}
+export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: Config.InitialOptions): TsJestPresets;
+export {};

node_modules/ts-jest/dist/presets/create-jest-preset.js

@@ -11,7 +11,8 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var logger_1 = require("../util/logger");
+exports.createJestPreset = void 0;
+var logger_1 = require("../utils/logger");
 var logger = logger_1.rootLogger.child({ namespace: 'jest-preset' });
 function createJestPreset(_a, from) {
     var _b;

node_modules/ts-jest/dist/transformers/hoist-jest.js

@@ -1,4 +1,15 @@
 "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 __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -20,21 +31,43 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.factory = exports.version = exports.name = void 0;
 var bs_logger_1 = require("bs-logger");
-var HOIST_METHODS = ['mock', 'unmock', 'enableAutomock', 'disableAutomock'];
+var HOIST_METHODS = ['mock', 'unmock', 'enableAutomock', 'disableAutomock', 'deepUnmock'];
+var JEST_GLOBALS_MODULE_NAME = '@jest/globals';
+var JEST_GLOBAL_NAME = 'jest';
+var ROOT_LEVEL_AST = 1;
 exports.name = 'hoisting-jest-mock';
-exports.version = 1;
+exports.version = 4;
 function factory(cs) {
     var logger = cs.logger.child({ namespace: 'ts-hoisting' });
     var ts = cs.compilerModule;
+    var importNames = [];
+    function shouldHoistExpression(node) {
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            HOIST_METHODS.includes(node.expression.name.text)) {
+            if (importNames.length) {
+                return ((ts.isIdentifier(node.expression.expression) && importNames.includes(node.expression.expression.text)) ||
+                    (ts.isPropertyAccessExpression(node.expression.expression) &&
+                        ts.isIdentifier(node.expression.expression.expression) &&
+                        importNames.includes(node.expression.expression.expression.text)) ||
+                    shouldHoistExpression(node.expression.expression));
+            }
+            else {
+                return ((ts.isIdentifier(node.expression.expression) && node.expression.expression.text === JEST_GLOBAL_NAME) ||
+                    shouldHoistExpression(node.expression.expression));
+            }
+        }
+        return false;
+    }
     function shouldHoistNode(node) {
-        return (ts.isExpressionStatement(node) &&
-            ts.isCallExpression(node.expression) &&
-            ts.isPropertyAccessExpression(node.expression.expression) &&
-            ts.isIdentifier(node.expression.expression.expression) &&
-            node.expression.expression.expression.text === 'jest' &&
-            ts.isIdentifier(node.expression.expression.name) &&
-            HOIST_METHODS.includes(node.expression.expression.name.text));
+        return ts.isExpressionStatement(node) && shouldHoistExpression(node.expression);
+    }
+    function isJestGlobalImport(node) {
+        return (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.moduleSpecifier.text === JEST_GLOBALS_MODULE_NAME);
     }
     function createVisitor(ctx, _) {
         var level = 0;
@@ -55,14 +88,32 @@ function factory(cs) {
             }
         };
         var visitor = function (node) {
+            var _a, _b;
             enter();
             var resultNode = ts.visitEachChild(node, visitor, ctx);
+            if (isJestGlobalImport(resultNode) && ((_a = resultNode.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings) &&
+                (ts.isNamespaceImport(resultNode.importClause.namedBindings) ||
+                    ts.isNamedImports(resultNode.importClause.namedBindings))) {
+                var namedBindings = resultNode.importClause.namedBindings;
+                var jestImportName = ts.isNamespaceImport(namedBindings)
+                    ? namedBindings.name.text
+                    : (_b = namedBindings.elements.find(function (element) { var _a; return element.name.text === JEST_GLOBAL_NAME || ((_a = element.propertyName) === null || _a === void 0 ? void 0 : _a.text) === JEST_GLOBAL_NAME; })) === null || _b === void 0 ? void 0 : _b.name.text;
+                if (jestImportName) {
+                    importNames.push(jestImportName);
+                }
+            }
             if (hoisted[level] && hoisted[level].length) {
                 var hoistedStmts_1 = hoisted[level];
-                var otherStmts = resultNode.statements.filter(function (s) { return !hoistedStmts_1.includes(s); });
+                var otherStmts = resultNode.statements.filter(function (s) { return !hoistedStmts_1.includes(s) && !isJestGlobalImport(s); });
                 var newNode = ts.getMutableClone(resultNode);
-                newNode.statements = ts.createNodeArray(__spread(hoistedStmts_1, otherStmts));
-                resultNode = newNode;
+                var newStatements = __spread(hoistedStmts_1, otherStmts);
+                if (level === ROOT_LEVEL_AST) {
+                    var jestGlobalsImportStmts = resultNode.statements.filter(function (s) { return isJestGlobalImport(s); });
+                    resultNode = __assign(__assign({}, newNode), { statements: ts.createNodeArray(__spread(jestGlobalsImportStmts, newStatements)) });
+                }
+                else {
+                    resultNode = __assign(__assign({}, newNode), { statements: ts.createNodeArray(newStatements) });
+                }
             }
             exit();
             if (shouldHoistNode(resultNode)) {

node_modules/ts-jest/dist/transformers/index.js

@@ -1,4 +1,24 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var hoisting = require("./hoist-jest");
+exports.internals = void 0;
+var hoisting = __importStar(require("./hoist-jest"));
 exports.internals = [hoisting];

node_modules/ts-jest/dist/transformers/path-mapping.d.ts

@@ -0,0 +1,3 @@
+import type * as _ts from 'typescript';
+import type { ConfigSet } from '../config/config-set';
+export declare function factory(cs: ConfigSet): (ctx: _ts.TransformationContext) => _ts.Transformer<_ts.SourceFile>;

node_modules/ts-jest/dist/transformers/path-mapping.js

@@ -0,0 +1,121 @@
+"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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factory = exports.version = exports.name = void 0;
+var bs_logger_1 = require("bs-logger");
+var path_1 = require("path");
+exports.name = 'path-mapping';
+exports.version = 1;
+var isBaseDir = function (base, dir) { var _a; return !((_a = path_1.relative(base, dir)) === null || _a === void 0 ? void 0 : _a.startsWith('.')); };
+function factory(cs) {
+    var _a;
+    var logger = cs.logger.child({ namespace: 'ts-path-mapping' });
+    var ts = cs.compilerModule;
+    var compilerOptions = cs.parsedTsConfig.options;
+    var rootDirs = (_a = compilerOptions.rootDirs) === null || _a === void 0 ? void 0 : _a.filter(path_1.isAbsolute);
+    var isDynamicImport = function (node) {
+        return ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
+    };
+    var isRequire = function (node) {
+        return ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === 'require' &&
+            ts.isStringLiteral(node.arguments[0]) &&
+            node.arguments.length === 1;
+    };
+    var createVisitor = function (ctx, sf) {
+        var fileName = sf.fileName;
+        var fileDir = path_1.normalize(path_1.dirname(fileName));
+        var rewritePath = function (importPath) {
+            var e_1, _a;
+            var p = importPath;
+            var resolvedModule = ts.resolveModuleName(importPath, fileName, compilerOptions, ts.sys).resolvedModule;
+            if (resolvedModule) {
+                var resolvedFileName = resolvedModule.resolvedFileName;
+                var filePath = fileDir;
+                var modulePath = path_1.dirname(resolvedFileName);
+                if (rootDirs) {
+                    var fileRootDir = '';
+                    var moduleRootDir = '';
+                    try {
+                        for (var rootDirs_1 = __values(rootDirs), rootDirs_1_1 = rootDirs_1.next(); !rootDirs_1_1.done; rootDirs_1_1 = rootDirs_1.next()) {
+                            var rootDir = rootDirs_1_1.value;
+                            if (isBaseDir(rootDir, resolvedFileName) && rootDir.length > moduleRootDir.length)
+                                moduleRootDir = rootDir;
+                            if (isBaseDir(rootDir, fileName) && rootDir.length > fileRootDir.length)
+                                fileRootDir = rootDir;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (rootDirs_1_1 && !rootDirs_1_1.done && (_a = rootDirs_1.return)) _a.call(rootDirs_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    if (fileRootDir && moduleRootDir) {
+                        filePath = path_1.relative(fileRootDir, filePath);
+                        modulePath = path_1.relative(moduleRootDir, modulePath);
+                    }
+                }
+                p = path_1.normalize(path_1.join(path_1.relative(filePath, modulePath), path_1.basename(resolvedFileName)));
+                p = p.startsWith('.') ? p : "./" + p;
+            }
+            return p;
+        };
+        var visitor = function (node) {
+            var rewrittenPath;
+            var newNode = ts.getMutableClone(node);
+            if (isDynamicImport(node) || isRequire(node)) {
+                rewrittenPath = rewritePath(node.arguments[0].text);
+                return __assign(__assign({}, newNode), { arguments: ts.createNodeArray([ts.createStringLiteral(rewrittenPath)]) });
+            }
+            if (ts.isExternalModuleReference(node) && ts.isStringLiteral(node.expression)) {
+                rewrittenPath = rewritePath(node.expression.text);
+                return ts.updateExternalModuleReference(newNode, ts.createLiteral(rewrittenPath));
+            }
+            if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+                rewrittenPath = rewritePath(node.moduleSpecifier.text);
+                return __assign(__assign({}, newNode), { moduleSpecifier: ts.createLiteral(rewrittenPath) });
+            }
+            if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+                rewrittenPath = rewritePath(node.moduleSpecifier.text);
+                return __assign(__assign({}, newNode), { moduleSpecifier: ts.createLiteral(rewrittenPath) });
+            }
+            if (ts.isImportTypeNode(node) &&
+                ts.isLiteralTypeNode(node.argument) &&
+                ts.isStringLiteral(node.argument.literal)) {
+                rewrittenPath = rewritePath(node.argument.literal.text);
+                return __assign(__assign({}, newNode), { argument: ts.createLiteralTypeNode(ts.createStringLiteral(rewrittenPath)) });
+            }
+            return ts.visitEachChild(node, visitor, ctx);
+        };
+        return visitor;
+    };
+    return function (ctx) {
+        var _a;
+        return logger.wrap((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.debug, _a.call = null, _a), 'visitSourceFileNode(): path mapping', function (sf) { return ts.visitNode(sf, createVisitor(ctx, sf)); });
+    };
+}
+exports.factory = factory;

node_modules/ts-jest/dist/ts-jest-transformer.d.ts

@@ -1,17 +1,12 @@
-/// <reference types="jest" />
-import { Logger } from 'bs-logger';
+import type { CacheKeyOptions, TransformedSource, Transformer, TransformOptions } from '@jest/transform';
+import type { Config } from '@jest/types';
+import type { Logger } from 'bs-logger';
 import { ConfigSet } from './config/config-set';
-import { TsJestGlobalOptions } from './types';
-export declare class TsJestTransformer implements jest.Transformer {
-    static get lastTransformerId(): number;
-    readonly logger: Logger;
-    readonly id: number;
-    readonly options: TsJestGlobalOptions;
-    constructor(baseOptions?: TsJestGlobalOptions);
-    configsFor(jestConfig: jest.ProjectConfig | string): ConfigSet;
-    process(input: string, filePath: jest.Path, jestConfig: jest.ProjectConfig, transformOptions?: jest.TransformOptions): jest.TransformedSource | string;
-    getCacheKey(fileContent: string, filePath: string, jestConfigStr: string, transformOptions?: {
-        instrument?: boolean;
-        rootDir?: string;
-    }): string;
+export declare class TsJestTransformer implements Transformer {
+    protected readonly logger: Logger;
+    protected _transformCfgStr: string;
+    constructor();
+    configsFor(jestConfig: Config.ProjectConfig): ConfigSet;
+    process(input: string, filePath: Config.Path, jestConfig: Config.ProjectConfig, transformOptions?: TransformOptions): TransformedSource | string;
+    getCacheKey(fileContent: string, filePath: string, _jestConfigStr: string, transformOptions: CacheKeyOptions): string;
 }

node_modules/ts-jest/dist/ts-jest-transformer.js

@@ -11,69 +11,53 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var util_1 = require("util");
+exports.TsJestTransformer = void 0;
 var config_set_1 = require("./config/config-set");
-var json_1 = require("./util/json");
-var jsonable_value_1 = require("./util/jsonable-value");
-var logger_1 = require("./util/logger");
-var messages_1 = require("./util/messages");
-var sha1_1 = require("./util/sha1");
-exports.INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
+var constants_1 = require("./constants");
+var json_1 = require("./utils/json");
+var jsonable_value_1 = require("./utils/jsonable-value");
+var logger_1 = require("./utils/logger");
+var messages_1 = require("./utils/messages");
+var sha1_1 = require("./utils/sha1");
 var TsJestTransformer = (function () {
-    function TsJestTransformer(baseOptions) {
-        if (baseOptions === void 0) { baseOptions = {}; }
-        this.options = __assign({}, baseOptions);
-        this.id = TsJestTransformer._nextTransformerId;
-        this.logger = logger_1.rootLogger.child({
-            transformerId: this.id,
-            namespace: 'jest-transformer',
-        });
-        this.logger.debug({ baseOptions: baseOptions }, 'created new transformer');
+    function TsJestTransformer() {
+        this.logger = logger_1.rootLogger.child({ namespace: 'ts-jest-transformer' });
+        this.logger.debug('created new transformer');
     }
-    Object.defineProperty(TsJestTransformer, "lastTransformerId", {
-        get: function () {
-            return TsJestTransformer._lastTransformerId;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TsJestTransformer, "_nextTransformerId", {
-        get: function () {
-            return ++TsJestTransformer._lastTransformerId;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    TsJestTransformer.prototype[exports.INSPECT_CUSTOM] = function () {
-        return "[object TsJestTransformer<#" + this.id + ">]";
-    };
     TsJestTransformer.prototype.configsFor = function (jestConfig) {
-        var csi;
-        var jestConfigObj;
-        if (typeof jestConfig === 'string') {
-            csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.serialized === jestConfig; });
-            if (csi)
-                return csi.configSet;
-            jestConfigObj = json_1.parse(jestConfig);
+        var ccs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.value === jestConfig; });
+        var configSet;
+        if (ccs) {
+            this._transformCfgStr = ccs.transformerCfgStr;
+            configSet = ccs.configSet;
         }
         else {
-            csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.value === jestConfig; });
-            if (csi)
-                return csi.configSet;
-            var serialized_1 = json_1.stringify(jestConfig);
-            csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.serialized === serialized_1; });
-            if (csi) {
-                csi.jestConfig.value = jestConfig;
-                return csi.configSet;
+            var serializedJestCfg_1 = json_1.stringify(jestConfig);
+            var serializedCcs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.serialized === serializedJestCfg_1; });
+            if (serializedCcs) {
+                serializedCcs.jestConfig.value = jestConfig;
+                this._transformCfgStr = serializedCcs.transformerCfgStr;
+                configSet = serializedCcs.configSet;
+            }
+            else {
+                this.logger.info('no matching config-set found, creating a new one');
+                configSet = new config_set_1.ConfigSet(jestConfig);
+                var jest_1 = __assign({}, jestConfig);
+                var globals = (jest_1.globals = __assign({}, jest_1.globals));
+                jest_1.name = undefined;
+                jest_1.cacheDirectory = undefined;
+                delete globals['ts-jest'];
+                this._transformCfgStr = new jsonable_value_1.JsonableValue(__assign(__assign({ digest: configSet.tsJestDigest, babel: configSet.babelConfig }, jest_1), { tsconfig: {
+                        options: configSet.parsedTsConfig.options,
+                        raw: configSet.parsedTsConfig.raw,
+                    } })).serialized;
+                TsJestTransformer._cachedConfigSets.push({
+                    jestConfig: new jsonable_value_1.JsonableValue(jestConfig),
+                    configSet: configSet,
+                    transformerCfgStr: this._transformCfgStr,
+                });
             }
-            jestConfigObj = jestConfig;
         }
-        this.logger.info("no matching config-set found, creating a new one");
-        var configSet = new config_set_1.ConfigSet(jestConfigObj, this.options, this.logger);
-        TsJestTransformer._configSetsIndex.push({
-            jestConfig: new jsonable_value_1.JsonableValue(jestConfigObj),
-            configSet: configSet,
-        });
         return configSet;
     };
     TsJestTransformer.prototype.process = function (input, filePath, jestConfig, transformOptions) {
@@ -82,26 +66,26 @@ var TsJestTransformer = (function () {
         var source = input;
         var configs = this.configsFor(jestConfig);
         var hooks = configs.hooks;
-        var stringify = configs.shouldStringifyContent(filePath);
-        var babelJest = stringify ? undefined : configs.babelJestTransformer;
-        var isDefinitionFile = filePath.endsWith('.d.ts');
-        var isJsFile = !isDefinitionFile && /\.jsx?$/.test(filePath);
-        var isTsFile = isDefinitionFile || /\.tsx?$/.test(filePath);
-        if (stringify) {
-            result = "module.exports=" + JSON.stringify(source);
+        var shouldStringifyContent = configs.shouldStringifyContent(filePath);
+        var babelJest = shouldStringifyContent ? undefined : configs.babelJestTransformer;
+        var isDefinitionFile = filePath.endsWith(constants_1.DECLARATION_TYPE_EXT);
+        var isJsFile = constants_1.JS_JSX_REGEX.test(filePath);
+        var isTsFile = !isDefinitionFile && constants_1.TS_TSX_REGEX.test(filePath);
+        if (shouldStringifyContent) {
+            result = "module.exports=" + json_1.stringify(source);
         }
         else if (isDefinitionFile) {
             result = '';
         }
-        else if (!configs.typescript.options.allowJs && isJsFile) {
-            this.logger.warn({ fileName: filePath }, messages_1.interpolate(messages_1.Errors.GotJsFileButAllowJsFalse, { path: filePath }));
+        else if (!configs.parsedTsConfig.options.allowJs && isJsFile) {
+            this.logger.warn({ fileName: filePath }, messages_1.interpolate("Got a `.js` file to compile while `allowJs` option is not set to `true` (file: {{path}}). To fix this:\n  - if you want TypeScript to process JS files, set `allowJs` to `true` in your TypeScript config (usually tsconfig.json)\n  - if you do not want TypeScript to process your `.js` files, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match `.js` files anymore", { path: filePath }));
             result = source;
         }
         else if (isJsFile || isTsFile) {
             result = configs.tsCompiler.compile(source, filePath);
         }
         else {
-            var message = babelJest ? messages_1.Errors.GotUnknownFileTypeWithBabel : messages_1.Errors.GotUnknownFileTypeWithoutBabel;
+            var message = babelJest ? "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore. If you still want Babel to process it, add another entry to the `transform` option with value `babel-jest` which key matches this type of files." : "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore.";
             this.logger.warn({ fileName: filePath }, messages_1.interpolate(message, { path: filePath }));
             result = source;
         }
@@ -118,15 +102,13 @@ var TsJestTransformer = (function () {
         }
         return result;
     };
-    TsJestTransformer.prototype.getCacheKey = function (fileContent, filePath, jestConfigStr, transformOptions) {
-        if (transformOptions === void 0) { transformOptions = {}; }
+    TsJestTransformer.prototype.getCacheKey = function (fileContent, filePath, _jestConfigStr, transformOptions) {
+        var configs = this.configsFor(transformOptions.config);
         this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'computing cache key for', filePath);
-        var configs = this.configsFor(jestConfigStr);
         var _a = transformOptions.instrument, instrument = _a === void 0 ? false : _a, _b = transformOptions.rootDir, rootDir = _b === void 0 ? configs.rootDir : _b;
-        return sha1_1.sha1(configs.cacheKey, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
+        return sha1_1.sha1(this._transformCfgStr, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
     };
-    TsJestTransformer._configSetsIndex = [];
-    TsJestTransformer._lastTransformerId = 0;
+    TsJestTransformer._cachedConfigSets = [];
     return TsJestTransformer;
 }());
 exports.TsJestTransformer = TsJestTransformer;

node_modules/ts-jest/dist/types.d.ts

@@ -1,113 +1,39 @@
-/// <reference types="jest" />
-import * as _babel from 'babel__core';
-import { CompilerOptions, SourceFile, TransformerFactory } from 'typescript';
-import * as _ts from 'typescript';
-import { ConfigSet } from './config/config-set';
-export declare type TBabelCore = typeof _babel;
+import type * as _babel from 'babel__core';
+import type * as _ts from 'typescript';
 export declare type TTypeScript = typeof _ts;
-export declare type TBabelJest = Required<jest.Transformer>;
-export declare type BabelJestTransformer = {
-    [K in Exclude<keyof jest.Transformer, 'createTransformer'>]: Exclude<jest.Transformer[K], undefined>;
-};
 export declare type BabelConfig = _babel.TransformOptions;
+export interface AstTransformer<T = Record<string, unknown>> {
+    path: string;
+    options?: T;
+}
+export interface ConfigCustomTransformer {
+    before?: (string | AstTransformer)[];
+    after?: (string | AstTransformer)[];
+    afterDeclarations?: (string | AstTransformer)[];
+}
 export interface TsJestGlobalOptions {
-    tsConfig?: boolean | string | CompilerOptions;
-    packageJson?: boolean | string | object;
+    tsConfig?: boolean | string | _ts.CompilerOptions;
+    tsconfig?: boolean | string | _ts.CompilerOptions;
+    packageJson?: boolean | string | Record<string, unknown>;
     isolatedModules?: boolean;
     compiler?: string;
-    astTransformers?: string[];
+    astTransformers?: string[] | ConfigCustomTransformer;
     diagnostics?: boolean | {
         pretty?: boolean;
-        ignoreCodes?: number | string | Array<number | string>;
+        ignoreCodes?: number | string | (number | string)[];
         pathRegex?: RegExp | string;
         warnOnly?: boolean;
     };
     babelConfig?: boolean | string | BabelConfig;
     stringifyContentPathRegex?: string | RegExp;
 }
-interface TsJestConfig$tsConfig$file {
-    kind: 'file';
-    value: string | undefined;
-}
-interface TsJestConfig$tsConfig$inline {
-    kind: 'inline';
-    value: CompilerOptions;
-}
-declare type TsJestConfig$tsConfig = TsJestConfig$tsConfig$file | TsJestConfig$tsConfig$inline | undefined;
-interface TsJestConfig$diagnostics {
+export interface TsJestDiagnosticsCfg {
     pretty: boolean;
     ignoreCodes: number[];
     pathRegex?: string | undefined;
     throws: boolean;
-}
-interface TsJestConfig$babelConfig$file {
-    kind: 'file';
-    value: string | undefined;
-}
-interface TsJestConfig$babelConfig$inline {
-    kind: 'inline';
-    value: BabelConfig;
-}
-declare type TsJestConfig$babelConfig = TsJestConfig$babelConfig$file | TsJestConfig$babelConfig$inline | undefined;
-interface TsJestConfig$packageJson$file {
-    kind: 'file';
-    value: string | undefined;
-}
-interface TsJestConfig$packageJson$inline {
-    kind: 'inline';
-    value: any;
-}
-declare type TsJestConfig$packageJson = TsJestConfig$packageJson$file | TsJestConfig$packageJson$inline | undefined;
-declare type TsJestConfig$stringifyContentPathRegex = string | undefined;
-export interface TsJestConfig {
-    tsConfig: TsJestConfig$tsConfig;
-    packageJson: TsJestConfig$packageJson;
-    isolatedModules: boolean;
-    compiler: string;
-    diagnostics: TsJestConfig$diagnostics;
-    babelConfig: TsJestConfig$babelConfig;
-    transformers: string[];
-    stringifyContentPathRegex: TsJestConfig$stringifyContentPathRegex;
-}
-export interface TsJestHooksMap {
-    afterProcess?(args: any[], result: string | jest.TransformedSource): string | jest.TransformedSource | void;
-}
-export interface TSCommon {
-    version: typeof _ts.version;
-    sys: typeof _ts.sys;
-    ScriptSnapshot: typeof _ts.ScriptSnapshot;
-    displayPartsToString: typeof _ts.displayPartsToString;
-    createLanguageService: typeof _ts.createLanguageService;
-    getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath;
-    getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics;
-    flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText;
-    transpileModule: typeof _ts.transpileModule;
-    ModuleKind: typeof _ts.ModuleKind;
-    ScriptTarget: typeof _ts.ScriptTarget;
-    findConfigFile: typeof _ts.findConfigFile;
-    readConfigFile: typeof _ts.readConfigFile;
-    parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent;
-    formatDiagnostics: typeof _ts.formatDiagnostics;
-    formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext;
-}
-export interface TypeInfo {
-    name: string;
-    comment: string;
+    warnOnly?: boolean;
 }
 export interface TsCompiler {
-    cwd: string;
-    extensions: string[];
-    cachedir: string | undefined;
-    ts: TSCommon;
-    compile(code: string, fileName: string, lineOffset?: number): string;
-    getTypeInfo(code: string, fileName: string, position: number): TypeInfo;
+    program: _ts.Program | undefined;
 }
-export interface AstTransformerDesc {
-    name: string;
-    version: number;
-    factory(cs: ConfigSet): TransformerFactory<SourceFile>;
-}
-export interface IPackageJson {
-    main: string;
-}
-export {};

node_modules/ts-jest/dist/util/exported.d.ts

@@ -1,3 +0,0 @@
-export { mocked } from './testing';
-export { createJestPreset } from '../config/create-jest-preset';
-export { pathsToModuleNameMapper } from '../config/paths-to-module-name-mapper';

node_modules/ts-jest/dist/util/exported.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var testing_1 = require("./testing");
-exports.mocked = testing_1.mocked;
-var create_jest_preset_1 = require("../config/create-jest-preset");
-exports.createJestPreset = create_jest_preset_1.createJestPreset;
-var paths_to_module_name_mapper_1 = require("../config/paths-to-module-name-mapper");
-exports.pathsToModuleNameMapper = paths_to_module_name_mapper_1.pathsToModuleNameMapper;

node_modules/ts-jest/dist/util/jsonable-value.d.ts

@@ -1 +0,0 @@
-export {};

node_modules/ts-jest/dist/util/messages.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var Errors;
-(function (Errors) {
-    Errors["LoadingModuleFailed"] = "Loading module {{module}} failed with error: {{error}}";
-    Errors["UnableToLoadOneModule"] = "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}";
-    Errors["UnableToLoadAnyModule"] = "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}";
-    Errors["TypesUnavailableWithoutTypeCheck"] = "Type information is unavailable with \"isolatedModules\"";
-    Errors["UnableToRequireDefinitionFile"] = "Unable to require `.d.ts` file.\nThis is usually the result of a faulty configuration or import. Make sure there is a `.js`, `.json` or another executable extension available alongside `{{file}}`.";
-    Errors["FileNotFound"] = "File not found: {{inputPath}} (resolved as: {{resolvedPath}})";
-    Errors["UntestedDependencyVersion"] = "Version {{actualVersion}} of {{module}} installed has not been tested with ts-jest. If you're experiencing issues, consider using a supported version ({{expectedVersion}}). Please do not report issues in ts-jest if you are using unsupported versions.";
-    Errors["MissingDependency"] = "Module {{module}} is not installed. If you're experiencing issues, consider installing a supported version ({{expectedVersion}}).";
-    Errors["UnableToCompileTypeScript"] = "TypeScript diagnostics ({{help}}):\n{{diagnostics}}";
-    Errors["NotMappingMultiStarPath"] = "Not mapping \"{{path}}\" because it has more than one star (`*`).";
-    Errors["NotMappingPathWithEmptyMap"] = "Not mapping \"{{path}}\" because it has no target.";
-    Errors["MappingOnlyFirstTargetOfPath"] = "Mapping only to first target of \"{{path}}\" because it has more than one ({{count}}).";
-    Errors["GotJsFileButAllowJsFalse"] = "Got a `.js` file to compile while `allowJs` option is not set to `true` (file: {{path}}). To fix this:\n  - if you want TypeScript to process JS files, set `allowJs` to `true` in your TypeScript config (usually tsconfig.json)\n  - if you do not want TypeScript to process your `.js` files, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match `.js` files anymore";
-    Errors["GotUnknownFileTypeWithoutBabel"] = "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore.";
-    Errors["GotUnknownFileTypeWithBabel"] = "Got a unknown file type to compile (file: {{path}}). To fix this, in your Jest config change the `transform` key which value is `ts-jest` so that it does not match this kind of files anymore. If you still want Babel to process it, add another entry to the `transform` option with value `babel-jest` which key matches this type of files.";
-    Errors["ConfigNoModuleInterop"] = "If you have issues related to imports, you should consider setting `esModuleInterop` to `true` in your TypeScript configuration file (usually `tsconfig.json`). See https://blogs.msdn.microsoft.com/typescript/2018/01/31/announcing-typescript-2-7/#easier-ecmascript-module-interoperability for more information.";
-    Errors["UnableToFindProjectRoot"] = "Unable to find the root of the project where ts-jest has been installed.";
-    Errors["UnableToResolveJestConfig"] = "Unable to resolve jest-config. Ensure Jest is properly installed.";
-})(Errors = exports.Errors || (exports.Errors = {}));
-var Helps;
-(function (Helps) {
-    Helps["FixMissingModule"] = "{{label}}: `npm i -D {{module}}` (or `yarn add --dev {{module}}`)";
-    Helps["IgnoreDiagnosticCode"] = "customize using `[jest-config].globals.ts-jest.diagnostics` option";
-    Helps["MigrateConfigUsingCLI"] = "Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>.";
-})(Helps = exports.Helps || (exports.Helps = {}));
-var Deprecateds;
-(function (Deprecateds) {
-    Deprecateds["EnvVar"] = "Using env. var \"{{old}}\" is deprecated, use \"{{new}}\" instead.";
-    Deprecateds["ConfigOption"] = "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.";
-    Deprecateds["ConfigOptionWithNote"] = "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.\n    \u21B3 {{note}}";
-    Deprecateds["ConfigOptionUseBabelRcNote"] = "See `babel-jest` related issue: https://github.com/facebook/jest/issues/3845";
-    Deprecateds["HelperMovedToUtils"] = "The `{{helper}}` helper has been moved to `ts-jest/utils`. Use `import { {{helper}} } from 'ts-jest/utils'` instead.";
-})(Deprecateds = exports.Deprecateds || (exports.Deprecateds = {}));
-var ImportReasons;
-(function (ImportReasons) {
-    ImportReasons["TsJest"] = "Using \"ts-jest\" requires this package to be installed.";
-    ImportReasons["BabelJest"] = "Using \"babel-jest\" requires this package to be installed.";
-})(ImportReasons = exports.ImportReasons || (exports.ImportReasons = {}));
-function interpolate(msg, vars) {
-    if (vars === void 0) { vars = {}; }
-    return msg.replace(/\{\{([^\}]+)\}\}/g, function (_, key) { return (key in vars ? vars[key] : _); });
-}
-exports.interpolate = interpolate;

node_modules/ts-jest/dist/util/version-checkers.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var semver_1 = require("semver");
-var get_package_version_1 = require("./get-package-version");
-var logger_1 = require("./logger");
-var messages_1 = require("./messages");
-var logger = logger_1.rootLogger.child({ namespace: 'versions' });
-var ExpectedVersions;
-(function (ExpectedVersions) {
-    ExpectedVersions["Jest"] = ">=24 <25";
-    ExpectedVersions["TypeScript"] = ">=2.7 <4";
-    ExpectedVersions["BabelJest"] = ">=24 <25";
-    ExpectedVersions["BabelCore"] = ">=7.0.0-beta.0 <8";
-})(ExpectedVersions = exports.ExpectedVersions || (exports.ExpectedVersions = {}));
-exports.VersionCheckers = {
-    jest: createVersionChecker('jest', ExpectedVersions.Jest),
-    typescript: createVersionChecker('typescript', ExpectedVersions.TypeScript),
-    babelJest: createVersionChecker('babel-jest', ExpectedVersions.BabelJest),
-    babelCore: createVersionChecker('@babel/core', ExpectedVersions.BabelCore),
-};
-function checkVersion(name, expectedRange, action) {
-    if (action === void 0) { action = 'warn'; }
-    var version = get_package_version_1.getPackageVersion(name);
-    var success = !!version && semver_1.satisfies(version, expectedRange);
-    logger.debug({
-        actualVersion: version,
-        expectedVersion: expectedRange,
-    }, 'checking version of %s: %s', name, success ? 'OK' : 'NOT OK');
-    if (!action || success)
-        return success;
-    var message = messages_1.interpolate(version ? messages_1.Errors.UntestedDependencyVersion : messages_1.Errors.MissingDependency, {
-        module: name,
-        actualVersion: version || '??',
-        expectedVersion: rangeToHumanString(expectedRange),
-    });
-    if (action === 'warn') {
-        logger.warn(message);
-    }
-    else if (action === 'throw') {
-        logger.fatal(message);
-        throw new RangeError(message);
-    }
-    return success;
-}
-function rangeToHumanString(versionRange) {
-    return new semver_1.Range(versionRange).toString();
-}
-function createVersionChecker(moduleName, expectedVersion) {
-    var memo;
-    var warn = function () {
-        if (memo !== undefined)
-            return memo;
-        return (memo = checkVersion(moduleName, expectedVersion, 'warn'));
-    };
-    var raise = function () { return checkVersion(moduleName, expectedVersion, 'throw'); };
-    return {
-        raise: raise,
-        warn: warn,
-        forget: function () {
-            memo = undefined;
-        },
-    };
-}

node_modules/ts-jest/dist/utils/backports.js

@@ -12,6 +12,7 @@ var __assign = (this && this.__assign) || function () {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.backportTsJestDebugEnvVar = exports.backportJestConfig = void 0;
 var bs_logger_1 = require("bs-logger");
 var messages_1 = require("./messages");
 var context = (_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'backports', _a);
@@ -23,7 +24,7 @@ exports.backportJestConfig = function (logger, config) {
     var hadWarnings = false;
     var warnConfig = function (oldPath, newPath, note) {
         hadWarnings = true;
-        logger.warn(context, messages_1.interpolate(note ? messages_1.Deprecateds.ConfigOptionWithNote : messages_1.Deprecateds.ConfigOption, {
+        logger.warn(context, messages_1.interpolate(note ? "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.\n    \u21B3 {{note}}" : "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.", {
             oldPath: oldPath,
             newPath: newPath,
             note: note,
@@ -68,7 +69,7 @@ exports.backportJestConfig = function (logger, config) {
         delete tsJest.enableTsDiagnostics;
     }
     if ('useBabelrc' in tsJest) {
-        warnConfig('globals.ts-jest.useBabelrc', 'globals.ts-jest.babelConfig', messages_1.Deprecateds.ConfigOptionUseBabelRcNote);
+        warnConfig('globals.ts-jest.useBabelrc', 'globals.ts-jest.babelConfig', "See `babel-jest` related issue: https://github.com/facebook/jest/issues/3845");
         if (tsJest.useBabelrc != null) {
             mergeTsJest.babelConfig = tsJest.useBabelrc ? true : {};
         }
@@ -82,7 +83,7 @@ exports.backportJestConfig = function (logger, config) {
         delete tsJest.skipBabel;
     }
     if (hadWarnings) {
-        logger.warn(context, messages_1.Helps.MigrateConfigUsingCLI);
+        logger.warn(context, "Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>.");
     }
     return __assign(__assign({}, config), { globals: __assign(__assign({}, globals), { 'ts-jest': __assign(__assign({}, mergeTsJest), tsJest) }) });
 };
@@ -91,9 +92,9 @@ exports.backportTsJestDebugEnvVar = function (logger) {
         var shouldLog = !/^\s*(?:0|f(?:alse)?|no?|disabled?|off|)\s*$/i.test(process.env.TS_JEST_DEBUG || '');
         delete process.env.TS_JEST_DEBUG;
         if (shouldLog) {
-            process.env.TS_JEST_LOG = "ts-jest.log,stderr:warn";
+            process.env.TS_JEST_LOG = 'ts-jest.log,stderr:warn';
         }
-        logger.warn(context, messages_1.interpolate(messages_1.Deprecateds.EnvVar, {
+        logger.warn(context, messages_1.interpolate("Using env. var \"{{old}}\" is deprecated, use \"{{new}}\" instead.", {
             old: 'TS_JEST_DEBUG',
             new: 'TS_JEST_LOG',
         }));

node_modules/ts-jest/dist/utils/get-package-version.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = void 0;
 function getPackageVersion(moduleName) {
     try {
         return require(moduleName + "/package.json").version;

node_modules/ts-jest/dist/utils/importer.js

@@ -37,6 +37,7 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.__requireModule = exports.importer = exports.Importer = void 0;
 var logger_1 = require("./logger");
 var memoize_1 = require("./memoize");
 var messages_1 = require("./messages");
@@ -61,7 +62,7 @@ var Importer = (function () {
                 jest: [passThru(version_checkers_1.VersionCheckers.jest.warn)],
             });
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     Importer.prototype.babelJest = function (why) {
@@ -128,17 +129,15 @@ var Importer = (function () {
         if (res && res.exists) {
             if (!res.error)
                 return res.exports;
-            throw new Error(messages_1.interpolate(messages_1.Errors.LoadingModuleFailed, { module: res.given, error: res.error.message }));
+            throw new Error(messages_1.interpolate("Loading module {{module}} failed with error: {{error}}", { module: res.given, error: res.error.message }));
         }
-        var msg = alternatives.length ? messages_1.Errors.UnableToLoadAnyModule : messages_1.Errors.UnableToLoadOneModule;
+        var msg = alternatives.length ? "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}" : "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}";
         var loadModule = __spread([moduleName], alternatives).map(function (m) { return "\"" + m + "\""; }).join(', ');
         if (typeof installTip === 'string') {
             installTip = [{ module: installTip, label: "install \"" + installTip + "\"" }];
         }
         var fix = installTip
-            .map(function (tip) {
-            return "    " + (installTip.length === 1 ? '↳' : '•') + " " + messages_1.interpolate(messages_1.Helps.FixMissingModule, tip);
-        })
+            .map(function (tip) { return "    " + (installTip.length === 1 ? '↳' : '•') + " " + messages_1.interpolate("{{label}}: `npm i -D {{module}}` (or `yarn add --dev {{module}}`)", tip); })
             .join('\n');
         throw new Error(messages_1.interpolate(msg, {
             module: loadModule,
@@ -177,15 +176,20 @@ function requireWrapper(moduleName) {
     }
     var result = { exists: exists, path: path, given: moduleName };
     try {
-        result.exports = requireModule(moduleName);
+        result.exports = requireModule(path);
     }
     catch (error) {
-        result.error = error;
+        try {
+            result.exports = requireModule(moduleName);
+        }
+        catch (error) {
+            result.error = error;
+        }
     }
     return result;
 }
 var requireModule = function (mod) { return require(mod); };
-var resolveModule = function (mod) { return require.resolve(mod); };
+var resolveModule = function (mod) { return require.resolve(mod, { paths: [process.cwd(), __dirname] }); };
 function __requireModule(localRequire, localResolve) {
     requireModule = localRequire;
     resolveModule = localResolve;

node_modules/ts-jest/dist/utils/json.d.ts

@@ -0,0 +1,2 @@
+export declare function stringify(input: unknown): string;
+export declare function parse(input: string): any;

node_modules/ts-jest/dist/utils/json.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = exports.parse = exports.stringify = void 0;
 var stableStringify = require("fast-json-stable-stringify");
 var UNDEFINED = 'undefined';
 function stringify(input) {

node_modules/ts-jest/dist/utils/jsonable-value.d.ts

@@ -0,0 +1,10 @@
+export declare class JsonableValue<V = Record<string, any>> {
+    private _serialized;
+    private _value;
+    constructor(value: V);
+    set value(value: V);
+    get value(): V;
+    get serialized(): string;
+    valueOf(): V;
+    toString(): string;
+}

node_modules/ts-jest/dist/utils/jsonable-value.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonableValue = void 0;
 var json_1 = require("./json");
 var JsonableValue = (function () {
     function JsonableValue(value) {
@@ -13,14 +14,14 @@ var JsonableValue = (function () {
             this._value = value;
             this._serialized = json_1.stringify(value);
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     Object.defineProperty(JsonableValue.prototype, "serialized", {
         get: function () {
             return this._serialized;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     JsonableValue.prototype.valueOf = function () {

node_modules/ts-jest/dist/utils/logger.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootLogger = void 0;
 var bs_logger_1 = require("bs-logger");
 var backports_1 = require("./backports");
 var original = process.env.TS_JEST_LOG;

node_modules/ts-jest/dist/utils/memoize.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memoize = void 0;
 var cacheProp = Symbol.for('[memoize]');
 function Memoize(keyBuilder) {
     return function (_, propertyKey, descriptor) {

node_modules/ts-jest/dist/utils/messages.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolate = void 0;
+function interpolate(msg, vars) {
+    if (vars === void 0) { vars = {}; }
+    return msg.replace(/\{\{([^\}]+)\}\}/g, function (_, key) { return (key in vars ? vars[key] : _); });
+}
+exports.interpolate = interpolate;

node_modules/ts-jest/dist/utils/normalize-slashes.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSlashes = void 0;
 function normalizeSlashes(value) {
     return value.replace(/\\/g, '/');
 }

node_modules/ts-jest/dist/utils/sha1.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha1 = exports.cache = void 0;
 var crypto_1 = require("crypto");
 exports.cache = Object.create(null);
 function sha1() {

node_modules/ts-jest/dist/utils/testing.d.ts

@@ -1,28 +1,28 @@
 /// <reference types="jest" />
-declare type MockableFunction = (...args: any[]) => any;
-declare type MethodKeysOf<T> = {
+export declare type MockableFunction = (...args: any[]) => any;
+export declare type MethodKeysOf<T> = {
     [K in keyof T]: T[K] extends MockableFunction ? K : never;
 }[keyof T];
-declare type PropertyKeysOf<T> = {
+export declare type PropertyKeysOf<T> = {
     [K in keyof T]: T[K] extends MockableFunction ? never : K;
 }[keyof T];
-declare type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
-declare type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
-interface MockWithArgs<T extends MockableFunction> extends jest.MockInstance<ReturnType<T>, ArgumentsOf<T>> {
+export declare type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
+export declare type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
+export interface MockWithArgs<T extends MockableFunction> extends jest.MockInstance<ReturnType<T>, ArgumentsOf<T>> {
     new (...args: ConstructorArgumentsOf<T>): T;
     (...args: ArgumentsOf<T>): ReturnType<T>;
 }
-declare type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R ? jest.MockInstance<R, ConstructorArgumentsOf<T>> : {};
-declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
+export declare type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R ? jest.MockInstance<R, ConstructorArgumentsOf<T>> : T;
+export declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
     [K in keyof T]: T[K];
 };
-declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
-declare type MockedObject<T> = MaybeMockedConstructor<T> & {
+export declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
+export declare type MockedObject<T> = MaybeMockedConstructor<T> & {
     [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunction<T[K]> : T[K];
 } & {
     [K in PropertyKeysOf<T>]: T[K];
 };
-declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
+export declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
     [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunctionDeep<T[K]> : T[K];
 } & {
     [K in PropertyKeysOf<T>]: MaybeMockedDeep<T[K]>;
@@ -31,4 +31,3 @@ export declare type MaybeMockedDeep<T> = T extends MockableFunction ? MockedFunc
 export declare type MaybeMocked<T> = T extends MockableFunction ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
 export declare function mocked<T>(item: T, deep?: false): MaybeMocked<T>;
 export declare function mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
-export {};

node_modules/ts-jest/dist/utils/testing.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mocked = void 0;
 function mocked(item, _deep) {
     if (_deep === void 0) { _deep = false; }
     return item;

node_modules/ts-jest/dist/utils/ts-error.js

@@ -3,7 +3,7 @@ var __extends = (this && this.__extends) || (function () {
     var extendStatics = function (d, b) {
         extendStatics = Object.setPrototypeOf ||
             ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
         return extendStatics(d, b);
     };
     return function (d, b) {
@@ -13,6 +13,7 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSError = exports.INSPECT_CUSTOM = void 0;
 var make_error_1 = require("make-error");
 var util_1 = require("util");
 var logger_1 = require("./logger");
@@ -22,9 +23,8 @@ exports.INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
 var TSError = (function (_super) {
     __extends(TSError, _super);
     function TSError(diagnosticText, diagnosticCodes) {
-        var _this = _super.call(this, messages_1.interpolate(messages_1.Errors.UnableToCompileTypeScript, {
+        var _this = _super.call(this, messages_1.interpolate("{{diagnostics}}", {
             diagnostics: diagnosticText.trim(),
-            help: messages_1.Helps.IgnoreDiagnosticCode,
         })) || this;
         _this.diagnosticText = diagnosticText;
         _this.diagnosticCodes = diagnosticCodes;

node_modules/ts-jest/dist/utils/version-checkers.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionCheckers = void 0;
+var semver_1 = require("semver");
+var get_package_version_1 = require("./get-package-version");
+var logger_1 = require("./logger");
+var messages_1 = require("./messages");
+var logger = logger_1.rootLogger.child({ namespace: 'versions' });
+exports.VersionCheckers = {
+    jest: createVersionChecker('jest', ">=26 <27"),
+    typescript: createVersionChecker('typescript', ">=3.8 <5"),
+    babelJest: createVersionChecker('babel-jest', ">=26 <27"),
+    babelCore: createVersionChecker('@babel/core', ">=7.0.0-beta.0 <8"),
+};
+function checkVersion(name, expectedRange, action) {
+    if (action === void 0) { action = 'warn'; }
+    var success = true;
+    if (!('TS_JEST_DISABLE_VER_CHECKER' in process.env)) {
+        var version = get_package_version_1.getPackageVersion(name);
+        success = !!version && semver_1.satisfies(version, expectedRange);
+        logger.debug({
+            actualVersion: version,
+            expectedVersion: expectedRange,
+        }, 'checking version of %s: %s', name, success ? 'OK' : 'NOT OK');
+        if (!action || success)
+            return success;
+        var message = messages_1.interpolate(version ? "Version {{actualVersion}} of {{module}} installed has not been tested with ts-jest. If you're experiencing issues, consider using a supported version ({{expectedVersion}}). Please do not report issues in ts-jest if you are using unsupported versions." : "Module {{module}} is not installed. If you're experiencing issues, consider installing a supported version ({{expectedVersion}}).", {
+            module: name,
+            actualVersion: version || '??',
+            expectedVersion: rangeToHumanString(expectedRange),
+        });
+        if (action === 'warn') {
+            logger.warn(message);
+        }
+        else if (action === 'throw') {
+            logger.fatal(message);
+            throw new RangeError(message);
+        }
+    }
+    return success;
+}
+function rangeToHumanString(versionRange) {
+    return new semver_1.Range(versionRange).toString();
+}
+function createVersionChecker(moduleName, expectedVersion) {
+    var memo;
+    var warn = function () {
+        if (memo !== undefined)
+            return memo;
+        return (memo = checkVersion(moduleName, expectedVersion, 'warn'));
+    };
+    var raise = function () { return checkVersion(moduleName, expectedVersion, 'throw'); };
+    return {
+        raise: raise,
+        warn: warn,
+        forget: function () {
+            memo = undefined;
+        },
+    };
+}