.

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

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

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

@@ -0,0 +1,101 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var _a;
+var bs_logger_1 = require("bs-logger");
+var messages_1 = require("./messages");
+var context = (_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'backports', _a);
+exports.backportJestConfig = function (logger, config) {
+    logger.debug(__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, messages_1.interpolate(note ? messages_1.Deprecateds.ConfigOptionWithNote : messages_1.Deprecateds.ConfigOption, {
+            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 ('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.pathRegex = tsJest.enableTsDiagnostics;
+        }
+        else {
+            mergeTsJest.diagnostics = false;
+        }
+        delete tsJest.enableTsDiagnostics;
+    }
+    if ('useBabelrc' in tsJest) {
+        warnConfig('globals.ts-jest.useBabelrc', 'globals.ts-jest.babelConfig', messages_1.Deprecateds.ConfigOptionUseBabelRcNote);
+        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, messages_1.Helps.MigrateConfigUsingCLI);
+    }
+    return __assign({}, config, { globals: __assign({}, globals, { 'ts-jest': __assign({}, mergeTsJest, tsJest) }) });
+};
+exports.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, messages_1.interpolate(messages_1.Deprecateds.EnvVar, {
+            old: 'TS_JEST_DEBUG',
+            new: 'TS_JEST_LOG',
+        }));
+    }
+};

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,193 @@
+"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 __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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: true,
+        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.tryThese = function (moduleName) {
+        var fallbacks = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            fallbacks[_i - 1] = arguments[_i];
+        }
+        var name;
+        var loaded;
+        var tries = __spread([moduleName], fallbacks);
+        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 '" + 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 '" + name + "' not found");
+                continue;
+            }
+        }
+        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, __spread(args));
+        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, __spread([moduleName], alternatives));
+        if (res && res.exists) {
+            if (!res.error)
+                return res.exports;
+            throw new Error(messages_1.interpolate(messages_1.Errors.LoadingModuleFailed, { module: res.given, error: res.error.message }));
+        }
+        var msg = alternatives.length ? messages_1.Errors.UnableToLoadAnyModule : messages_1.Errors.UnableToLoadOneModule;
+        var loadModule = __spread([moduleName], alternatives).map(function (m) { return "\"" + m + "\""; }).join(', ');
+        if (typeof installTip === 'string') {
+            installTip = [{ module: installTip, label: "install \"" + installTip + "\"" }];
+        }
+        var fix = installTip
+            .map(function (tip) {
+            return "    " + (installTip.length === 1 ? '↳' : '•') + " " + messages_1.interpolate(messages_1.Helps.FixMissingModule, tip);
+        })
+            .join('\n');
+        throw new Error(messages_1.interpolate(msg, {
+            module: loadModule,
+            reason: why,
+            fix: fix,
+        }));
+    };
+    __decorate([
+        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([
+        memoize_1.Memoize(function (name) { return name; })
+    ], Importer.prototype, "_patch", null);
+    __decorate([
+        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(moduleName);
+    }
+    catch (error) {
+        result.error = error;
+    }
+    return result;
+}
+var requireModule = function (mod) { return require(mod); };
+var resolveModule = function (mod) { return require.resolve(mod); };
+function __requireModule(localRequire, localResolve) {
+    requireModule = localRequire;
+    resolveModule = localResolve;
+}
+exports.__requireModule = __requireModule;

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var stableStringify = require("fast-json-stable-stringify");
+var UNDEFINED = 'undefined';
+function stringify(input) {
+    return input === undefined ? UNDEFINED : stableStringify(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).parse, parser = _b === void 0 ? parse : _b;
+    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/util/jsonable-value.d.ts

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

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = json_1.stringify(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(JsonableValue.prototype, "serialized", {
+        get: function () {
+            return this._serialized;
+        },
+        enumerable: true,
+        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/util/logger.d.ts

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

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = bs_logger_1.createLogger(buildOptions());
+backports_1.backportTsJestDebugEnvVar(exports.rootLogger);
+if (original !== process.env.TS_JEST_LOG) {
+    exports.rootLogger = bs_logger_1.createLogger(buildOptions());
+}

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

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

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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/util/messages.d.ts

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = 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/util/testing.d.ts

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

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

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

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

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

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

@@ -0,0 +1,41 @@
+"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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    }
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var make_error_1 = require("make-error");
+var util_1 = require("util");
+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, messages_1.interpolate(messages_1.Errors.UnableToCompileTypeScript, {
+            diagnostics: diagnosticText.trim(),
+            help: messages_1.Helps.IgnoreDiagnosticCode,
+        })) || 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/util/version-checkers.d.ts

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

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

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