ts-jest 29.3.2 → 29.3.3

package/dist/legacy/config/config-set.js

@@ -1,15 +1,4 @@
 "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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -33,42 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -84,21 +37,21 @@ exports.ConfigSet = exports.TS_JEST_OUT_DIR = exports.IGNORE_DIAGNOSTIC_CODES =
  * version of the `jest.ProjectConfig`, and then later it calls `process()`
  * with the complete, object version of it.
  */
-var fs_1 = require("fs");
-var module_1 = __importDefault(require("module"));
-var path_1 = require("path");
-var bs_logger_1 = require("bs-logger");
-var jest_util_1 = require("jest-util");
-var json5_1 = __importDefault(require("json5"));
-var constants_1 = require("../../constants");
-var hoistJestTransformer = __importStar(require("../../transformers/hoist-jest"));
-var utils_1 = require("../../utils");
-var backports_1 = require("../../utils/backports");
-var importer_1 = require("../../utils/importer");
-var messages_1 = require("../../utils/messages");
-var normalize_slashes_1 = require("../../utils/normalize-slashes");
-var sha1_1 = require("../../utils/sha1");
-var ts_error_1 = require("../../utils/ts-error");
+const fs_1 = require("fs");
+const module_1 = __importDefault(require("module"));
+const path_1 = require("path");
+const bs_logger_1 = require("bs-logger");
+const jest_util_1 = require("jest-util");
+const json5_1 = __importDefault(require("json5"));
+const constants_1 = require("../../constants");
+const hoistJestTransformer = __importStar(require("../../transformers/hoist-jest"));
+const utils_1 = require("../../utils");
+const backports_1 = require("../../utils/backports");
+const importer_1 = require("../../utils/importer");
+const messages_1 = require("../../utils/messages");
+const normalize_slashes_1 = require("../../utils/normalize-slashes");
+const sha1_1 = require("../../utils/sha1");
+const ts_error_1 = require("../../utils/ts-error");
 /**
  * @internal
  */
@@ -115,112 +68,141 @@ exports.IGNORE_DIAGNOSTIC_CODES = [
  * @internal
  */
 exports.TS_JEST_OUT_DIR = '$$ts-jest$$';
-var normalizeRegex = function (pattern) {
-    return pattern ? (typeof pattern === 'string' ? pattern : pattern.source) : undefined;
-};
-var toDiagnosticCode = function (code) { var _a; return code ? (_a = parseInt("".concat(code).trim().replace(/^TS/, ''), 10)) !== null && _a !== void 0 ? _a : undefined : undefined; };
-var toDiagnosticCodeList = function (items, into) {
-    var e_1, _a;
-    if (into === void 0) { into = []; }
-    try {
-        for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
-            var item = items_1_1.value;
-            if (typeof item === 'string') {
-                var children = item.trim().split(/\s*,\s*/g);
-                if (children.length > 1) {
-                    toDiagnosticCodeList(children, into);
-                    continue;
-                }
-                item = children[0];
-            }
-            if (!item)
+const normalizeRegex = (pattern) => pattern ? (typeof pattern === 'string' ? pattern : pattern.source) : undefined;
+const toDiagnosticCode = (code) => code ? parseInt(`${code}`.trim().replace(/^TS/, ''), 10) ?? undefined : undefined;
+const toDiagnosticCodeList = (items, into = []) => {
+    for (let item of items) {
+        if (typeof item === 'string') {
+            const children = item.trim().split(/\s*,\s*/g);
+            if (children.length > 1) {
+                toDiagnosticCodeList(children, into);
                 continue;
-            var code = toDiagnosticCode(item);
-            if (code && !into.includes(code))
-                into.push(code);
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
+            }
+            item = children[0];
         }
-        finally { if (e_1) throw e_1.error; }
+        if (!item)
+            continue;
+        const code = toDiagnosticCode(item);
+        if (code && !into.includes(code))
+            into.push(code);
     }
     return into;
 };
-var requireFromString = function (code, fileName) {
+const requireFromString = (code, fileName) => {
     // @ts-expect-error `_nodeModulePaths` is not exposed in typing
-    var paths = module_1.default._nodeModulePaths((0, path_1.dirname)(fileName));
-    var parent = module.parent;
-    var m = new module_1.default(fileName, parent);
+    const paths = module_1.default._nodeModulePaths((0, path_1.dirname)(fileName));
+    const parent = module.parent;
+    const m = new module_1.default(fileName, parent);
     m.filename = fileName;
     m.paths = [].concat(paths);
     // @ts-expect-error `_compile` is not exposed in typing
     m._compile(code, fileName);
-    var exports = m.exports;
+    const exports = m.exports;
     // eslint-disable-next-line @typescript-eslint/no-unused-expressions
     parent && parent.children && parent.children.splice(parent.children.indexOf(m), 1);
     return exports;
 };
-var ConfigSet = /** @class */ (function () {
-    function ConfigSet(jestConfig, parentLogger) {
-        var _a, _b;
-        var _c, _d, _e, _f;
+class ConfigSet {
+    parentLogger;
+    /**
+     * Use by e2e, don't mark as internal
+     */
+    tsJestDigest = exports.MY_DIGEST;
+    logger;
+    compilerModule;
+    isolatedModules;
+    cwd;
+    rootDir;
+    cacheSuffix;
+    tsCacheDir;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    parsedTsConfig;
+    resolvedTransformers = {
+        before: [],
+        after: [],
+        afterDeclarations: [],
+    };
+    useESM = false;
+    /**
+     * @internal
+     */
+    babelConfig;
+    /**
+     * @internal
+     */
+    babelJestTransformer;
+    /**
+     * @internal
+     */
+    _jestCfg;
+    /**
+     * @internal
+     */
+    _diagnostics;
+    /**
+     * @internal
+     */
+    _stringifyContentRegExp;
+    /**
+     * @internal
+     */
+    _matchablePatterns;
+    /**
+     * @internal
+     */
+    _matchTestFilePath;
+    /**
+     * @internal
+     */
+    _shouldIgnoreDiagnosticsForFile;
+    /**
+     * @internal
+     */
+    _overriddenCompilerOptions = {
+        inlineSourceMap: false,
+        declaration: false, // we don't want to create declaration files
+        isolatedDeclarations: false, // we don't want to create declaration files
+        noEmit: false, // set to true will make compiler API not emit any compiled results.
+        // else istanbul related will be dropped
+        removeComments: false,
+        // to clear out else it's buggy
+        out: undefined,
+        outFile: undefined,
+        composite: undefined, // see https://github.com/TypeStrong/ts-node/pull/657/files
+        declarationDir: undefined,
+        declarationMap: undefined,
+        emitDeclarationOnly: undefined,
+        sourceRoot: undefined,
+        tsBuildInfoFile: undefined,
+    };
+    /**
+     * @internal
+     */
+    tsconfigFilePath;
+    constructor(jestConfig, parentLogger) {
         this.parentLogger = parentLogger;
-        /**
-         * Use by e2e, don't mark as internal
-         */
-        this.tsJestDigest = exports.MY_DIGEST;
-        this.resolvedTransformers = {
-            before: [],
-            after: [],
-            afterDeclarations: [],
-        };
-        this.useESM = false;
-        /**
-         * @internal
-         */
-        this._overriddenCompilerOptions = {
-            inlineSourceMap: false,
-            // we don't want to create declaration files
-            declaration: false,
-            noEmit: false, // set to true will make compiler API not emit any compiled results.
-            // else istanbul related will be dropped
-            removeComments: false,
-            // to clear out else it's buggy
-            out: undefined,
-            outFile: undefined,
-            composite: undefined, // see https://github.com/TypeStrong/ts-node/pull/657/files
-            declarationDir: undefined,
-            declarationMap: undefined,
-            emitDeclarationOnly: undefined,
-            sourceRoot: undefined,
-            tsBuildInfoFile: undefined,
-        };
         this.logger = this.parentLogger
-            ? this.parentLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'config', _a))
+            ? this.parentLogger.child({ [bs_logger_1.LogContexts.namespace]: 'config' })
             : utils_1.rootLogger.child({ namespace: 'config' });
-        this._backportJestCfg(jestConfig !== null && jestConfig !== void 0 ? jestConfig : Object.create(null));
-        this.cwd = (0, path_1.normalize)((_c = this._jestCfg.cwd) !== null && _c !== void 0 ? _c : process.cwd());
-        this.rootDir = (0, path_1.normalize)((_d = this._jestCfg.rootDir) !== null && _d !== void 0 ? _d : this.cwd);
-        var tsJestCfg = this._jestCfg.globals && this._jestCfg.globals['ts-jest'];
-        var options = tsJestCfg !== null && tsJestCfg !== void 0 ? tsJestCfg : Object.create(null);
+        this._backportJestCfg(jestConfig ?? Object.create(null));
+        this.cwd = (0, path_1.normalize)(this._jestCfg.cwd ?? process.cwd());
+        this.rootDir = (0, path_1.normalize)(this._jestCfg.rootDir ?? this.cwd);
+        const tsJestCfg = this._jestCfg.globals && this._jestCfg.globals['ts-jest'];
+        const options = tsJestCfg ?? Object.create(null);
         // compiler module
-        this.compilerModule = importer_1.importer.typescript("Using \"ts-jest\" requires this package to be installed." /* ImportReasons.TsJest */, (_e = options.compiler) !== null && _e !== void 0 ? _e : 'typescript');
+        this.compilerModule = importer_1.importer.typescript("Using \"ts-jest\" requires this package to be installed." /* ImportReasons.TsJest */, options.compiler ?? 'typescript');
         this.logger.debug({ compilerModule: this.compilerModule }, 'normalized compiler module config via ts-jest option');
         this._setupConfigSet(options);
-        this._matchablePatterns = __spreadArray(__spreadArray([], __read(this._jestCfg.testMatch), false), __read(this._jestCfg.testRegex), false).filter(function (pattern) {
-            /**
-             * jest config testRegex doesn't always deliver the correct RegExp object
-             * See https://github.com/facebook/jest/issues/9778
-             */
-            return pattern instanceof RegExp || typeof pattern === 'string';
-        });
+        this._matchablePatterns = [...this._jestCfg.testMatch, ...this._jestCfg.testRegex].filter((pattern) => 
+        /**
+         * jest config testRegex doesn't always deliver the correct RegExp object
+         * See https://github.com/facebook/jest/issues/9778
+         */
+        pattern instanceof RegExp || typeof pattern === 'string');
         if (!this._matchablePatterns.length) {
-            (_b = this._matchablePatterns).push.apply(_b, __spreadArray([], __read(constants_1.DEFAULT_JEST_TEST_MATCH), false));
+            this._matchablePatterns.push(...constants_1.DEFAULT_JEST_TEST_MATCH);
         }
-        this._matchTestFilePath = (0, jest_util_1.globsToMatcher)(this._matchablePatterns.filter(function (pattern) { return typeof pattern === 'string'; }));
+        this._matchTestFilePath = (0, jest_util_1.globsToMatcher)(this._matchablePatterns.filter((pattern) => typeof pattern === 'string'));
         // isolatedModules
         if (options.isolatedModules) {
             this.parsedTsConfig.options.isolatedModules = true;
@@ -233,44 +215,54 @@ var ConfigSet = /** @class */ (function () {
                 this.logger.warn("\n    The \"ts-jest\" config option \"isolatedModules\" is deprecated and will be removed in v30.0.0. Please use \"isolatedModules: true\", see https://www.typescriptlang.org/tsconfig/#isolatedModules\n  " /* Deprecations.IsolatedModulesWithoutTsconfigPath */);
             }
         }
-        this.isolatedModules = (_f = this.parsedTsConfig.options.isolatedModules) !== null && _f !== void 0 ? _f : false;
+        this.isolatedModules = this.parsedTsConfig.options.isolatedModules ?? false;
         this._resolveTsCacheDir();
     }
     /**
      * @internal
      */
-    ConfigSet.prototype._backportJestCfg = function (jestCfg) {
-        var _a, _b;
-        var config = (0, backports_1.backportJestConfig)(this.logger, jestCfg);
+    _backportJestCfg(jestCfg) {
+        const config = (0, backports_1.backportJestConfig)(this.logger, jestCfg);
         this.logger.debug({ jestConfig: config }, 'normalized jest config');
-        this._jestCfg = __assign(__assign({}, config), { testMatch: (_a = config.testMatch) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_JEST_TEST_MATCH, testRegex: (_b = config.testRegex) !== null && _b !== void 0 ? _b : [] });
-    };
+        this._jestCfg = {
+            ...config,
+            testMatch: config.testMatch ?? constants_1.DEFAULT_JEST_TEST_MATCH,
+            testRegex: config.testRegex ?? [],
+        };
+    }
     /**
      * @internal
      */
-    ConfigSet.prototype._setupConfigSet = function (options) {
-        var _this = this;
-        var _a, _b, _c, _d, _e;
+    _setupConfigSet(options) {
         // useESM
-        this.useESM = (_a = options.useESM) !== null && _a !== void 0 ? _a : false;
+        this.useESM = options.useESM ?? false;
         // babel config (for babel-jest) default is undefined so we don't need to have fallback like tsConfig
         if (!options.babelConfig) {
             this.logger.debug('babel is disabled');
         }
         else {
-            var baseBabelCfg = { cwd: this.cwd };
+            const baseBabelCfg = { cwd: this.cwd };
             if (typeof options.babelConfig === 'string') {
-                var babelCfgPath = this.resolvePath(options.babelConfig);
-                var babelFileExtName = (0, path_1.extname)(options.babelConfig);
+                const babelCfgPath = this.resolvePath(options.babelConfig);
+                const babelFileExtName = (0, path_1.extname)(options.babelConfig);
                 if (babelFileExtName === '.js' || babelFileExtName === '.cjs') {
-                    this.babelConfig = __assign(__assign({}, baseBabelCfg), require(babelCfgPath));
+                    this.babelConfig = {
+                        ...baseBabelCfg,
+                        ...require(babelCfgPath),
+                    };
                 }
                 else {
-                    this.babelConfig = __assign(__assign({}, baseBabelCfg), json5_1.default.parse((0, fs_1.readFileSync)(babelCfgPath, 'utf-8')));
+                    this.babelConfig = {
+                        ...baseBabelCfg,
+                        ...json5_1.default.parse((0, fs_1.readFileSync)(babelCfgPath, 'utf-8')),
+                    };
                 }
             }
             else if (typeof options.babelConfig === 'object') {
-                this.babelConfig = __assign(__assign({}, baseBabelCfg), options.babelConfig);
+                this.babelConfig = {
+                    ...baseBabelCfg,
+                    ...options.babelConfig,
+                };
             }
             else {
                 this.babelConfig = baseBabelCfg;
@@ -282,17 +274,17 @@ var ConfigSet = /** @class */ (function () {
             this.logger.debug('created babel-jest transformer');
         }
         // diagnostics
-        var diagnosticsOpt = (_b = options.diagnostics) !== null && _b !== void 0 ? _b : true;
-        var ignoreList = __spreadArray([], __read(exports.IGNORE_DIAGNOSTIC_CODES), false);
+        const diagnosticsOpt = options.diagnostics ?? true;
+        const ignoreList = [...exports.IGNORE_DIAGNOSTIC_CODES];
         if (typeof diagnosticsOpt === 'object') {
-            var ignoreCodes = diagnosticsOpt.ignoreCodes;
+            const { ignoreCodes } = diagnosticsOpt;
             if (ignoreCodes) {
                 // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-                Array.isArray(ignoreCodes) ? ignoreList.push.apply(ignoreList, __spreadArray([], __read(ignoreCodes), false)) : ignoreList.push(ignoreCodes);
+                Array.isArray(ignoreCodes) ? ignoreList.push(...ignoreCodes) : ignoreList.push(ignoreCodes);
             }
             this._diagnostics = {
-                pretty: (_c = diagnosticsOpt.pretty) !== null && _c !== void 0 ? _c : true,
-                exclude: (_d = diagnosticsOpt.exclude) !== null && _d !== void 0 ? _d : [],
+                pretty: diagnosticsOpt.pretty ?? true,
+                exclude: diagnosticsOpt.exclude ?? [],
                 ignoreCodes: toDiagnosticCodeList(ignoreList),
                 throws: !diagnosticsOpt.warnOnly,
             };
@@ -308,15 +300,15 @@ var ConfigSet = /** @class */ (function () {
         if (diagnosticsOpt) {
             this._shouldIgnoreDiagnosticsForFile = this._diagnostics.exclude.length
                 ? (0, jest_util_1.globsToMatcher)(this._diagnostics.exclude)
-                : function () { return false; };
+                : () => false;
         }
         else {
-            this._shouldIgnoreDiagnosticsForFile = function () { return true; };
+            this._shouldIgnoreDiagnosticsForFile = () => true;
         }
         this.logger.debug({ diagnostics: this._diagnostics }, 'normalized diagnostics config via ts-jest option');
         // tsconfig
-        var tsconfigOpt = options.tsconfig;
-        var configFilePath = typeof tsconfigOpt === 'string' ? this.resolvePath(tsconfigOpt) : undefined;
+        const tsconfigOpt = options.tsconfig;
+        const configFilePath = typeof tsconfigOpt === 'string' ? this.resolvePath(tsconfigOpt) : undefined;
         this.parsedTsConfig = this._getAndResolveTsConfig(typeof tsconfigOpt === 'object' ? tsconfigOpt : undefined, configFilePath);
         // throw errors if any matching wanted diagnostics
         this.raiseDiagnostics(this.parsedTsConfig.errors, configFilePath);
@@ -329,12 +321,12 @@ var ConfigSet = /** @class */ (function () {
                 version: hoistJestTransformer.version,
             },
         ];
-        var astTransformers = options.astTransformers;
+        const { astTransformers } = options;
         if (astTransformers) {
-            var resolveTransformerFunc_1 = function (transformerPath) {
-                var transformerFunc;
+            const resolveTransformerFunc = (transformerPath) => {
+                let transformerFunc;
                 if ((0, path_1.extname)(transformerPath) === '.ts') {
-                    var compiledTransformer = importer_1.importer
+                    const compiledTransformer = importer_1.importer
                         .esBuild("Using \"esbuild\" requires this package to be installed." /* ImportReasons.EsBuild */)
                         .transformSync((0, fs_1.readFileSync)(transformerPath, 'utf-8'), {
                         loader: 'ts',
@@ -347,32 +339,39 @@ var ConfigSet = /** @class */ (function () {
                     transformerFunc = require(transformerPath);
                 }
                 if (!transformerFunc.version) {
-                    _this.logger.warn("The AST transformer {{file}} must have an `export const version = <your_transformer_version>`" /* Errors.MissingTransformerVersion */, { file: transformerPath });
+                    this.logger.warn("The AST transformer {{file}} must have an `export const version = <your_transformer_version>`" /* Errors.MissingTransformerVersion */, { file: transformerPath });
                 }
                 if (!transformerFunc.name) {
-                    _this.logger.warn("The AST transformer {{file}} must have an `export const name = <your_transformer_name>`" /* Errors.MissingTransformerName */, { file: transformerPath });
+                    this.logger.warn("The AST transformer {{file}} must have an `export const name = <your_transformer_name>`" /* Errors.MissingTransformerName */, { file: transformerPath });
                 }
                 return transformerFunc;
             };
-            var resolveTransformers = function (transformers) {
-                return transformers.map(function (transformer) {
-                    if (typeof transformer === 'string') {
-                        return resolveTransformerFunc_1(_this.resolvePath(transformer, { nodeResolve: true }));
-                    }
-                    else {
-                        return __assign(__assign({}, resolveTransformerFunc_1(_this.resolvePath(transformer.path, { nodeResolve: true }))), { options: transformer.options });
-                    }
-                });
-            };
+            const resolveTransformers = (transformers) => transformers.map((transformer) => {
+                if (typeof transformer === 'string') {
+                    return resolveTransformerFunc(this.resolvePath(transformer, { nodeResolve: true }));
+                }
+                else {
+                    return {
+                        ...resolveTransformerFunc(this.resolvePath(transformer.path, { nodeResolve: true })),
+                        options: transformer.options,
+                    };
+                }
+            });
             if (astTransformers.before) {
                 /* istanbul ignore next (already covered in unit test) */
-                (_e = this.resolvedTransformers.before) === null || _e === void 0 ? void 0 : _e.push.apply(_e, __spreadArray([], __read(resolveTransformers(astTransformers.before)), false));
+                this.resolvedTransformers.before?.push(...resolveTransformers(astTransformers.before));
             }
             if (astTransformers.after) {
-                this.resolvedTransformers = __assign(__assign({}, this.resolvedTransformers), { after: resolveTransformers(astTransformers.after) });
+                this.resolvedTransformers = {
+                    ...this.resolvedTransformers,
+                    after: resolveTransformers(astTransformers.after),
+                };
             }
             if (astTransformers.afterDeclarations) {
-                this.resolvedTransformers = __assign(__assign({}, this.resolvedTransformers), { afterDeclarations: resolveTransformers(astTransformers.afterDeclarations) });
+                this.resolvedTransformers = {
+                    ...this.resolvedTransformers,
+                    afterDeclarations: resolveTransformers(astTransformers.afterDeclarations),
+                };
             }
         }
         this.logger.debug({ customTransformers: this.resolvedTransformers }, 'normalized custom AST transformers via ts-jest option');
@@ -384,11 +383,11 @@ var ConfigSet = /** @class */ (function () {
                     : options.stringifyContentPathRegex;
             this.logger.debug({ stringifyContentPathRegex: this._stringifyContentRegExp }, 'normalized stringifyContentPathRegex config via ts-jest option');
         }
-    };
+    }
     /**
      * @internal
      */
-    ConfigSet.prototype._resolveTsCacheDir = function () {
+    _resolveTsCacheDir() {
         this.cacheSuffix = (0, sha1_1.sha1)((0, utils_1.stringify)({
             version: this.compilerModule.version,
             digest: this.tsJestDigest,
@@ -400,39 +399,37 @@ var ConfigSet = /** @class */ (function () {
             isolatedModules: this.isolatedModules,
             diagnostics: this._diagnostics,
             transformers: Object.values(this.resolvedTransformers)
-                .reduce(function (prevVal, currentVal) { return __spreadArray(__spreadArray([], __read(prevVal), false), [currentVal], false); })
-                .map(function (transformer) { return "".concat(transformer.name, "-").concat(transformer.version); }),
+                .reduce((prevVal, currentVal) => [...prevVal, currentVal])
+                .map((transformer) => `${transformer.name}-${transformer.version}`),
         }));
         if (!this._jestCfg.cache) {
             this.logger.debug('file caching disabled');
         }
         else {
-            var res = (0, path_1.join)(this._jestCfg.cacheDirectory, 'ts-jest', this.cacheSuffix.substr(0, 2), this.cacheSuffix.substr(2));
+            const res = (0, path_1.join)(this._jestCfg.cacheDirectory, 'ts-jest', this.cacheSuffix.substr(0, 2), this.cacheSuffix.substr(2));
             this.logger.debug({ cacheDirectory: res }, 'will use file caching');
             this.tsCacheDir = res;
         }
-    };
+    }
     /**
      * @internal
      */
-    ConfigSet.prototype._getAndResolveTsConfig = function (compilerOptions, resolvedConfigFile) {
-        var e_2, _a, _b;
-        var _c, _d, _e;
-        var result = this._resolveTsConfig(compilerOptions, resolvedConfigFile);
-        var forcedOptions = this._overriddenCompilerOptions;
-        var finalOptions = result.options;
+    _getAndResolveTsConfig(compilerOptions, resolvedConfigFile) {
+        const result = this._resolveTsConfig(compilerOptions, resolvedConfigFile);
+        const { _overriddenCompilerOptions: forcedOptions } = this;
+        const finalOptions = result.options;
         // Target ES2015 output by default (instead of ES3).
         if (finalOptions.target === undefined) {
             finalOptions.target = this.compilerModule.ScriptTarget.ES2015;
         }
         // check the module interoperability
-        var target = finalOptions.target;
+        const target = finalOptions.target;
         // compute the default if not set
-        var defaultModule = [this.compilerModule.ScriptTarget.ES3, this.compilerModule.ScriptTarget.ES5].includes(target)
+        const defaultModule = [this.compilerModule.ScriptTarget.ES3, this.compilerModule.ScriptTarget.ES5].includes(target)
             ? this.compilerModule.ModuleKind.CommonJS
             : this.compilerModule.ModuleKind.ESNext;
-        var moduleValue = (_c = finalOptions.module) !== null && _c !== void 0 ? _c : defaultModule;
-        var warningModulesForEsmInterop = [
+        const moduleValue = finalOptions.module ?? defaultModule;
+        const warningModulesForEsmInterop = [
             this.compilerModule.ModuleKind.CommonJS,
             this.compilerModule.ModuleKind.Node16,
             this.compilerModule.ModuleKind.NodeNext,
@@ -453,65 +450,63 @@ var ConfigSet = /** @class */ (function () {
         if (finalOptions.allowJs && !finalOptions.outDir) {
             finalOptions.outDir = exports.TS_JEST_OUT_DIR;
         }
-        try {
-            // ensure undefined are removed and other values are overridden
-            for (var _f = __values(Object.keys(forcedOptions)), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var key = _g.value;
-                var val = forcedOptions[key];
-                if (val === undefined) {
-                    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-                    delete finalOptions[key];
-                }
-                else {
-                    finalOptions[key] = val;
-                }
+        // ensure undefined are removed and other values are overridden
+        for (const key of Object.keys(forcedOptions)) {
+            const val = forcedOptions[key];
+            if (val === undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete finalOptions[key];
             }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+            else {
+                finalOptions[key] = val;
             }
-            finally { if (e_2) throw e_2.error; }
         }
         /**
          * See https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping
          * Every time this page is updated, we also need to update here. Here we only show warning message for Node LTS versions
          */
-        var nodeJsVer = process.version;
-        var compilationTarget = result.options.target;
-        var TARGET_TO_VERSION_MAPPING = (_b = {},
-            _b[this.compilerModule.ScriptTarget.ES2018] = 'es2018',
-            _b[this.compilerModule.ScriptTarget.ES2019] = 'es2019',
-            _b[this.compilerModule.ScriptTarget.ES2020] = 'es2020',
-            _b[this.compilerModule.ScriptTarget.ESNext] = 'ESNext',
-            _b);
+        const nodeJsVer = process.version;
+        const compilationTarget = result.options.target;
+        const TARGET_TO_VERSION_MAPPING = {
+            [this.compilerModule.ScriptTarget.ES2018]: 'es2018',
+            [this.compilerModule.ScriptTarget.ES2019]: 'es2019',
+            [this.compilerModule.ScriptTarget.ES2020]: 'es2020',
+            [this.compilerModule.ScriptTarget.ESNext]: 'ESNext',
+        };
         /* istanbul ignore next (cover by e2e) */
         if (compilationTarget &&
             !this.babelConfig &&
             nodeJsVer.startsWith('v12') &&
             compilationTarget > this.compilerModule.ScriptTarget.ES2019) {
-            var message = (0, messages_1.interpolate)("There is a mismatch between your NodeJs version {{nodeJsVer}} and your TypeScript target {{compilationTarget}}. This might lead to some unexpected errors when running tests with `ts-jest`. To fix this, you can check https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping" /* Errors.MismatchNodeTargetMapping */, {
+            const message = (0, messages_1.interpolate)("There is a mismatch between your NodeJs version {{nodeJsVer}} and your TypeScript target {{compilationTarget}}. This might lead to some unexpected errors when running tests with `ts-jest`. To fix this, you can check https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping" /* Errors.MismatchNodeTargetMapping */, {
                 nodeJsVer: process.version,
                 compilationTarget: TARGET_TO_VERSION_MAPPING[compilationTarget],
             });
             this.logger.warn(message);
         }
-        var resultOptions = result.options;
-        var sourceMap = (_d = resultOptions.sourceMap) !== null && _d !== void 0 ? _d : true;
-        return __assign(__assign({}, result), { options: __assign(__assign({}, resultOptions), { sourceMap: sourceMap, inlineSources: sourceMap, module: (_e = resultOptions.module) !== null && _e !== void 0 ? _e : this.compilerModule.ModuleKind.CommonJS }) });
-    };
-    ConfigSet.prototype._resolveTsConfig = function (compilerOptions, resolvedConfigFile) {
-        var config = { compilerOptions: Object.create(null) };
-        var basePath = (0, normalize_slashes_1.normalizeSlashes)(this.rootDir);
-        var ts = this.compilerModule;
+        const resultOptions = result.options;
+        const sourceMap = resultOptions.sourceMap ?? true;
+        return {
+            ...result,
+            options: {
+                ...resultOptions,
+                sourceMap,
+                inlineSources: sourceMap,
+                module: resultOptions.module ?? this.compilerModule.ModuleKind.CommonJS,
+            },
+        };
+    }
+    _resolveTsConfig(compilerOptions, resolvedConfigFile) {
+        let config = { compilerOptions: Object.create(null) };
+        let basePath = (0, normalize_slashes_1.normalizeSlashes)(this.rootDir);
+        const ts = this.compilerModule;
         // Read project configuration when available.
         this.tsconfigFilePath = resolvedConfigFile
             ? (0, normalize_slashes_1.normalizeSlashes)(resolvedConfigFile)
             : ts.findConfigFile((0, normalize_slashes_1.normalizeSlashes)(this.rootDir), ts.sys.fileExists);
         if (this.tsconfigFilePath) {
             this.logger.debug({ tsConfigFileName: this.tsconfigFilePath }, 'readTsConfig(): reading', this.tsconfigFilePath);
-            var result = ts.readConfigFile(this.tsconfigFilePath, ts.sys.readFile);
+            const result = ts.readConfigFile(this.tsconfigFilePath, ts.sys.readFile);
             // Return diagnostics.
             if (result.error) {
                 return { errors: [result.error], fileNames: [], options: {} };
@@ -520,71 +515,66 @@ var ConfigSet = /** @class */ (function () {
             basePath = (0, normalize_slashes_1.normalizeSlashes)((0, path_1.dirname)(this.tsconfigFilePath));
         }
         // Override default configuration options `ts-jest` requires.
-        config.compilerOptions = __assign(__assign({}, config.compilerOptions), compilerOptions);
+        config.compilerOptions = {
+            ...config.compilerOptions,
+            ...compilerOptions,
+        };
         // parse json, merge config extending others, ...
         return ts.parseJsonConfigFileContent(config, ts.sys, basePath, undefined, this.tsconfigFilePath);
-    };
-    ConfigSet.prototype.isTestFile = function (fileName) {
-        var _this = this;
-        return this._matchablePatterns.some(function (pattern) {
-            return typeof pattern === 'string' ? _this._matchTestFilePath(fileName) : pattern.test(fileName);
-        });
-    };
-    ConfigSet.prototype.shouldStringifyContent = function (filePath) {
+    }
+    isTestFile(fileName) {
+        return this._matchablePatterns.some((pattern) => typeof pattern === 'string' ? this._matchTestFilePath(fileName) : pattern.test(fileName));
+    }
+    shouldStringifyContent(filePath) {
         return this._stringifyContentRegExp ? this._stringifyContentRegExp.test(filePath) : false;
-    };
-    ConfigSet.prototype.raiseDiagnostics = function (diagnostics, filePath, logger) {
-        var _this = this;
-        if (logger === void 0) { logger = this.logger; }
-        var ignoreCodes = this._diagnostics.ignoreCodes;
-        var DiagnosticCategory = this.compilerModule.DiagnosticCategory;
-        var filteredDiagnostics = filePath && !this.shouldReportDiagnostics(filePath)
+    }
+    raiseDiagnostics(diagnostics, filePath, logger = this.logger) {
+        const { ignoreCodes } = this._diagnostics;
+        const { DiagnosticCategory } = this.compilerModule;
+        const filteredDiagnostics = filePath && !this.shouldReportDiagnostics(filePath)
             ? []
-            : diagnostics.filter(function (diagnostic) {
-                var _a;
-                if (((_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.fileName) && !_this.shouldReportDiagnostics(diagnostic.file.fileName)) {
+            : diagnostics.filter((diagnostic) => {
+                if (diagnostic.file?.fileName && !this.shouldReportDiagnostics(diagnostic.file.fileName)) {
                     return false;
                 }
                 return !ignoreCodes.includes(diagnostic.code);
             });
         if (!filteredDiagnostics.length)
             return;
-        var error = this.createTsError(filteredDiagnostics);
+        const error = this.createTsError(filteredDiagnostics);
         // only throw if `warnOnly` and it is a warning or error
-        var importantCategories = [DiagnosticCategory.Warning, DiagnosticCategory.Error];
-        if (this._diagnostics.throws && filteredDiagnostics.some(function (d) { return importantCategories.includes(d.category); })) {
+        const importantCategories = [DiagnosticCategory.Warning, DiagnosticCategory.Error];
+        if (this._diagnostics.throws && filteredDiagnostics.some((d) => importantCategories.includes(d.category))) {
             throw error;
         }
-        logger.warn({ error: error }, error.message);
-    };
-    ConfigSet.prototype.shouldReportDiagnostics = function (filePath) {
-        var fileExtension = (0, path_1.extname)(filePath);
+        logger.warn({ error }, error.message);
+    }
+    shouldReportDiagnostics(filePath) {
+        const fileExtension = (0, path_1.extname)(filePath);
         return constants_1.JS_JSX_EXTENSIONS.includes(fileExtension)
             ? this.parsedTsConfig.options.checkJs && !this._shouldIgnoreDiagnosticsForFile(filePath)
             : !this._shouldIgnoreDiagnosticsForFile(filePath);
-    };
+    }
     /**
      * @internal
      */
-    ConfigSet.prototype.createTsError = function (diagnostics) {
-        var _this = this;
-        var formatDiagnostics = this._diagnostics.pretty
+    createTsError(diagnostics) {
+        const formatDiagnostics = this._diagnostics.pretty
             ? this.compilerModule.formatDiagnosticsWithColorAndContext
             : this.compilerModule.formatDiagnostics;
         /* istanbul ignore next (not possible to cover) */
-        var diagnosticHost = {
-            getNewLine: function () { return '\n'; },
-            getCurrentDirectory: function () { return _this.cwd; },
-            getCanonicalFileName: function (path) { return path; },
+        const diagnosticHost = {
+            getNewLine: () => '\n',
+            getCurrentDirectory: () => this.cwd,
+            getCanonicalFileName: (path) => path,
         };
-        var diagnosticText = formatDiagnostics(diagnostics, diagnosticHost);
-        var diagnosticCodes = diagnostics.map(function (x) { return x.code; });
+        const diagnosticText = formatDiagnostics(diagnostics, diagnosticHost);
+        const diagnosticCodes = diagnostics.map((x) => x.code);
         return new ts_error_1.TSError(diagnosticText, diagnosticCodes);
-    };
-    ConfigSet.prototype.resolvePath = function (inputPath, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.throwIfMissing, throwIfMissing = _c === void 0 ? true : _c, _d = _b.nodeResolve, nodeResolve = _d === void 0 ? false : _d;
-        var path = inputPath;
-        var nodeResolved = false;
+    }
+    resolvePath(inputPath, { throwIfMissing = true, nodeResolve = false } = {}) {
+        let path = inputPath;
+        let nodeResolved = false;
         if (path.startsWith('<rootDir>')) {
             path = (0, path_1.resolve)((0, path_1.join)(this.rootDir, path.substr(9)));
         }
@@ -594,8 +584,8 @@ var ConfigSet = /** @class */ (function () {
                     path = require.resolve(path);
                     nodeResolved = true;
                 }
-                catch (_e) {
-                    this.logger.debug({ path: path }, 'failed to resolve path', path);
+                catch {
+                    this.logger.debug({ path }, 'failed to resolve path', path);
                 }
             }
             if (!nodeResolved) {
@@ -607,16 +597,15 @@ var ConfigSet = /** @class */ (function () {
                 path = require.resolve(path);
                 nodeResolved = true;
             }
-            catch (_f) {
-                this.logger.debug({ path: path }, 'failed to resolve path', path);
+            catch {
+                this.logger.debug({ path }, 'failed to resolve path', path);
             }
         }
         if (throwIfMissing && !(0, fs_1.existsSync)(path)) {
-            throw new Error((0, messages_1.interpolate)("File not found: {{inputPath}} (resolved as: {{resolvedPath}})" /* Errors.FileNotFound */, { inputPath: inputPath, resolvedPath: path }));
+            throw new Error((0, messages_1.interpolate)("File not found: {{inputPath}} (resolved as: {{resolvedPath}})" /* Errors.FileNotFound */, { inputPath, resolvedPath: path }));
         }
         this.logger.debug({ fromPath: inputPath, toPath: path }, 'resolved path from', inputPath, 'to', path);
         return path;
-    };
-    return ConfigSet;
-}());
+    }
+}
 exports.ConfigSet = ConfigSet;