@depup/ts-jest 29.4.6-depup.0

package/dist/utils/importer.js

@@ -0,0 +1,146 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importer = exports.Importer = void 0;
+exports.__requireModule = __requireModule;
+const logger_1 = require("./logger");
+const memoize_1 = require("./memoize");
+const messages_1 = require("./messages");
+const logger = logger_1.rootLogger.child({ namespace: 'Importer' });
+/**
+ * @internal
+ */
+class Importer {
+    static get instance() {
+        logger.debug('creating Importer singleton');
+        return new Importer();
+    }
+    babelJest(why) {
+        return this._import(why, 'babel-jest');
+    }
+    babelCore(why) {
+        return this._import(why, '@babel/core');
+    }
+    typescript(why, which) {
+        return this._import(why, which);
+    }
+    esBuild(why) {
+        return this._import(why, 'esbuild');
+    }
+    tryThese(moduleName, ...fallbacks) {
+        let name;
+        let loaded;
+        const tries = [moduleName, ...fallbacks];
+        while ((name = tries.shift()) !== undefined) {
+            const req = requireWrapper(name);
+            // remove exports from what we're going to log
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const contextReq = { ...req };
+            delete contextReq.exports;
+            if (req.exists) {
+                // module exists
+                loaded = req;
+                if (req.error) {
+                    logger.error({ requireResult: contextReq }, `failed loading module '${name}'`, req.error.message);
+                }
+                else {
+                    logger.debug({ requireResult: contextReq }, 'loaded module', name);
+                }
+                break;
+            }
+            else {
+                // module does not exists in the path
+                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;
+    }
+    tryTheseOr(moduleNames, missingResult, allowLoadError = false) {
+        const args = Array.isArray(moduleNames) ? moduleNames : [moduleNames];
+        const result = this.tryThese(...args);
+        if (!result)
+            return missingResult;
+        if (!result.error)
+            return result.exports;
+        if (allowLoadError)
+            return missingResult;
+        throw result.error;
+    }
+    _import(why, moduleName, { alternatives = [], installTip = moduleName } = {}) {
+        // try to load any of the alternative after trying main one
+        const res = this.tryThese(moduleName, ...alternatives);
+        // if we could load one, return it
+        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
+        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 "${installTip}"` }];
+        }
+        const fix = installTip
+            .map((tip) => `    ${installTip.length === 1 ? '↳' : '•'} ${(0, messages_1.interpolate)(messages_1.Helps.FixMissingModule, tip)}`)
+            .join('\n');
+        throw new Error((0, messages_1.interpolate)(msg, {
+            module: loadModule,
+            reason: why,
+            fix,
+        }));
+    }
+}
+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) {
+    let path;
+    let exists = false;
+    try {
+        path = resolveModule(moduleName);
+        exists = true;
+    }
+    catch (error) {
+        return { error: error, exists, given: moduleName };
+    }
+    const result = { exists, path, given: moduleName };
+    try {
+        result.exports = requireModule(path);
+    }
+    catch {
+        try {
+            result.exports = requireModule(moduleName);
+        }
+        catch (error) {
+            result.error = error;
+        }
+    }
+    return result;
+}
+let requireModule = (mod) => require(mod);
+let resolveModule = (mod) => require.resolve(mod, { paths: [process.cwd(), __dirname] });
+/**
+ * @internal
+ */
+// so that we can test easier
+function __requireModule(localRequire, localResolve) {
+    requireModule = localRequire;
+    resolveModule = localResolve;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './json';
+export * from './jsonable-value';
+export * from './logger';
+export * from './diagnostics';

package/dist/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./json"), exports);
+__exportStar(require("./jsonable-value"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./diagnostics"), exports);

package/dist/utils/json.d.ts

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

package/dist/utils/json.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = stringify;
+exports.parse = parse;
+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);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parse(input) {
+    return input === UNDEFINED ? undefined : JSON.parse(input);
+}

package/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;
+}

package/dist/utils/jsonable-value.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonableValue = void 0;
+const json_1 = require("./json");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class JsonableValue {
+    _serialized;
+    _value;
+    constructor(value) {
+        this.value = value;
+    }
+    set value(value) {
+        this._value = value;
+        this._serialized = (0, json_1.stringify)(value);
+    }
+    get value() {
+        return this._value;
+    }
+    get serialized() {
+        return this._serialized;
+    }
+    valueOf() {
+        return this._value;
+    }
+    toString() {
+        return this._serialized;
+    }
+}
+exports.JsonableValue = JsonableValue;

package/dist/utils/logger.d.ts

@@ -0,0 +1 @@
+export declare let rootLogger: import("bs-logger").Logger;

package/dist/utils/logger.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootLogger = void 0;
+const bs_logger_1 = require("bs-logger");
+const backports_1 = require("./backports");
+const original = process.env.TS_JEST_LOG;
+const buildOptions = () => ({
+    context: {
+        [bs_logger_1.LogContexts.package]: 'ts-jest',
+        [bs_logger_1.LogContexts.logLevel]: bs_logger_1.LogLevels.trace,
+        version: require('../../package.json').version,
+    },
+    targets: process.env.TS_JEST_LOG ?? undefined,
+});
+exports.rootLogger = (0, bs_logger_1.createLogger)(buildOptions());
+(0, backports_1.backportTsJestDebugEnvVar)(exports.rootLogger);
+// re-create the logger if the env var has been backported
+if (original !== process.env.TS_JEST_LOG) {
+    exports.rootLogger = (0, bs_logger_1.createLogger)(buildOptions());
+}

package/dist/utils/memoize.d.ts

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

package/dist/utils/memoize.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memoize = Memoize;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const cacheProp = Symbol.for('[memoize]');
+/**
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function Memoize(keyBuilder) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (_, propertyKey, descriptor) => {
+        if (descriptor.value != null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            descriptor.value = memoize(propertyKey, descriptor.value, keyBuilder || ((v) => v));
+        }
+        else if (descriptor.get != null) {
+            descriptor.get = memoize(propertyKey, descriptor.get, keyBuilder || (() => propertyKey));
+        }
+    };
+}
+// See https://github.com/microsoft/TypeScript/issues/1863#issuecomment-579541944
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function ensureCache(target, reset = false) {
+    if (reset || !target[cacheProp]) {
+        Object.defineProperty(target, cacheProp, {
+            value: Object.create(null),
+            configurable: true,
+        });
+    }
+    return target[cacheProp];
+}
+// See https://github.com/microsoft/TypeScript/issues/1863#issuecomment-579541944
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function ensureChildCache(target, key, reset = false) {
+    const dict = ensureCache(target);
+    if (reset || !dict[key]) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        dict[key] = new Map();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return dict[key];
+}
+function memoize(namespace, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+func, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+keyBuilder) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (...args) {
+        const cache = ensureChildCache(this, namespace);
+        const key = keyBuilder.apply(this, args);
+        if (cache.has(key))
+            return cache.get(key);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const res = func.apply(this, args);
+        cache.set(key, res);
+        return res;
+    };
+}

package/dist/utils/messages.d.ts

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

package/dist/utils/messages.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Helps = void 0;
+exports.interpolate = interpolate;
+const diagnostics_1 = require("./diagnostics");
+/**
+ * @internal
+ */
+exports.Helps = {
+    FixMissingModule: '{{label}}: `npm i -D {{module}}` (or `yarn add --dev {{module}}`)',
+    MigrateConfigUsingCLI: 'Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>.',
+    UsingModernNodeResolution: `Using hybrid module kind (Node16/18/Next) is only supported in "isolatedModules: true". Please set "isolatedModules: true" in your tsconfig.json. To disable this message, you can set "diagnostics.ignoreCodes" to include ${diagnostics_1.TsJestDiagnosticCodes.ModernNodeModule} in your ts-jest config. See more at https://kulshekhar.github.io/ts-jest/docs/getting-started/options/diagnostics`,
+};
+/**
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function interpolate(msg, vars = {}) {
+    // eslint-disable-next-line no-useless-escape
+    return msg.replace(/\{\{([^\}]+)\}\}/g, (_, key) => (key in vars ? vars[key] : _));
+}

package/dist/utils/normalize-slashes.d.ts

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

package/dist/utils/normalize-slashes.js

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

package/dist/utils/sha1.d.ts

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

package/dist/utils/sha1.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cache = void 0;
+exports.sha1 = sha1;
+const crypto_1 = require("crypto");
+/**
+ * @internal
+ */
+// stores hashes made out of only one argument being a string
+exports.cache = Object.create(null);
+/**
+ * @internal
+ */
+function sha1(...data) {
+    const canCache = data.length === 1 && typeof data[0] === 'string';
+    // caching
+    let cacheKey;
+    if (canCache) {
+        cacheKey = data[0];
+        if (cacheKey in exports.cache) {
+            return exports.cache[cacheKey];
+        }
+    }
+    // we use SHA1 because it's the fastest provided by node
+    // and we are not concerned about security here
+    const hash = (0, crypto_1.createHash)('sha1');
+    data.forEach((item) => {
+        if (typeof item === 'string')
+            hash.update(item, 'utf8');
+        else
+            hash.update(item);
+    });
+    const res = hash.digest('hex').toString();
+    if (canCache) {
+        exports.cache[cacheKey] = res;
+    }
+    return res;
+}

package/dist/utils/ts-error.d.ts

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

package/dist/utils/ts-error.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSError = exports.INSPECT_CUSTOM = void 0;
+const util_1 = require("util");
+const make_error_1 = require("make-error");
+const logger_1 = require("./logger");
+const messages_1 = require("./messages");
+const logger = logger_1.rootLogger.child({ namespace: 'TSError' });
+/**
+ * @internal
+ */
+exports.INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
+/**
+ * TypeScript diagnostics error.
+ *
+ * @internal
+ */
+class TSError extends make_error_1.BaseError {
+    diagnosticText;
+    diagnosticCodes;
+    name = 'TSError';
+    constructor(diagnosticText, diagnosticCodes) {
+        super((0, messages_1.interpolate)("{{diagnostics}}" /* Errors.UnableToCompileTypeScript */, {
+            diagnostics: diagnosticText.trim(),
+        }));
+        this.diagnosticText = diagnosticText;
+        this.diagnosticCodes = diagnosticCodes;
+        logger.debug({ diagnosticCodes, diagnosticText }, 'created new TSError');
+        // ensure we blacklist any of our code
+        Object.defineProperty(this, 'stack', { value: '' });
+    }
+    /* istanbul ignore next */
+    [exports.INSPECT_CUSTOM]() {
+        return this.diagnosticText;
+    }
+}
+exports.TSError = TSError;

package/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('./presets').defaults

package/legacy.js

@@ -0,0 +1 @@
+module.exports = require('./dist/legacy')

package/package.json

@@ -0,0 +1,167 @@
+{
+  "name": "@depup/ts-jest",
+  "version": "29.4.6-depup.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "commonjs",
+  "bin": {
+    "ts-jest": "cli.js"
+  },
+  "description": "[DepUp] A Jest transformer with source map support that lets you use Jest to test projects written in TypeScript",
+  "scripts": {
+    "prebuild": "rimraf --glob dist coverage *.tgz",
+    "build": "tsc -p tsconfig.build.json",
+    "postbuild": "node scripts/post-build.js",
+    "test": "jest -c=jest.config.ts",
+    "test-e2e-cjs": "jest -c=jest-e2e-cjs.config.ts --no-cache",
+    "test-e2e-esm": "node --experimental-vm-modules --no-warnings node_modules/jest/bin/jest.js -c=jest-e2e-esm.config.ts --no-cache",
+    "test-examples": "node scripts/test-examples.js",
+    "lint": "eslint .",
+    "lint-fix": "eslint --fix .",
+    "lint-prettier": "prettier \"**/*.{yml,yaml,md}\" --write",
+    "lint-prettier-ci": "prettier '**/*.{yml,yaml,md}' --check",
+    "doc": "cd website && npm run start",
+    "doc:build": "cd website && npm run build",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 1",
+    "preversion": "npm run test",
+    "version": "npm run changelog && git add CHANGELOG.md"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kulshekhar/ts-jest.git"
+  },
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "ts-jest",
+    "jest",
+    "typescript",
+    "sourcemap",
+    "react",
+    "testing"
+  ],
+  "author": "Kulshekhar Kabra <kulshekhar@users.noreply.github.com> (https://github.com/kulshekhar)",
+  "contributors": [
+    "Huafu Gandon <huafu.gandon@gmail.com> (https://github.com/huafu)",
+    "Anh Pham <anhpnnd@gmail.com> (https://github.com/ahnpnl)",
+    "Gustav Wengel <gustavwengel@gmail.com> (https://github.com/GeeWee)"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kulshekhar/ts-jest/issues"
+  },
+  "homepage": "https://kulshekhar.github.io/ts-jest",
+  "dependencies": {
+    "bs-logger": "^0.2.6",
+    "fast-json-stable-stringify": "^2.1.0",
+    "handlebars": "^4.7.8",
+    "json5": "^2.2.3",
+    "lodash.memoize": "^4.1.2",
+    "make-error": "^1.3.6",
+    "semver": "^7.7.4",
+    "type-fest": "^5.4.4",
+    "yargs-parser": "^22.0.0"
+  },
+  "peerDependencies": {
+    "@babel/core": ">=7.0.0-beta.0 <8",
+    "@jest/transform": "^29.0.0 || ^30.0.0",
+    "@jest/types": "^29.0.0 || ^30.0.0",
+    "babel-jest": "^29.0.0 || ^30.0.0",
+    "jest": "^29.0.0 || ^30.0.0",
+    "jest-util": "^29.0.0 || ^30.0.0",
+    "typescript": ">=4.3 <6"
+  },
+  "peerDependenciesMeta": {
+    "@babel/core": {
+      "optional": true
+    },
+    "@jest/transform": {
+      "optional": true
+    },
+    "@jest/types": {
+      "optional": true
+    },
+    "babel-jest": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    },
+    "jest-util": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-angular": "^19.8.1",
+    "@eslint/compat": "^1.4.1",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.39.1",
+    "@jest/globals": "^30.2.0",
+    "@jest/transform": "^30.2.0",
+    "@jest/types": "^30.2.0",
+    "@types/babel__core": "^7.20.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.5.14",
+    "@types/js-yaml": "^4.0.9",
+    "@types/lodash.camelcase": "^4.3.9",
+    "@types/lodash.memoize": "^4.1.9",
+    "@types/lodash.set": "^4.3.9",
+    "@types/micromatch": "^4.0.10",
+    "@types/node": "20.19.25",
+    "@types/semver": "^7.7.1",
+    "@types/yargs": "^17.0.35",
+    "@types/yargs-parser": "21.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.48.0",
+    "@typescript-eslint/parser": "^8.48.0",
+    "babel-jest": "^30.2.0",
+    "conventional-changelog-angular": "^8.1.0",
+    "conventional-changelog": "^7.1.1",
+    "esbuild": "~0.27.0",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jest": "^28.14.0",
+    "eslint-plugin-jsdoc": "^50.8.0",
+    "eslint-plugin-prettier": "^4.2.5",
+    "execa": "5.1.1",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.2",
+    "globals": "^16.5.0",
+    "husky": "^9.1.7",
+    "jest": "^30.2.0",
+    "js-yaml": "^4.1.1",
+    "lint-staged": "^15.5.2",
+    "memfs": "^4.51.0",
+    "prettier": "^2.8.8",
+    "rimraf": "^5.0.10",
+    "ts-node": "^10.9.2",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.48.0"
+  },
+  "engines": {
+    "node": "^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0"
+  },
+  "depup": {
+    "changes": {
+      "semver": {
+        "from": "^7.7.3",
+        "to": "^7.7.4"
+      },
+      "type-fest": {
+        "from": "^4.41.0",
+        "to": "^5.4.4"
+      },
+      "yargs-parser": {
+        "from": "^21.1.1",
+        "to": "^22.0.0"
+      }
+    },
+    "depsUpdated": 3,
+    "originalPackage": "ts-jest",
+    "originalVersion": "29.4.6",
+    "processedAt": "2026-03-17T16:39:42.819Z",
+    "smokeTest": "passed"
+  }
+}

package/preprocessor.js

@@ -0,0 +1,7 @@
+console.warn(
+  'ts-jest[main] (WARN) Replace any occurrences of "ts-jest/dist/preprocessor.js" or ' +
+    ' "<rootDir>/node_modules/ts-jest/preprocessor.js"' +
+    ' in the \'transform\' section of your Jest config with just "ts-jest".'
+)
+
+module.exports = require('./dist')

package/presets/default/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').defaults

package/presets/default-esm/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').defaultsESM

package/presets/default-esm-legacy/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').defaultsESMLegacy

package/presets/default-legacy/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').defaultsLegacy

package/presets/index.d.ts

@@ -0,0 +1,3 @@
+import allPresets from '../dist/presets/all-presets'
+
+export = allPresets

package/presets/index.js

@@ -0,0 +1,3 @@
+const allPresets = require('../dist/presets/all-presets')
+
+module.exports = allPresets.default

package/presets/js-with-babel/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').jsWithBabel

package/presets/js-with-babel-esm/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').jsWithBabelESM

package/presets/js-with-babel-esm-legacy/jest-preset.js

@@ -0,0 +1 @@
+module.exports = require('..').jsWithBabelESMLegacy