Add node modules and compiled JavaScript from main (#54)

Co-authored-by: Oliver King <oking3@uncc.edu>

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

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

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

@@ -0,0 +1,111 @@
+"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);
+var backportJestConfig = function (logger, config) {
+    logger.debug(__assign(__assign({}, context), { config: config }), 'backporting config');
+    var _a = (config || {}).globals, globals = _a === void 0 ? {} : _a;
+    var _b = globals["ts-jest"], tsJest = _b === void 0 ? {} : _b;
+    var mergeTsJest = {};
+    var hadWarnings = false;
+    var warnConfig = function (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}}" : "\"[jest-config].{{oldPath}}\" is deprecated, use \"[jest-config].{{newPath}}\" instead.", {
+            oldPath: oldPath,
+            newPath: newPath,
+            note: note,
+        }));
+    };
+    if ('__TS_CONFIG__' in globals) {
+        warnConfig('globals.__TS_CONFIG__', 'globals.ts-jest.tsconfig');
+        if (typeof globals.__TS_CONFIG__ === 'object') {
+            mergeTsJest.tsconfig = globals.__TS_CONFIG__;
+        }
+        delete globals.__TS_CONFIG__;
+    }
+    if ('__TRANSFORM_HTML__' in globals) {
+        warnConfig('globals.__TRANSFORM_HTML__', 'globals.ts-jest.stringifyContentPathRegex');
+        if (globals.__TRANSFORM_HTML__) {
+            mergeTsJest.stringifyContentPathRegex = '\\.html?$';
+        }
+        delete globals.__TRANSFORM_HTML__;
+    }
+    if ('typeCheck' in tsJest) {
+        warnConfig('globals.ts-jest.typeCheck', 'globals.ts-jest.isolatedModules');
+        mergeTsJest.isolatedModules = !tsJest.typeCheck;
+        delete tsJest.typeCheck;
+    }
+    if ('tsConfigFile' in tsJest) {
+        warnConfig('globals.ts-jest.tsConfigFile', 'globals.ts-jest.tsconfig');
+        if (tsJest.tsConfigFile) {
+            mergeTsJest.tsconfig = tsJest.tsConfigFile;
+        }
+        delete tsJest.tsConfigFile;
+    }
+    if ('tsConfig' in tsJest) {
+        warnConfig('globals.ts-jest.tsConfig', 'globals.ts-jest.tsconfig');
+        if (tsJest.tsConfig) {
+            mergeTsJest.tsconfig = tsJest.tsConfig;
+        }
+        delete tsJest.tsConfig;
+    }
+    if ('enableTsDiagnostics' in tsJest) {
+        warnConfig('globals.ts-jest.enableTsDiagnostics', 'globals.ts-jest.diagnostics');
+        if (tsJest.enableTsDiagnostics) {
+            mergeTsJest.diagnostics = { warnOnly: true };
+            if (typeof tsJest.enableTsDiagnostics === 'string')
+                mergeTsJest.diagnostics.exclude = [tsJest.enableTsDiagnostics];
+        }
+        else {
+            mergeTsJest.diagnostics = false;
+        }
+        delete tsJest.enableTsDiagnostics;
+    }
+    if ('useBabelrc' in tsJest) {
+        warnConfig('globals.ts-jest.useBabelrc', 'globals.ts-jest.babelConfig', "See `babel-jest` related issue: https://github.com/facebook/jest/issues/3845");
+        if (tsJest.useBabelrc != null) {
+            mergeTsJest.babelConfig = tsJest.useBabelrc ? true : {};
+        }
+        delete tsJest.useBabelrc;
+    }
+    if ('skipBabel' in tsJest) {
+        warnConfig('globals.ts-jest.skipBabel', 'globals.ts-jest.babelConfig');
+        if (tsJest.skipBabel === false && !mergeTsJest.babelConfig) {
+            mergeTsJest.babelConfig = true;
+        }
+        delete tsJest.skipBabel;
+    }
+    if (hadWarnings) {
+        logger.warn(context, "Your Jest configuration is outdated. Use the CLI to help migrating it: ts-jest config:migrate <config-file>.");
+    }
+    return __assign(__assign({}, config), { globals: __assign(__assign({}, globals), { 'ts-jest': __assign(__assign({}, mergeTsJest), tsJest) }) });
+};
+exports.backportJestConfig = backportJestConfig;
+var backportTsJestDebugEnvVar = function (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 || '');
+        delete process.env.TS_JEST_DEBUG;
+        if (shouldLog) {
+            process.env.TS_JEST_LOG = 'ts-jest.log,stderr:warn';
+        }
+        logger.warn(context, (0, messages_1.interpolate)("Using env. var \"{{old}}\" is deprecated, use \"{{new}}\" instead.", {
+            old: 'TS_JEST_DEBUG',
+            new: 'TS_JEST_LOG',
+        }));
+    }
+};
+exports.backportTsJestDebugEnvVar = backportTsJestDebugEnvVar;

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

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

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

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

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

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

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

@@ -0,0 +1,204 @@
+"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.__requireModule = exports.importer = exports.Importer = void 0;
+var logger_1 = require("./logger");
+var memoize_1 = require("./memoize");
+var messages_1 = require("./messages");
+var version_checkers_1 = require("./version-checkers");
+var logger = logger_1.rootLogger.child({ namespace: 'Importer' });
+var passThru = function (action) { return function (input) {
+    action();
+    return input;
+}; };
+var Importer = (function () {
+    function Importer(_patches) {
+        if (_patches === void 0) { _patches = {}; }
+        this._patches = _patches;
+    }
+    Object.defineProperty(Importer, "instance", {
+        get: function () {
+            logger.debug('creating Importer singleton');
+            return new Importer({
+                '@babel/core': [passThru(version_checkers_1.VersionCheckers.babelCore.warn)],
+                'babel-jest': [passThru(version_checkers_1.VersionCheckers.babelJest.warn)],
+                typescript: [passThru(version_checkers_1.VersionCheckers.typescript.warn)],
+                jest: [passThru(version_checkers_1.VersionCheckers.jest.warn)],
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Importer.prototype.babelJest = function (why) {
+        return this._import(why, 'babel-jest');
+    };
+    Importer.prototype.babelCore = function (why) {
+        return this._import(why, '@babel/core');
+    };
+    Importer.prototype.typescript = function (why, which) {
+        return this._import(why, which);
+    };
+    Importer.prototype.esBuild = function (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);
+        while ((name = tries.shift()) !== undefined) {
+            var req = requireWrapper(name);
+            var contextReq = __assign({}, req);
+            delete contextReq.exports;
+            if (req.exists) {
+                loaded = req;
+                if (loaded.error) {
+                    logger.error({ requireResult: contextReq }, "failed loading module '".concat(name, "'"), loaded.error.message);
+                }
+                else {
+                    logger.debug({ requireResult: contextReq }, 'loaded module', name);
+                    loaded.exports = this._patch(name, loaded.exports);
+                }
+                break;
+            }
+            else {
+                logger.debug({ requireResult: contextReq }, "module '".concat(name, "' not found"));
+            }
+        }
+        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));
+        if (!result)
+            return missingResult;
+        if (!result.error)
+            return result.exports;
+        if (allowLoadError)
+            return missingResult;
+        throw result.error;
+    };
+    Importer.prototype._patch = function (name, unpatched) {
+        if (name in this._patches) {
+            logger.debug('patching', name);
+            return this._patches[name].reduce(function (mod, patcher) { return patcher(mod); }, unpatched);
+        }
+        return unpatched;
+    };
+    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;
+        var res = this.tryThese.apply(this, __spreadArray([moduleName], __read(alternatives), false));
+        if (res && res.exists) {
+            if (!res.error)
+                return res.exports;
+            throw new Error((0, messages_1.interpolate)("Loading module {{module}} failed with error: {{error}}", { module: res.given, error: res.error.message }));
+        }
+        var msg = alternatives.length ? "Unable to load any of these modules: {{module}}. {{reason}}. To fix it:\n{{fix}}" : "Unable to load the module {{module}}. {{reason}} To fix it:\n{{fix}}";
+        var loadModule = __spreadArray([moduleName], __read(alternatives), false).map(function (m) { return "\"".concat(m, "\""); }).join(', ');
+        if (typeof installTip === 'string') {
+            installTip = [{ module: installTip, label: "install \"".concat(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}}`)", tip)); })
+            .join('\n');
+        throw new Error((0, messages_1.interpolate)(msg, {
+            module: loadModule,
+            reason: why,
+            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)(function (name) { return name; })
+    ], Importer.prototype, "_patch", null);
+    __decorate([
+        (0, memoize_1.Memoize)()
+    ], Importer, "instance", null);
+    return Importer;
+}());
+exports.Importer = Importer;
+exports.importer = Importer.instance;
+function requireWrapper(moduleName) {
+    var path;
+    var exists = false;
+    try {
+        path = resolveModule(moduleName);
+        exists = true;
+    }
+    catch (error) {
+        return { error: error, exists: exists, given: moduleName };
+    }
+    var result = { exists: exists, path: path, given: moduleName };
+    try {
+        result.exports = requireModule(path);
+    }
+    catch (error) {
+        try {
+            result.exports = requireModule(moduleName);
+        }
+        catch (error) {
+            result.error = error;
+        }
+    }
+    return result;
+}
+var requireModule = function (mod) { return require(mod); };
+var resolveModule = function (mod) { return require.resolve(mod, { paths: [process.cwd(), __dirname] }); };
+function __requireModule(localRequire, localResolve) {
+    requireModule = localRequire;
+    resolveModule = localResolve;
+}
+exports.__requireModule = __requireModule;

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

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

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

@@ -0,0 +1,19 @@
+"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);

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

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

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

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = exports.parse = exports.stringify = void 0;
+var fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+var UNDEFINED = 'undefined';
+function stringify(input) {
+    return input === undefined ? UNDEFINED : (0, fast_json_stable_stringify_1.default)(input);
+}
+exports.stringify = stringify;
+function parse(input) {
+    return input === UNDEFINED ? undefined : JSON.parse(input);
+}
+exports.parse = parse;
+function normalize(input, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.parse, parser = _c === void 0 ? parse : _c;
+    var result;
+    if (normalize.cache.has(input)) {
+        result = normalize.cache.get(input);
+    }
+    else {
+        var data = parser(input);
+        result = stringify(data);
+        if (result === input)
+            result = undefined;
+        normalize.cache.set(input, result);
+    }
+    return result === undefined ? input : result;
+}
+exports.normalize = normalize;
+(function (normalize) {
+    normalize.cache = new Map();
+})(normalize = exports.normalize || (exports.normalize = {}));

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootLogger = void 0;
+var bs_logger_1 = require("bs-logger");
+var backports_1 = require("./backports");
+var original = process.env.TS_JEST_LOG;
+var buildOptions = function () {
+    var _a;
+    return ({
+        context: (_a = {},
+            _a[bs_logger_1.LogContexts.package] = 'ts-jest',
+            _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
+            _a.version = require('../../package.json').version,
+            _a),
+        targets: process.env.TS_JEST_LOG || undefined,
+    });
+};
+exports.rootLogger = (0, bs_logger_1.createLogger)(buildOptions());
+(0, backports_1.backportTsJestDebugEnvVar)(exports.rootLogger);
+if (original !== process.env.TS_JEST_LOG) {
+    exports.rootLogger = (0, bs_logger_1.createLogger)(buildOptions());
+}

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

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

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memoize = void 0;
+var cacheProp = Symbol.for('[memoize]');
+function Memoize(keyBuilder) {
+    return function (_, propertyKey, descriptor) {
+        if (descriptor.value != null) {
+            descriptor.value = memoize(propertyKey, descriptor.value, keyBuilder || (function (v) { return v; }));
+        }
+        else if (descriptor.get != null) {
+            descriptor.get = memoize(propertyKey, descriptor.get, keyBuilder || (function () { return propertyKey; }));
+        }
+    };
+}
+exports.Memoize = Memoize;
+function ensureCache(target, reset) {
+    if (reset === void 0) { reset = false; }
+    if (reset || !target[cacheProp]) {
+        Object.defineProperty(target, cacheProp, {
+            value: Object.create(null),
+            configurable: true,
+        });
+    }
+    return target[cacheProp];
+}
+function ensureChildCache(target, key, reset) {
+    if (reset === void 0) { reset = false; }
+    var dict = ensureCache(target);
+    if (reset || !dict[key]) {
+        dict[key] = new Map();
+    }
+    return dict[key];
+}
+function memoize(namespace, func, keyBuilder) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var cache = ensureChildCache(this, namespace);
+        var key = keyBuilder.apply(this, args);
+        if (cache.has(key))
+            return cache.get(key);
+        var res = func.apply(this, args);
+        cache.set(key, res);
+        return res;
+    };
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha1 = exports.cache = void 0;
+var crypto_1 = require("crypto");
+exports.cache = Object.create(null);
+function sha1() {
+    var data = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        data[_i] = arguments[_i];
+    }
+    var canCache = data.length === 1 && typeof data[0] === 'string';
+    var cacheKey;
+    if (canCache) {
+        cacheKey = data[0];
+        if (cacheKey in exports.cache) {
+            return exports.cache[cacheKey];
+        }
+    }
+    var hash = (0, crypto_1.createHash)('sha1');
+    data.forEach(function (item) {
+        if (typeof item === 'string')
+            hash.update(item, 'utf8');
+        else
+            hash.update(item);
+    });
+    var res = hash.digest('hex').toString();
+    if (canCache) {
+        exports.cache[cacheKey] = res;
+    }
+    return res;
+}
+exports.sha1 = sha1;

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

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

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

@@ -0,0 +1,43 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSError = exports.INSPECT_CUSTOM = void 0;
+var util_1 = require("util");
+var make_error_1 = require("make-error");
+var logger_1 = require("./logger");
+var messages_1 = require("./messages");
+var logger = logger_1.rootLogger.child({ namespace: 'TSError' });
+exports.INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
+var TSError = (function (_super) {
+    __extends(TSError, _super);
+    function TSError(diagnosticText, diagnosticCodes) {
+        var _this = _super.call(this, (0, messages_1.interpolate)("{{diagnostics}}", {
+            diagnostics: diagnosticText.trim(),
+        })) || this;
+        _this.diagnosticText = diagnosticText;
+        _this.diagnosticCodes = diagnosticCodes;
+        _this.name = 'TSError';
+        logger.debug({ diagnosticCodes: diagnosticCodes, diagnosticText: diagnosticText }, 'created new TSError');
+        Object.defineProperty(_this, 'stack', { value: '' });
+        return _this;
+    }
+    TSError.prototype[exports.INSPECT_CUSTOM] = function () {
+        return this.diagnosticText;
+    };
+    return TSError;
+}(make_error_1.BaseError));
+exports.TSError = TSError;

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

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

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

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