ts-jest 29.3.2 → 29.3.3

package/dist/transpilers/typescript/transpile-module.js

@@ -1,53 +1,36 @@
 "use strict";
-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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsTranspileModule = exports.isModernNodeModuleKind = void 0;
-var node_path_1 = __importDefault(require("node:path"));
-var typescript_1 = __importDefault(require("typescript"));
-var messages_1 = require("../../utils/messages");
-var barebonesLibContent = "/// <reference no-default-lib=\"true\"/>\ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number {}\ninterface Object {}\ninterface RegExp {}\ninterface String {}\ninterface Array<T> { length: number; [n: number]: T; }\ninterface SymbolConstructor {\n    (desc?: string | number): symbol;\n    for(name: string): symbol;\n    readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n    readonly [Symbol.toStringTag]: string;\n}";
-var barebonesLibName = 'lib.d.ts';
-var barebonesLibSourceFile;
-var carriageReturnLineFeed = '\r\n';
-var lineFeed = '\n';
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const messages_1 = require("../../utils/messages");
+const barebonesLibContent = `/// <reference no-default-lib="true"/>
+interface Boolean {}
+interface Function {}
+interface CallableFunction {}
+interface NewableFunction {}
+interface IArguments {}
+interface Number {}
+interface Object {}
+interface RegExp {}
+interface String {}
+interface Array<T> { length: number; [n: number]: T; }
+interface SymbolConstructor {
+    (desc?: string | number): symbol;
+    for(name: string): symbol;
+    readonly toStringTag: symbol;
+}
+declare var Symbol: SymbolConstructor;
+interface Symbol {
+    readonly [Symbol.toStringTag]: string;
+}`;
+const barebonesLibName = 'lib.d.ts';
+let barebonesLibSourceFile;
+const carriageReturnLineFeed = '\r\n';
+const lineFeed = '\n';
 function getNewLineCharacter(options) {
     switch (options.newLine) {
         case typescript_1.default.NewLineKind.CarriageReturnLineFeed:
@@ -57,11 +40,11 @@ function getNewLineCharacter(options) {
             return lineFeed;
     }
 }
-var isModernNodeModuleKind = function (module) {
+const isModernNodeModuleKind = (module) => {
     return module ? [typescript_1.default.ModuleKind.Node16, /* ModuleKind.Node18 */ 101, typescript_1.default.ModuleKind.NodeNext].includes(module) : false;
 };
 exports.isModernNodeModuleKind = isModernNodeModuleKind;
-var shouldCheckProjectPkgJsonContent = function (fileName, moduleKind) {
+const shouldCheckProjectPkgJsonContent = (fileName, moduleKind) => {
     return fileName.endsWith('package.json') && (0, exports.isModernNodeModuleKind)(moduleKind);
 };
 /**
@@ -70,41 +53,29 @@ var shouldCheckProjectPkgJsonContent = function (fileName, moduleKind) {
  * - Remove generation of declaration files
  * - Allow using custom AST transformers with the internal created {@link Program}
  */
-var transpileWorker = function (input, transpileOptions) {
-    var e_1, _a;
-    var _b, _c, _d, _e, _f;
-    barebonesLibSourceFile !== null && barebonesLibSourceFile !== void 0 ? barebonesLibSourceFile : (barebonesLibSourceFile = typescript_1.default.createSourceFile(barebonesLibName, barebonesLibContent, {
+const transpileWorker = (input, transpileOptions) => {
+    barebonesLibSourceFile ??= typescript_1.default.createSourceFile(barebonesLibName, barebonesLibContent, {
         languageVersion: typescript_1.default.ScriptTarget.Latest,
-    }));
-    var diagnostics = [];
-    var options = transpileOptions.compilerOptions
+    });
+    const diagnostics = [];
+    const options = transpileOptions.compilerOptions
         ? // @ts-expect-error internal TypeScript API
             typescript_1.default.fixupCompilerOptions(transpileOptions.compilerOptions, diagnostics)
         : {};
     // mix in default options
-    var defaultOptions = typescript_1.default.getDefaultCompilerOptions();
-    for (var key in defaultOptions) {
+    const defaultOptions = typescript_1.default.getDefaultCompilerOptions();
+    for (const key in defaultOptions) {
         if (Object.hasOwn(defaultOptions, key) && options[key] === undefined) {
             options[key] = defaultOptions[key];
         }
     }
-    try {
-        // @ts-expect-error internal TypeScript API
-        for (var _g = __values(typescript_1.default.transpileOptionValueCompilerOptions), _h = _g.next(); !_h.done; _h = _g.next()) {
-            var option = _h.value;
-            // Do not set redundant config options if `verbatimModuleSyntax` was supplied.
-            if (options.verbatimModuleSyntax && new Set(['isolatedModules']).has(option.name)) {
-                continue;
-            }
-            options[option.name] = option.transpileOptionValue;
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+    // @ts-expect-error internal TypeScript API
+    for (const option of typescript_1.default.transpileOptionValueCompilerOptions) {
+        // Do not set redundant config options if `verbatimModuleSyntax` was supplied.
+        if (options.verbatimModuleSyntax && new Set(['isolatedModules']).has(option.name)) {
+            continue;
         }
-        finally { if (e_1) throw e_1.error; }
+        options[option.name] = option.transpileOptionValue;
     }
     // transpileModule does not write anything to disk so there is no need to verify that there are no conflicts between input and output paths.
     options.suppressOutputPathCheck = true;
@@ -112,12 +83,12 @@ var transpileWorker = function (input, transpileOptions) {
     options.allowNonTsExtensions = true;
     options.declaration = false;
     options.declarationMap = false;
-    var newLine = getNewLineCharacter(options);
+    const newLine = getNewLineCharacter(options);
     // if jsx is specified then treat file as .tsx
-    var inputFileName = (_b = transpileOptions.fileName) !== null && _b !== void 0 ? _b : (((_c = transpileOptions.compilerOptions) === null || _c === void 0 ? void 0 : _c.jsx) ? 'module.tsx' : 'module.ts');
+    const inputFileName = transpileOptions.fileName ?? (transpileOptions.compilerOptions?.jsx ? 'module.tsx' : 'module.ts');
     // Create a compilerHost object to allow the compiler to read and write files
-    var compilerHost = {
-        getSourceFile: function (fileName) {
+    const compilerHost = {
+        getSourceFile: (fileName) => {
             // @ts-expect-error internal TypeScript API
             if (fileName === typescript_1.default.normalizePath(inputFileName)) {
                 return sourceFile;
@@ -125,7 +96,7 @@ var transpileWorker = function (input, transpileOptions) {
             // @ts-expect-error internal TypeScript API
             return fileName === typescript_1.default.normalizePath(barebonesLibName) ? barebonesLibSourceFile : undefined;
         },
-        writeFile: function (name, text) {
+        writeFile: (name, text) => {
             if (node_path_1.default.extname(name) === '.map') {
                 sourceMapText = text;
             }
@@ -133,33 +104,33 @@ var transpileWorker = function (input, transpileOptions) {
                 outputText = text;
             }
         },
-        getDefaultLibFileName: function () { return barebonesLibName; },
-        useCaseSensitiveFileNames: function () { return false; },
-        getCanonicalFileName: function (fileName) { return fileName; },
-        getCurrentDirectory: function () { return ''; },
-        getNewLine: function () { return newLine; },
-        fileExists: function (fileName) {
+        getDefaultLibFileName: () => barebonesLibName,
+        useCaseSensitiveFileNames: () => false,
+        getCanonicalFileName: (fileName) => fileName,
+        getCurrentDirectory: () => '',
+        getNewLine: () => newLine,
+        fileExists: (fileName) => {
             if (shouldCheckProjectPkgJsonContent(fileName, options.module)) {
                 return typescript_1.default.sys.fileExists(fileName);
             }
             return fileName === inputFileName;
         },
-        readFile: function (fileName) {
+        readFile: (fileName) => {
             if (shouldCheckProjectPkgJsonContent(fileName, options.module)) {
                 return typescript_1.default.sys.readFile(fileName);
             }
             return '';
         },
-        directoryExists: function () { return true; },
-        getDirectories: function () { return []; },
+        directoryExists: () => true,
+        getDirectories: () => [],
     };
-    var sourceFile = typescript_1.default.createSourceFile(inputFileName, input, {
-        languageVersion: (_d = options.target) !== null && _d !== void 0 ? _d : typescript_1.default.ScriptTarget.ESNext,
+    const sourceFile = typescript_1.default.createSourceFile(inputFileName, input, {
+        languageVersion: options.target ?? typescript_1.default.ScriptTarget.ESNext,
         impliedNodeFormat: typescript_1.default.getImpliedNodeFormatForFile(inputFileName, 
         /*packageJsonInfoCache*/ undefined, compilerHost, options),
         // @ts-expect-error internal TypeScript API
         setExternalModuleIndicator: typescript_1.default.getSetExternalModuleIndicator(options),
-        jsDocParsingMode: (_e = transpileOptions.jsDocParsingMode) !== null && _e !== void 0 ? _e : typescript_1.default.JSDocParsingMode.ParseAll,
+        jsDocParsingMode: transpileOptions.jsDocParsingMode ?? typescript_1.default.JSDocParsingMode.ParseAll,
     });
     if (transpileOptions.moduleName) {
         sourceFile.moduleName = transpileOptions.moduleName;
@@ -169,21 +140,21 @@ var transpileWorker = function (input, transpileOptions) {
         sourceFile.renamedDependencies = new Map(Object.entries(transpileOptions.renamedDependencies));
     }
     // Output
-    var outputText;
-    var sourceMapText;
-    var inputs = [inputFileName];
-    var program = typescript_1.default.createProgram(inputs, options, compilerHost);
+    let outputText;
+    let sourceMapText;
+    const inputs = [inputFileName];
+    const program = typescript_1.default.createProgram(inputs, options, compilerHost);
     if (transpileOptions.reportDiagnostics) {
-        diagnostics.push.apply(diagnostics, __spreadArray([], __read(program.getSyntacticDiagnostics(sourceFile)), false));
+        diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
     }
-    diagnostics.push.apply(diagnostics, __spreadArray([], __read(program.getOptionsDiagnostics()), false));
+    diagnostics.push(...program.getOptionsDiagnostics());
     // Emit
-    var result = program.emit(
+    const result = program.emit(
     /*targetSourceFile*/ undefined, 
     /*writeFile*/ undefined, 
     /*cancellationToken*/ undefined, 
-    /*emitOnlyDtsFiles*/ undefined, (_f = transpileOptions.transformers) === null || _f === void 0 ? void 0 : _f.call(transpileOptions, program));
-    diagnostics.push.apply(diagnostics, __spreadArray([], __read(result.diagnostics), false));
+    /*emitOnlyDtsFiles*/ undefined, transpileOptions.transformers?.(program));
+    diagnostics.push(...result.diagnostics);
     if (outputText === undefined) {
         diagnostics.push({
             category: typescript_1.default.DiagnosticCategory.Error,
@@ -194,6 +165,6 @@ var transpileWorker = function (input, transpileOptions) {
             length: 0,
         });
     }
-    return { outputText: outputText !== null && outputText !== void 0 ? outputText : '', diagnostics: diagnostics, sourceMapText: sourceMapText };
+    return { outputText: outputText ?? '', diagnostics, sourceMapText };
 };
 exports.tsTranspileModule = transpileWorker;

package/dist/types.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("./constants");
+const constants_1 = require("./constants");

package/dist/utils/backports.js

@@ -1,38 +1,26 @@
 "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 _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);
+const bs_logger_1 = require("bs-logger");
+const messages_1 = require("./messages");
+const context = { [bs_logger_1.LogContexts.namespace]: 'backports' };
 /**
  * @internal
  */
-var backportJestConfig = function (logger, config) {
-    logger.debug(__assign(__assign({}, context), { config: config }), 'backporting config');
+const backportJestConfig = (logger, config) => {
+    logger.debug({ ...context, config }, 'backporting config');
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    var _a = (config || {}).globals, globals = _a === void 0 ? {} : _a;
-    var _b = globals["ts-jest"], tsJest = _b === void 0 ? {} : _b;
+    const { globals = {} } = (config || {});
+    const { 'ts-jest': tsJest = {} } = globals;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    var mergeTsJest = {};
-    var hadWarnings = false;
-    var warnConfig = function (oldPath, newPath, note) {
+    const mergeTsJest = {};
+    let hadWarnings = false;
+    const warnConfig = (oldPath, newPath, note) => {
         hadWarnings = true;
         logger.warn(context, (0, messages_1.interpolate)(note ? "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.\n    \u21B3 {{note}}" /* Deprecations.ConfigOptionWithNote */ : "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead." /* Deprecations.ConfigOption */, {
-            oldPath: oldPath,
-            newPath: newPath,
-            note: note,
+            oldPath,
+            newPath,
+            note,
         }));
     };
     if ('__TS_CONFIG__' in globals) {
@@ -98,15 +86,25 @@ var backportJestConfig = function (logger, config) {
     if (hadWarnings) {
         logger.warn(context, "Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>." /* Helps.MigrateConfigUsingCLI */);
     }
-    return __assign(__assign({}, config), { globals: __assign(__assign({}, globals), { 'ts-jest': __assign(__assign({}, mergeTsJest), tsJest) }) });
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ...config,
+        globals: {
+            ...globals,
+            'ts-jest': {
+                ...mergeTsJest,
+                ...tsJest,
+            },
+        },
+    };
 };
 exports.backportJestConfig = backportJestConfig;
 /**
  * @internal
  */
-var backportTsJestDebugEnvVar = function (logger) {
+const backportTsJestDebugEnvVar = (logger) => {
     if ('TS_JEST_DEBUG' in process.env) {
-        var shouldLog = !/^\s*(?:0|f(?:alse)?|no?|disabled?|off|)\s*$/i.test(process.env.TS_JEST_DEBUG || '');
+        const 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';

package/dist/utils/get-package-version.js

@@ -6,9 +6,9 @@ exports.getPackageVersion = getPackageVersion;
  */
 function getPackageVersion(moduleName) {
     try {
-        return require("".concat(moduleName, "/package.json")).version;
+        return require(`${moduleName}/package.json`).version;
     }
-    catch (_a) {
+    catch {
         return undefined;
     }
 }

package/dist/utils/importer.js

@@ -1,98 +1,52 @@
 "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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.importer = exports.Importer = void 0;
 exports.__requireModule = __requireModule;
-var logger_1 = require("./logger");
-var memoize_1 = require("./memoize");
-var messages_1 = require("./messages");
-var logger = logger_1.rootLogger.child({ namespace: 'Importer' });
+const logger_1 = require("./logger");
+const memoize_1 = require("./memoize");
+const messages_1 = require("./messages");
+const logger = logger_1.rootLogger.child({ namespace: 'Importer' });
 /**
  * @internal
  */
-var Importer = /** @class */ (function () {
-    function Importer() {
+class Importer {
+    static get instance() {
+        logger.debug('creating Importer singleton');
+        return new Importer();
     }
-    Object.defineProperty(Importer, "instance", {
-        get: function () {
-            logger.debug('creating Importer singleton');
-            return new Importer();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Importer.prototype.babelJest = function (why) {
+    babelJest(why) {
         return this._import(why, 'babel-jest');
-    };
-    Importer.prototype.babelCore = function (why) {
+    }
+    babelCore(why) {
         return this._import(why, '@babel/core');
-    };
-    Importer.prototype.typescript = function (why, which) {
+    }
+    typescript(why, which) {
         return this._import(why, which);
-    };
-    Importer.prototype.esBuild = function (why) {
+    }
+    esBuild(why) {
         return this._import(why, 'esbuild');
-    };
-    Importer.prototype.tryThese = function (moduleName) {
-        var fallbacks = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            fallbacks[_i - 1] = arguments[_i];
-        }
-        var name;
-        var loaded;
-        var tries = __spreadArray([moduleName], __read(fallbacks), false);
+    }
+    tryThese(moduleName, ...fallbacks) {
+        let name;
+        let loaded;
+        const tries = [moduleName, ...fallbacks];
         while ((name = tries.shift()) !== undefined) {
-            var req = requireWrapper(name);
+            const req = requireWrapper(name);
             // remove exports from what we're going to log
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            var contextReq = __assign({}, req);
+            const contextReq = { ...req };
             delete contextReq.exports;
             if (req.exists) {
                 // module exists
                 loaded = req;
                 if (req.error) {
-                    logger.error({ requireResult: contextReq }, "failed loading module '".concat(name, "'"), req.error.message);
+                    logger.error({ requireResult: contextReq }, `failed loading module '${name}'`, req.error.message);
                 }
                 else {
                     logger.debug({ requireResult: contextReq }, 'loaded module', name);
@@ -101,17 +55,16 @@ var Importer = /** @class */ (function () {
             }
             else {
                 // module does not exists in the path
-                logger.debug({ requireResult: contextReq }, "module '".concat(name, "' not found"));
+                logger.debug({ requireResult: contextReq }, `module '${name}' not found`);
             }
         }
         // return the loaded one, could be one that has been loaded, or one which has failed during load
         // but not one which does not exists
         return loaded;
-    };
-    Importer.prototype.tryTheseOr = function (moduleNames, missingResult, allowLoadError) {
-        if (allowLoadError === void 0) { allowLoadError = false; }
-        var args = Array.isArray(moduleNames) ? moduleNames : [moduleNames];
-        var result = this.tryThese.apply(this, __spreadArray([], __read(args), false));
+    }
+    tryTheseOr(moduleNames, missingResult, allowLoadError = false) {
+        const args = Array.isArray(moduleNames) ? moduleNames : [moduleNames];
+        const result = this.tryThese(...args);
         if (!result)
             return missingResult;
         if (!result.error)
@@ -119,67 +72,59 @@ var Importer = /** @class */ (function () {
         if (allowLoadError)
             return missingResult;
         throw result.error;
-    };
-    Importer.prototype._import = function (why, moduleName, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.alternatives, alternatives = _c === void 0 ? [] : _c, _d = _b.installTip, installTip = _d === void 0 ? moduleName : _d;
+    }
+    _import(why, moduleName, { alternatives = [], installTip = moduleName } = {}) {
         // try to load any of the alternative after trying main one
-        var res = this.tryThese.apply(this, __spreadArray([moduleName], __read(alternatives), false));
+        const res = this.tryThese(moduleName, ...alternatives);
         // if we could load one, return it
-        if (res === null || res === void 0 ? void 0 : res.exists) {
+        if (res?.exists) {
             if (!res.error)
                 return res.exports;
             // it could not load because of a failure while importing, but it exists
             throw new Error((0, messages_1.interpolate)("Loading module {{module}} failed with error: {{error}}" /* Errors.LoadingModuleFailed */, { module: res.given, error: res.error.message }));
         }
         // if it couldn't load, build a nice error message so the user can fix it by himself
-        var msg = alternatives.length ? "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}" /* Errors.UnableToLoadAnyModule */ : "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}" /* Errors.UnableToLoadOneModule */;
-        var loadModule = __spreadArray([moduleName], __read(alternatives), false).map(function (m) { return "\"".concat(m, "\""); }).join(', ');
+        const msg = alternatives.length ? "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}" /* Errors.UnableToLoadAnyModule */ : "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}" /* Errors.UnableToLoadOneModule */;
+        const loadModule = [moduleName, ...alternatives].map((m) => `"${m}"`).join(', ');
         if (typeof installTip === 'string') {
-            installTip = [{ module: installTip, label: "install \"".concat(installTip, "\"") }];
+            installTip = [{ module: installTip, label: `install "${installTip}"` }];
         }
-        var fix = installTip
-            .map(function (tip) { return "    ".concat(installTip.length === 1 ? '↳' : '•', " ").concat((0, messages_1.interpolate)("{{label}}: `npm i -D {{module}}` (or `yarn add --dev {{module}}`)" /* Helps.FixMissingModule */, tip)); })
+        const fix = installTip
+            .map((tip) => `    ${installTip.length === 1 ? '↳' : '•'} ${(0, messages_1.interpolate)("{{label}}: `npm i -D {{module}}` (or `yarn add --dev {{module}}`)" /* Helps.FixMissingModule */, tip)}`)
             .join('\n');
         throw new Error((0, messages_1.interpolate)(msg, {
             module: loadModule,
             reason: why,
-            fix: fix,
+            fix,
         }));
-    };
-    __decorate([
-        (0, memoize_1.Memoize)(function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return args.join(':');
-        })
-    ], Importer.prototype, "tryThese", null);
-    __decorate([
-        (0, memoize_1.Memoize)()
-    ], Importer, "instance", null);
-    return Importer;
-}());
+    }
+}
 exports.Importer = Importer;
+__decorate([
+    (0, memoize_1.Memoize)((...args) => args.join(':'))
+], Importer.prototype, "tryThese", null);
+__decorate([
+    (0, memoize_1.Memoize)()
+], Importer, "instance", null);
 /**
  * @internal
  */
 exports.importer = Importer.instance;
 function requireWrapper(moduleName) {
-    var path;
-    var exists = false;
+    let path;
+    let exists = false;
     try {
         path = resolveModule(moduleName);
         exists = true;
     }
     catch (error) {
-        return { error: error, exists: exists, given: moduleName };
+        return { error: error, exists, given: moduleName };
     }
-    var result = { exists: exists, path: path, given: moduleName };
+    const result = { exists, path, given: moduleName };
     try {
         result.exports = requireModule(path);
     }
-    catch (_a) {
+    catch {
         try {
             result.exports = requireModule(moduleName);
         }
@@ -189,8 +134,8 @@ function requireWrapper(moduleName) {
     }
     return result;
 }
-var requireModule = function (mod) { return require(mod); };
-var resolveModule = function (mod) { return require.resolve(mod, { paths: [process.cwd(), __dirname] }); };
+let requireModule = (mod) => require(mod);
+let resolveModule = (mod) => require.resolve(mod, { paths: [process.cwd(), __dirname] });
 /**
  * @internal
  */

package/dist/utils/json.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringify = stringify;
 exports.parse = parse;
-var fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
-var UNDEFINED = 'undefined';
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+const UNDEFINED = 'undefined';
 function stringify(input) {
     return input === undefined ? UNDEFINED : (0, fast_json_stable_stringify_1.default)(input);
 }