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

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

.github/workflows/unit-tests.yml

@@ -2,11 +2,11 @@ name: "Run unit tests."
 on: # rebuild any PRs and main branch changes
   pull_request:
     branches:
-      - master
+      - main
       - "releases/*"
   push:
     branches:
-      - master
+      - main
       - "releases/*"
 
 jobs:

README.md

@@ -42,7 +42,7 @@ Following are the key capabilities of this action:
   </tr>
   <tr>
     <td>manifests </br></br>(Required)</td>
-    <td>Path to the manifest files to be used for deployment</td>
+    <td>Path to the manifest files to be used for deployment. These can also be directories containing manifest files, in which case, all manifest files in the referenced directory at every depth will be deployed. Files not ending in .yml or .yaml will be ignored.</td>
   </tr>  
   <tr>
     <td>namespace </br></br>(Optional)
@@ -105,23 +105,21 @@ Following are the key capabilities of this action:
 ### Basic deployment (without any deployment strategy)
 
 ```yaml
-- uses: Azure/k8s-deploy@v1.4
+- uses: Azure/k8s-deploy@v3.1
   with:
     namespace: "myapp"
     manifests: |
-      deployment.yaml
+      dir/manifestsDirectory
-      service.yaml
     images: "contoso.azurecr.io/myapp:${{ event.run_id }}"
     imagepullsecrets: |
       image-pull-secret1
       image-pull-secret2
-    kubectl-version: "latest"
 ```
 
 ### Canary deployment without service mesh
 
 ```yaml
-- uses: Azure/k8s-deploy@v1.4
+- uses: Azure/k8s-deploy@v3.1
   with:
     namespace: "myapp"
     images: "contoso.azurecr.io/myapp:${{ event.run_id }}"
@@ -131,6 +129,7 @@ Following are the key capabilities of this action:
     manifests: |
       deployment.yaml
       service.yaml
+      dir/manifestsDirectory
     strategy: canary
     action: deploy
     percentage: 20
@@ -139,7 +138,7 @@ Following are the key capabilities of this action:
 To promote/reject the canary created by the above snippet, the following YAML snippet could be used:
 
 ```yaml
-- uses: Azure/k8s-deploy@v1.4
+- uses: Azure/k8s-deploy@v3.1
   with:
     namespace: "myapp"
     images: "contoso.azurecr.io/myapp:${{ event.run_id }}"
@@ -149,6 +148,7 @@ To promote/reject the canary created by the above snippet, the following YAML sn
     manifests: |
       deployment.yaml
       service.yaml
+      dir/manifestsDirectory
     strategy: canary
     action: promote # substitute reject if you want to reject
 ```
@@ -156,7 +156,7 @@ To promote/reject the canary created by the above snippet, the following YAML sn
 ### Canary deployment based on Service Mesh Interface
 
 ```yaml
-- uses: Azure/k8s-deploy@v1.4
+- uses: Azure/k8s-deploy@v3.1
   with:
     namespace: "myapp"
     images: "contoso.azurecr.io/myapp:${{ event.run_id }}"
@@ -166,6 +166,7 @@ To promote/reject the canary created by the above snippet, the following YAML sn
     manifests: |
       deployment.yaml
       service.yaml
+      dir/manifestsDirectory
     strategy: canary
     action: deploy
     traffic-split-method: smi
@@ -176,7 +177,7 @@ To promote/reject the canary created by the above snippet, the following YAML sn
 To promote/reject the canary created by the above snippet, the following YAML snippet could be used:
 
 ```yaml
-- uses: Azure/k8s-deploy@v1.4
+- uses: Azure/k8s-deploy@v3.1
   with:
     namespace: "myapp"
     images: "contoso.azurecr.io/myapp:${{ event.run_id }} "
@@ -186,6 +187,7 @@ To promote/reject the canary created by the above snippet, the following YAML sn
     manifests: |
       deployment.yaml
       service.yaml
+      dir/manifestsDirectory
     strategy: canary
     traffic-split-method: smi
     action: reject # substitute reject if you want to reject
@@ -194,7 +196,7 @@ To promote/reject the canary created by the above snippet, the following YAML sn
 ### Blue-Green deployment with different route methods
 
 ```yaml
-- uses: Azure/k8s-deploy@v1.4
+- uses: Azure/k8s-deploy@v3.1
   with:
     namespace: "myapp"
     images: "contoso.azurecr.io/myapp:${{ event.run_id }}"
@@ -214,7 +216,7 @@ To promote/reject the canary created by the above snippet, the following YAML sn
 To promote/reject the green workload created by the above snippet, the following YAML snippet could be used:
 
 ```yaml
-- uses: Azure/k8s-deploy@v1.4
+- uses: Azure/k8s-deploy@v3.1
   with:
     namespace: "myapp"
     images: "contoso.azurecr.io/myapp:${{ event.run_id }}"
@@ -224,7 +226,7 @@ To promote/reject the green workload created by the above snippet, the following
     manifests: |
       deployment.yaml
       service.yaml
-      ingress-yml
+      ingress.yml
     strategy: blue-green
     route-method: ingress # should be the same as the value when action was deploy
     action: promote # substitute reject if you want to reject
@@ -271,7 +273,7 @@ jobs:
           container-registry-password: ${{ secrets.REGISTRY_PASSWORD }}
           secret-name: demo-k8s-secret
 
-      - uses: Azure/k8s-deploy@v1.4
+      - uses: Azure/k8s-deploy@v3.1
         with:
           action: deploy
           manifests: |
@@ -317,7 +319,7 @@ jobs:
           container-registry-password: ${{ secrets.REGISTRY_PASSWORD }}
           secret-name: demo-k8s-secret
 
-      - uses: Azure/k8s-deploy@v1.4
+      - uses: Azure/k8s-deploy@v3.1
         with:
           action: deploy
           manifests: |

action.yml

@@ -63,5 +63,5 @@ inputs:
 branding:
   color: "green"
 runs:
-  using: "node12"
+  using: "node16"
   main: "lib/index.js"

lib/index.js

@@ -19888,7 +19888,9 @@ class Kubectl {
             if (this.ignoreSSLErrors) {
                 args.push("--insecure-skip-tls-verify");
             }
-            args = args.concat(["--namespace", this.namespace]);
+            if (this.namespace && this.namespace != "default") {
+                args = args.concat(["--namespace", this.namespace]);
+            }
             core.debug(`Kubectl run with command: ${this.kubectlPath} ${args}`);
             return yield exec_1.getExecOutput(this.kubectlPath, args, { silent });
         });
@@ -20979,7 +20981,15 @@ exports.getTrafficSplitAPIVersion = getTrafficSplitAPIVersion;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.getWorkflowAnnotationKeyLabel = exports.getWorkflowAnnotations = void 0;
+exports.getWorkflowAnnotationKeyLabel = exports.getWorkflowAnnotations = exports.prefixObjectKeys = void 0;
+const ANNOTATION_PREFIX = "actions.github.com/";
+function prefixObjectKeys(obj, prefix) {
+    return Object.keys(obj).reduce((newObj, key) => {
+        newObj[prefix + key] = obj[key];
+        return newObj;
+    }, {});
+}
+exports.prefixObjectKeys = prefixObjectKeys;
 function getWorkflowAnnotations(lastSuccessRunSha, workflowFilePath, deploymentConfig) {
     const annotationObject = {
         run: process.env.GITHUB_RUN_ID,
@@ -20998,7 +21008,8 @@ function getWorkflowAnnotations(lastSuccessRunSha, workflowFilePath, deploymentC
         helmChartPaths: deploymentConfig.helmChartFilePaths,
         provider: "GitHub",
     };
-    return JSON.stringify(annotationObject);
+    const prefixedAnnotationObject = prefixObjectKeys(annotationObject, ANNOTATION_PREFIX);
+    return JSON.stringify(prefixedAnnotationObject);
 }
 exports.getWorkflowAnnotations = getWorkflowAnnotations;
 function getWorkflowAnnotationKeyLabel(workflowFilePath) {

node_modules/.package-lock.json

@@ -3915,12 +3915,6 @@
       "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
       "dev": true
     },
-    "node_modules/lodash.memoize": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
-      "integrity": "sha1-vMbEmkKihA7Zl/Mj6tpezRguC/4=",
-      "dev": true
-    },
     "node_modules/lru-cache": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
@@ -4077,15 +4071,15 @@
       }
     },
     "node_modules/mkdirp": {
-      "version": "0.5.5",
+      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
-      "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
       "dev": true,
-      "dependencies": {
-        "minimist": "^1.2.5"
-      },
       "bin": {
         "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
       }
     },
     "node_modules/ms": {
@@ -5628,31 +5622,55 @@
       }
     },
     "node_modules/ts-jest": {
-      "version": "25.5.1",
+      "version": "26.5.6",
-      "resolved": "https://registry.npmjs.org/ts-jest/-/ts-jest-25.5.1.tgz",
+      "resolved": "https://registry.npmjs.org/ts-jest/-/ts-jest-26.5.6.tgz",
-      "integrity": "sha512-kHEUlZMK8fn8vkxDjwbHlxXRB9dHYpyzqKIGDNxbzs+Rz+ssNDSDNusEK8Fk/sDd4xE6iKoQLfFkFVaskmTJyw==",
+      "integrity": "sha512-rua+rCP8DxpA8b4DQD/6X2HQS8Zy/xzViVYfEs2OQu68tkCuKLV0Md8pmX55+W24uRIyAsf/BajRfxOs+R2MKA==",
       "dev": true,
       "dependencies": {
         "bs-logger": "0.x",
         "buffer-from": "1.x",
         "fast-json-stable-stringify": "2.x",
+        "jest-util": "^26.1.0",
         "json5": "2.x",
-        "lodash.memoize": "4.x",
+        "lodash": "4.x",
         "make-error": "1.x",
-        "micromatch": "4.x",
+        "mkdirp": "1.x",
-        "mkdirp": "0.x",
+        "semver": "7.x",
-        "semver": "6.x",
+        "yargs-parser": "20.x"
-        "yargs-parser": "18.x"
       },
       "bin": {
         "ts-jest": "cli.js"
       },
       "engines": {
-        "node": ">= 8"
+        "node": ">= 10"
       },
       "peerDependencies": {
-        "jest": ">=25 <26",
+        "jest": ">=26 <27",
-        "typescript": ">=3.4 <4.0"
+        "typescript": ">=3.8 <5.0"
+      }
+    },
+    "node_modules/ts-jest/node_modules/semver": {
+      "version": "7.3.7",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz",
+      "integrity": "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==",
+      "dev": true,
+      "dependencies": {
+        "lru-cache": "^6.0.0"
+      },
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/ts-jest/node_modules/yargs-parser": {
+      "version": "20.2.9",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz",
+      "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
       }
     },
     "node_modules/tunnel": {

node_modules/lodash.memoize/LICENSE

@@ -1,47 +0,0 @@
-Copyright jQuery Foundation and other contributors <https://jquery.org/>
-
-Based on Underscore.js, copyright Jeremy Ashkenas,
-DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
-
-This software consists of voluntary contributions made by many
-individuals. For exact contribution history, see the revision history
-available at https://github.com/lodash/lodash
-
-The following license applies to all parts of this software except as
-documented below:
-
-====
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-====
-
-Copyright and related rights for sample code are waived via CC0. Sample
-code is defined as all source code displayed within the prose of the
-documentation.
-
-CC0: http://creativecommons.org/publicdomain/zero/1.0/
-
-====
-
-Files located in the node_modules and vendor directories are externally
-maintained libraries used by this software which have their own
-licenses; we recommend you read them, as their terms may differ from the
-terms above.

node_modules/lodash.memoize/README.md

@@ -1,18 +0,0 @@
-# lodash.memoize v4.1.2
-
-The [lodash](https://lodash.com/) method `_.memoize` exported as a [Node.js](https://nodejs.org/) module.
-
-## Installation
-
-Using npm:
-```bash
-$ {sudo -H} npm i -g npm
-$ npm i --save lodash.memoize
-```
-
-In Node.js:
-```js
-var memoize = require('lodash.memoize');
-```
-
-See the [documentation](https://lodash.com/docs#memoize) or [package source](https://github.com/lodash/lodash/blob/4.1.2-npm-packages/lodash.memoize) for more details.

node_modules/lodash.memoize/index.js

@@ -1,676 +0,0 @@
-/**
- * lodash (Custom Build) <https://lodash.com/>
- * Build: `lodash modularize exports="npm" -o ./`
- * Copyright jQuery Foundation and other contributors <https://jquery.org/>
- * Released under MIT license <https://lodash.com/license>
- * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
- * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
- */
-
-/** Used as the `TypeError` message for "Functions" methods. */
-var FUNC_ERROR_TEXT = 'Expected a function';
-
-/** Used to stand-in for `undefined` hash values. */
-var HASH_UNDEFINED = '__lodash_hash_undefined__';
-
-/** `Object#toString` result references. */
-var funcTag = '[object Function]',
-    genTag = '[object GeneratorFunction]';
-
-/**
- * Used to match `RegExp`
- * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
- */
-var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
-
-/** Used to detect host constructors (Safari). */
-var reIsHostCtor = /^\[object .+?Constructor\]$/;
-
-/** Detect free variable `global` from Node.js. */
-var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
-
-/** Detect free variable `self`. */
-var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
-
-/** Used as a reference to the global object. */
-var root = freeGlobal || freeSelf || Function('return this')();
-
-/**
- * Gets the value at `key` of `object`.
- *
- * @private
- * @param {Object} [object] The object to query.
- * @param {string} key The key of the property to get.
- * @returns {*} Returns the property value.
- */
-function getValue(object, key) {
-  return object == null ? undefined : object[key];
-}
-
-/**
- * Checks if `value` is a host object in IE < 9.
- *
- * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
- */
-function isHostObject(value) {
-  // Many host objects are `Object` objects that can coerce to strings
-  // despite having improperly defined `toString` methods.
-  var result = false;
-  if (value != null && typeof value.toString != 'function') {
-    try {
-      result = !!(value + '');
-    } catch (e) {}
-  }
-  return result;
-}
-
-/** Used for built-in method references. */
-var arrayProto = Array.prototype,
-    funcProto = Function.prototype,
-    objectProto = Object.prototype;
-
-/** Used to detect overreaching core-js shims. */
-var coreJsData = root['__core-js_shared__'];
-
-/** Used to detect methods masquerading as native. */
-var maskSrcKey = (function() {
-  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
-  return uid ? ('Symbol(src)_1.' + uid) : '';
-}());
-
-/** Used to resolve the decompiled source of functions. */
-var funcToString = funcProto.toString;
-
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
-
-/**
- * Used to resolve the
- * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
- * of values.
- */
-var objectToString = objectProto.toString;
-
-/** Used to detect if a method is native. */
-var reIsNative = RegExp('^' +
-  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
-  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
-);
-
-/** Built-in value references. */
-var splice = arrayProto.splice;
-
-/* Built-in method references that are verified to be native. */
-var Map = getNative(root, 'Map'),
-    nativeCreate = getNative(Object, 'create');
-
-/**
- * Creates a hash object.
- *
- * @private
- * @constructor
- * @param {Array} [entries] The key-value pairs to cache.
- */
-function Hash(entries) {
-  var index = -1,
-      length = entries ? entries.length : 0;
-
-  this.clear();
-  while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
-  }
-}
-
-/**
- * Removes all key-value entries from the hash.
- *
- * @private
- * @name clear
- * @memberOf Hash
- */
-function hashClear() {
-  this.__data__ = nativeCreate ? nativeCreate(null) : {};
-}
-
-/**
- * Removes `key` and its value from the hash.
- *
- * @private
- * @name delete
- * @memberOf Hash
- * @param {Object} hash The hash to modify.
- * @param {string} key The key of the value to remove.
- * @returns {boolean} Returns `true` if the entry was removed, else `false`.
- */
-function hashDelete(key) {
-  return this.has(key) && delete this.__data__[key];
-}
-
-/**
- * Gets the hash value for `key`.
- *
- * @private
- * @name get
- * @memberOf Hash
- * @param {string} key The key of the value to get.
- * @returns {*} Returns the entry value.
- */
-function hashGet(key) {
-  var data = this.__data__;
-  if (nativeCreate) {
-    var result = data[key];
-    return result === HASH_UNDEFINED ? undefined : result;
-  }
-  return hasOwnProperty.call(data, key) ? data[key] : undefined;
-}
-
-/**
- * Checks if a hash value for `key` exists.
- *
- * @private
- * @name has
- * @memberOf Hash
- * @param {string} key The key of the entry to check.
- * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
- */
-function hashHas(key) {
-  var data = this.__data__;
-  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
-}
-
-/**
- * Sets the hash `key` to `value`.
- *
- * @private
- * @name set
- * @memberOf Hash
- * @param {string} key The key of the value to set.
- * @param {*} value The value to set.
- * @returns {Object} Returns the hash instance.
- */
-function hashSet(key, value) {
-  var data = this.__data__;
-  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
-  return this;
-}
-
-// Add methods to `Hash`.
-Hash.prototype.clear = hashClear;
-Hash.prototype['delete'] = hashDelete;
-Hash.prototype.get = hashGet;
-Hash.prototype.has = hashHas;
-Hash.prototype.set = hashSet;
-
-/**
- * Creates an list cache object.
- *
- * @private
- * @constructor
- * @param {Array} [entries] The key-value pairs to cache.
- */
-function ListCache(entries) {
-  var index = -1,
-      length = entries ? entries.length : 0;
-
-  this.clear();
-  while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
-  }
-}
-
-/**
- * Removes all key-value entries from the list cache.
- *
- * @private
- * @name clear
- * @memberOf ListCache
- */
-function listCacheClear() {
-  this.__data__ = [];
-}
-
-/**
- * Removes `key` and its value from the list cache.
- *
- * @private
- * @name delete
- * @memberOf ListCache
- * @param {string} key The key of the value to remove.
- * @returns {boolean} Returns `true` if the entry was removed, else `false`.
- */
-function listCacheDelete(key) {
-  var data = this.__data__,
-      index = assocIndexOf(data, key);
-
-  if (index < 0) {
-    return false;
-  }
-  var lastIndex = data.length - 1;
-  if (index == lastIndex) {
-    data.pop();
-  } else {
-    splice.call(data, index, 1);
-  }
-  return true;
-}
-
-/**
- * Gets the list cache value for `key`.
- *
- * @private
- * @name get
- * @memberOf ListCache
- * @param {string} key The key of the value to get.
- * @returns {*} Returns the entry value.
- */
-function listCacheGet(key) {
-  var data = this.__data__,
-      index = assocIndexOf(data, key);
-
-  return index < 0 ? undefined : data[index][1];
-}
-
-/**
- * Checks if a list cache value for `key` exists.
- *
- * @private
- * @name has
- * @memberOf ListCache
- * @param {string} key The key of the entry to check.
- * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
- */
-function listCacheHas(key) {
-  return assocIndexOf(this.__data__, key) > -1;
-}
-
-/**
- * Sets the list cache `key` to `value`.
- *
- * @private
- * @name set
- * @memberOf ListCache
- * @param {string} key The key of the value to set.
- * @param {*} value The value to set.
- * @returns {Object} Returns the list cache instance.
- */
-function listCacheSet(key, value) {
-  var data = this.__data__,
-      index = assocIndexOf(data, key);
-
-  if (index < 0) {
-    data.push([key, value]);
-  } else {
-    data[index][1] = value;
-  }
-  return this;
-}
-
-// Add methods to `ListCache`.
-ListCache.prototype.clear = listCacheClear;
-ListCache.prototype['delete'] = listCacheDelete;
-ListCache.prototype.get = listCacheGet;
-ListCache.prototype.has = listCacheHas;
-ListCache.prototype.set = listCacheSet;
-
-/**
- * Creates a map cache object to store key-value pairs.
- *
- * @private
- * @constructor
- * @param {Array} [entries] The key-value pairs to cache.
- */
-function MapCache(entries) {
-  var index = -1,
-      length = entries ? entries.length : 0;
-
-  this.clear();
-  while (++index < length) {
-    var entry = entries[index];
-    this.set(entry[0], entry[1]);
-  }
-}
-
-/**
- * Removes all key-value entries from the map.
- *
- * @private
- * @name clear
- * @memberOf MapCache
- */
-function mapCacheClear() {
-  this.__data__ = {
-    'hash': new Hash,
-    'map': new (Map || ListCache),
-    'string': new Hash
-  };
-}
-
-/**
- * Removes `key` and its value from the map.
- *
- * @private
- * @name delete
- * @memberOf MapCache
- * @param {string} key The key of the value to remove.
- * @returns {boolean} Returns `true` if the entry was removed, else `false`.
- */
-function mapCacheDelete(key) {
-  return getMapData(this, key)['delete'](key);
-}
-
-/**
- * Gets the map value for `key`.
- *
- * @private
- * @name get
- * @memberOf MapCache
- * @param {string} key The key of the value to get.
- * @returns {*} Returns the entry value.
- */
-function mapCacheGet(key) {
-  return getMapData(this, key).get(key);
-}
-
-/**
- * Checks if a map value for `key` exists.
- *
- * @private
- * @name has
- * @memberOf MapCache
- * @param {string} key The key of the entry to check.
- * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
- */
-function mapCacheHas(key) {
-  return getMapData(this, key).has(key);
-}
-
-/**
- * Sets the map `key` to `value`.
- *
- * @private
- * @name set
- * @memberOf MapCache
- * @param {string} key The key of the value to set.
- * @param {*} value The value to set.
- * @returns {Object} Returns the map cache instance.
- */
-function mapCacheSet(key, value) {
-  getMapData(this, key).set(key, value);
-  return this;
-}
-
-// Add methods to `MapCache`.
-MapCache.prototype.clear = mapCacheClear;
-MapCache.prototype['delete'] = mapCacheDelete;
-MapCache.prototype.get = mapCacheGet;
-MapCache.prototype.has = mapCacheHas;
-MapCache.prototype.set = mapCacheSet;
-
-/**
- * Gets the index at which the `key` is found in `array` of key-value pairs.
- *
- * @private
- * @param {Array} array The array to inspect.
- * @param {*} key The key to search for.
- * @returns {number} Returns the index of the matched value, else `-1`.
- */
-function assocIndexOf(array, key) {
-  var length = array.length;
-  while (length--) {
-    if (eq(array[length][0], key)) {
-      return length;
-    }
-  }
-  return -1;
-}
-
-/**
- * The base implementation of `_.isNative` without bad shim checks.
- *
- * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a native function,
- *  else `false`.
- */
-function baseIsNative(value) {
-  if (!isObject(value) || isMasked(value)) {
-    return false;
-  }
-  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
-  return pattern.test(toSource(value));
-}
-
-/**
- * Gets the data for `map`.
- *
- * @private
- * @param {Object} map The map to query.
- * @param {string} key The reference key.
- * @returns {*} Returns the map data.
- */
-function getMapData(map, key) {
-  var data = map.__data__;
-  return isKeyable(key)
-    ? data[typeof key == 'string' ? 'string' : 'hash']
-    : data.map;
-}
-
-/**
- * Gets the native function at `key` of `object`.
- *
- * @private
- * @param {Object} object The object to query.
- * @param {string} key The key of the method to get.
- * @returns {*} Returns the function if it's native, else `undefined`.
- */
-function getNative(object, key) {
-  var value = getValue(object, key);
-  return baseIsNative(value) ? value : undefined;
-}
-
-/**
- * Checks if `value` is suitable for use as unique object key.
- *
- * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
- */
-function isKeyable(value) {
-  var type = typeof value;
-  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
-    ? (value !== '__proto__')
-    : (value === null);
-}
-
-/**
- * Checks if `func` has its source masked.
- *
- * @private
- * @param {Function} func The function to check.
- * @returns {boolean} Returns `true` if `func` is masked, else `false`.
- */
-function isMasked(func) {
-  return !!maskSrcKey && (maskSrcKey in func);
-}
-
-/**
- * Converts `func` to its source code.
- *
- * @private
- * @param {Function} func The function to process.
- * @returns {string} Returns the source code.
- */
-function toSource(func) {
-  if (func != null) {
-    try {
-      return funcToString.call(func);
-    } catch (e) {}
-    try {
-      return (func + '');
-    } catch (e) {}
-  }
-  return '';
-}
-
-/**
- * Creates a function that memoizes the result of `func`. If `resolver` is
- * provided, it determines the cache key for storing the result based on the
- * arguments provided to the memoized function. By default, the first argument
- * provided to the memoized function is used as the map cache key. The `func`
- * is invoked with the `this` binding of the memoized function.
- *
- * **Note:** The cache is exposed as the `cache` property on the memoized
- * function. Its creation may be customized by replacing the `_.memoize.Cache`
- * constructor with one whose instances implement the
- * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
- * method interface of `delete`, `get`, `has`, and `set`.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Function
- * @param {Function} func The function to have its output memoized.
- * @param {Function} [resolver] The function to resolve the cache key.
- * @returns {Function} Returns the new memoized function.
- * @example
- *
- * var object = { 'a': 1, 'b': 2 };
- * var other = { 'c': 3, 'd': 4 };
- *
- * var values = _.memoize(_.values);
- * values(object);
- * // => [1, 2]
- *
- * values(other);
- * // => [3, 4]
- *
- * object.a = 2;
- * values(object);
- * // => [1, 2]
- *
- * // Modify the result cache.
- * values.cache.set(object, ['a', 'b']);
- * values(object);
- * // => ['a', 'b']
- *
- * // Replace `_.memoize.Cache`.
- * _.memoize.Cache = WeakMap;
- */
-function memoize(func, resolver) {
-  if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
-    throw new TypeError(FUNC_ERROR_TEXT);
-  }
-  var memoized = function() {
-    var args = arguments,
-        key = resolver ? resolver.apply(this, args) : args[0],
-        cache = memoized.cache;
-
-    if (cache.has(key)) {
-      return cache.get(key);
-    }
-    var result = func.apply(this, args);
-    memoized.cache = cache.set(key, result);
-    return result;
-  };
-  memoized.cache = new (memoize.Cache || MapCache);
-  return memoized;
-}
-
-// Assign cache to `_.memoize`.
-memoize.Cache = MapCache;
-
-/**
- * Performs a
- * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
- * comparison between two values to determine if they are equivalent.
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to compare.
- * @param {*} other The other value to compare.
- * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
- * @example
- *
- * var object = { 'a': 1 };
- * var other = { 'a': 1 };
- *
- * _.eq(object, object);
- * // => true
- *
- * _.eq(object, other);
- * // => false
- *
- * _.eq('a', 'a');
- * // => true
- *
- * _.eq('a', Object('a'));
- * // => false
- *
- * _.eq(NaN, NaN);
- * // => true
- */
-function eq(value, other) {
-  return value === other || (value !== value && other !== other);
-}
-
-/**
- * Checks if `value` is classified as a `Function` object.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a function, else `false`.
- * @example
- *
- * _.isFunction(_);
- * // => true
- *
- * _.isFunction(/abc/);
- * // => false
- */
-function isFunction(value) {
-  // The use of `Object#toString` avoids issues with the `typeof` operator
-  // in Safari 8-9 which returns 'object' for typed array and other constructors.
-  var tag = isObject(value) ? objectToString.call(value) : '';
-  return tag == funcTag || tag == genTag;
-}
-
-/**
- * Checks if `value` is the
- * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
- * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an object, else `false`.
- * @example
- *
- * _.isObject({});
- * // => true
- *
- * _.isObject([1, 2, 3]);
- * // => true
- *
- * _.isObject(_.noop);
- * // => true
- *
- * _.isObject(null);
- * // => false
- */
-function isObject(value) {
-  var type = typeof value;
-  return !!value && (type == 'object' || type == 'function');
-}
-
-module.exports = memoize;

node_modules/lodash.memoize/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "lodash.memoize",
-  "version": "4.1.2",
-  "description": "The lodash method `_.memoize` exported as a module.",
-  "homepage": "https://lodash.com/",
-  "icon": "https://lodash.com/icon.svg",
-  "license": "MIT",
-  "keywords": "lodash-modularized, memoize",
-  "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
-  "contributors": [
-    "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
-    "Blaine Bublitz <blaine.bublitz@gmail.com> (https://github.com/phated)",
-    "Mathias Bynens <mathias@qiwi.be> (https://mathiasbynens.be/)"
-  ],
-  "repository": "lodash/lodash",
-  "scripts": { "test": "echo \"See https://travis-ci.org/lodash/lodash-cli for testing details.\"" }
-}

node_modules/mkdirp/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changers Lorgs!
+
+## 1.0
+
+Full rewrite.  Essentially a brand new module.
+
+- Return a promise instead of taking a callback.
+- Use native `fs.mkdir(path, { recursive: true })` when available.
+- Drop support for outdated Node.js versions.  (Technically still works on
+  Node.js v8, but only 10 and above are officially supported.)
+
+## 0.x
+
+Original and most widely used recursive directory creation implementation
+in JavaScript, dating back to 2010.

node_modules/mkdirp/LICENSE

@@ -1,6 +1,6 @@
-Copyright 2010 James Halliday (mail@substack.net)
+Copyright James Halliday (mail@substack.net) and Isaac Z. Schlueter (i@izs.me)
 
-This project is free software released under the MIT/X11 license:
+This project is free software released under the MIT license:
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

node_modules/mkdirp/bin/cmd.js

@@ -1,33 +1,68 @@
 #!/usr/bin/env node
 
-var mkdirp = require('../');
+const usage = () => `
-var minimist = require('minimist');
+usage: mkdirp [DIR1,DIR2..] {OPTIONS}
-var fs = require('fs');
 
-var argv = minimist(process.argv.slice(2), {
+  Create each supplied directory including any necessary parent directories
-    alias: { m: 'mode', h: 'help' },
+  that don't yet exist.
-    string: [ 'mode' ]
+
-});
+  If the directory already exists, do nothing.
-if (argv.help) {
+
-    fs.createReadStream(__dirname + '/usage.txt').pipe(process.stdout);
+OPTIONS are:
-    return;
+
+  -m<mode>       If a directory needs to be created, set the mode as an octal
+  --mode=<mode>  permission string.
+
+  -v --version   Print the mkdirp version number
+
+  -h --help      Print this helpful banner
+
+  -p --print     Print the first directories created for each path provided
+
+  --manual       Use manual implementation, even if native is available
+`
+
+const dirs = []
+const opts = {}
+let print = false
+let dashdash = false
+let manual = false
+for (const arg of process.argv.slice(2)) {
+  if (dashdash)
+    dirs.push(arg)
+  else if (arg === '--')
+    dashdash = true
+  else if (arg === '--manual')
+    manual = true
+  else if (/^-h/.test(arg) || /^--help/.test(arg)) {
+    console.log(usage())
+    process.exit(0)
+  } else if (arg === '-v' || arg === '--version') {
+    console.log(require('../package.json').version)
+    process.exit(0)
+  } else if (arg === '-p' || arg === '--print') {
+    print = true
+  } else if (/^-m/.test(arg) || /^--mode=/.test(arg)) {
+    const mode = parseInt(arg.replace(/^(-m|--mode=)/, ''), 8)
+    if (isNaN(mode)) {
+      console.error(`invalid mode argument: ${arg}\nMust be an octal number.`)
+      process.exit(1)
+    }
+    opts.mode = mode
+  } else
+    dirs.push(arg)
 }
 
-var paths = argv._.slice();
+const mkdirp = require('../')
-var mode = argv.mode ? parseInt(argv.mode, 8) : undefined;
+const impl = manual ? mkdirp.manual : mkdirp
+if (dirs.length === 0)
+  console.error(usage())
 
-(function next () {
+Promise.all(dirs.map(dir => impl(dir, opts)))
-    if (paths.length === 0) return;
+  .then(made => print ? made.forEach(m => m && console.log(m)) : null)
-    var p = paths.shift();
+  .catch(er => {
-    
+    console.error(er.message)
-    if (mode === undefined) mkdirp(p, cb)
+    if (er.code)
-    else mkdirp(p, mode, cb)
+      console.error('  code: ' + er.code)
-    
+    process.exit(1)
-    function cb (err) {
+  })
-        if (err) {
-            console.error(err.message);
-            process.exit(1);
-        }
-        else next();
-    }
-})();

node_modules/mkdirp/bin/usage.txt

@@ -1,12 +0,0 @@
-usage: mkdirp [DIR1,DIR2..] {OPTIONS}
-
-  Create each supplied directory including any necessary parent directories that
-  don't yet exist.
-  
-  If the directory already exists, do nothing.
-
-OPTIONS are:
-
-  -m, --mode   If a directory needs to be created, set the mode as an octal
-               permission string.
-

node_modules/mkdirp/index.js

@@ -1,99 +1,31 @@
-var path = require('path');
+const optsArg = require('./lib/opts-arg.js')
-var fs = require('fs');
+const pathArg = require('./lib/path-arg.js')
-var _0777 = parseInt('0777', 8);
 
-module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
+const {mkdirpNative, mkdirpNativeSync} = require('./lib/mkdirp-native.js')
+const {mkdirpManual, mkdirpManualSync} = require('./lib/mkdirp-manual.js')
+const {useNative, useNativeSync} = require('./lib/use-native.js')
 
-function mkdirP (p, opts, f, made) {
-    if (typeof opts === 'function') {
-        f = opts;
-        opts = {};
-    }
-    else if (!opts || typeof opts !== 'object') {
-        opts = { mode: opts };
-    }
-    
-    var mode = opts.mode;
-    var xfs = opts.fs || fs;
-    
-    if (mode === undefined) {
-        mode = _0777
-    }
-    if (!made) made = null;
-    
-    var cb = f || function () {};
-    p = path.resolve(p);
-    
-    xfs.mkdir(p, mode, function (er) {
-        if (!er) {
-            made = made || p;
-            return cb(null, made);
-        }
-        switch (er.code) {
-            case 'ENOENT':
-                if (path.dirname(p) === p) return cb(er);
-                mkdirP(path.dirname(p), opts, function (er, made) {
-                    if (er) cb(er, made);
-                    else mkdirP(p, opts, cb, made);
-                });
-                break;
 
-            // In the case of any other error, just see if there's a dir
+const mkdirp = (path, opts) => {
-            // there already.  If so, then hooray!  If not, then something
+  path = pathArg(path)
-            // is borked.
+  opts = optsArg(opts)
-            default:
+  return useNative(opts)
-                xfs.stat(p, function (er2, stat) {
+    ? mkdirpNative(path, opts)
-                    // if the stat fails, then that's super weird.
+    : mkdirpManual(path, opts)
-                    // let the original error be the failure reason.
-                    if (er2 || !stat.isDirectory()) cb(er, made)
-                    else cb(null, made);
-                });
-                break;
-        }
-    });
 }
 
-mkdirP.sync = function sync (p, opts, made) {
+const mkdirpSync = (path, opts) => {
-    if (!opts || typeof opts !== 'object') {
+  path = pathArg(path)
-        opts = { mode: opts };
+  opts = optsArg(opts)
-    }
+  return useNativeSync(opts)
-    
+    ? mkdirpNativeSync(path, opts)
-    var mode = opts.mode;
+    : mkdirpManualSync(path, opts)
-    var xfs = opts.fs || fs;
+}
-    
-    if (mode === undefined) {
-        mode = _0777
-    }
-    if (!made) made = null;
 
-    p = path.resolve(p);
+mkdirp.sync = mkdirpSync
+mkdirp.native = (path, opts) => mkdirpNative(pathArg(path), optsArg(opts))
+mkdirp.manual = (path, opts) => mkdirpManual(pathArg(path), optsArg(opts))
+mkdirp.nativeSync = (path, opts) => mkdirpNativeSync(pathArg(path), optsArg(opts))
+mkdirp.manualSync = (path, opts) => mkdirpManualSync(pathArg(path), optsArg(opts))
 
-    try {
+module.exports = mkdirp
-        xfs.mkdirSync(p, mode);
-        made = made || p;
-    }
-    catch (err0) {
-        switch (err0.code) {
-            case 'ENOENT' :
-                made = sync(path.dirname(p), opts, made);
-                sync(p, opts, made);
-                break;
-
-            // In the case of any other error, just see if there's a dir
-            // there already.  If so, then hooray!  If not, then something
-            // is borked.
-            default:
-                var stat;
-                try {
-                    stat = xfs.statSync(p);
-                }
-                catch (err1) {
-                    throw err0;
-                }
-                if (!stat.isDirectory()) throw err0;
-                break;
-        }
-    }
-
-    return made;
-};

node_modules/mkdirp/lib/find-made.js

@@ -0,0 +1,29 @@
+const {dirname} = require('path')
+
+const findMade = (opts, parent, path = undefined) => {
+  // we never want the 'made' return value to be a root directory
+  if (path === parent)
+    return Promise.resolve()
+
+  return opts.statAsync(parent).then(
+    st => st.isDirectory() ? path : undefined, // will fail later
+    er => er.code === 'ENOENT'
+      ? findMade(opts, dirname(parent), parent)
+      : undefined
+  )
+}
+
+const findMadeSync = (opts, parent, path = undefined) => {
+  if (path === parent)
+    return undefined
+
+  try {
+    return opts.statSync(parent).isDirectory() ? path : undefined
+  } catch (er) {
+    return er.code === 'ENOENT'
+      ? findMadeSync(opts, dirname(parent), parent)
+      : undefined
+  }
+}
+
+module.exports = {findMade, findMadeSync}

node_modules/mkdirp/lib/mkdirp-manual.js

@@ -0,0 +1,64 @@
+const {dirname} = require('path')
+
+const mkdirpManual = (path, opts, made) => {
+  opts.recursive = false
+  const parent = dirname(path)
+  if (parent === path) {
+    return opts.mkdirAsync(path, opts).catch(er => {
+      // swallowed by recursive implementation on posix systems
+      // any other error is a failure
+      if (er.code !== 'EISDIR')
+        throw er
+    })
+  }
+
+  return opts.mkdirAsync(path, opts).then(() => made || path, er => {
+    if (er.code === 'ENOENT')
+      return mkdirpManual(parent, opts)
+        .then(made => mkdirpManual(path, opts, made))
+    if (er.code !== 'EEXIST' && er.code !== 'EROFS')
+      throw er
+    return opts.statAsync(path).then(st => {
+      if (st.isDirectory())
+        return made
+      else
+        throw er
+    }, () => { throw er })
+  })
+}
+
+const mkdirpManualSync = (path, opts, made) => {
+  const parent = dirname(path)
+  opts.recursive = false
+
+  if (parent === path) {
+    try {
+      return opts.mkdirSync(path, opts)
+    } catch (er) {
+      // swallowed by recursive implementation on posix systems
+      // any other error is a failure
+      if (er.code !== 'EISDIR')
+        throw er
+      else
+        return
+    }
+  }
+
+  try {
+    opts.mkdirSync(path, opts)
+    return made || path
+  } catch (er) {
+    if (er.code === 'ENOENT')
+      return mkdirpManualSync(path, opts, mkdirpManualSync(parent, opts, made))
+    if (er.code !== 'EEXIST' && er.code !== 'EROFS')
+      throw er
+    try {
+      if (!opts.statSync(path).isDirectory())
+        throw er
+    } catch (_) {
+      throw er
+    }
+  }
+}
+
+module.exports = {mkdirpManual, mkdirpManualSync}

node_modules/mkdirp/lib/mkdirp-native.js

@@ -0,0 +1,39 @@
+const {dirname} = require('path')
+const {findMade, findMadeSync} = require('./find-made.js')
+const {mkdirpManual, mkdirpManualSync} = require('./mkdirp-manual.js')
+
+const mkdirpNative = (path, opts) => {
+  opts.recursive = true
+  const parent = dirname(path)
+  if (parent === path)
+    return opts.mkdirAsync(path, opts)
+
+  return findMade(opts, path).then(made =>
+    opts.mkdirAsync(path, opts).then(() => made)
+    .catch(er => {
+      if (er.code === 'ENOENT')
+        return mkdirpManual(path, opts)
+      else
+        throw er
+    }))
+}
+
+const mkdirpNativeSync = (path, opts) => {
+  opts.recursive = true
+  const parent = dirname(path)
+  if (parent === path)
+    return opts.mkdirSync(path, opts)
+
+  const made = findMadeSync(opts, path)
+  try {
+    opts.mkdirSync(path, opts)
+    return made
+  } catch (er) {
+    if (er.code === 'ENOENT')
+      return mkdirpManualSync(path, opts)
+    else
+      throw er
+  }
+}
+
+module.exports = {mkdirpNative, mkdirpNativeSync}

node_modules/mkdirp/lib/opts-arg.js

@@ -0,0 +1,23 @@
+const { promisify } = require('util')
+const fs = require('fs')
+const optsArg = opts => {
+  if (!opts)
+    opts = { mode: 0o777, fs }
+  else if (typeof opts === 'object')
+    opts = { mode: 0o777, fs, ...opts }
+  else if (typeof opts === 'number')
+    opts = { mode: opts, fs }
+  else if (typeof opts === 'string')
+    opts = { mode: parseInt(opts, 8), fs }
+  else
+    throw new TypeError('invalid options argument')
+
+  opts.mkdir = opts.mkdir || opts.fs.mkdir || fs.mkdir
+  opts.mkdirAsync = promisify(opts.mkdir)
+  opts.stat = opts.stat || opts.fs.stat || fs.stat
+  opts.statAsync = promisify(opts.stat)
+  opts.statSync = opts.statSync || opts.fs.statSync || fs.statSync
+  opts.mkdirSync = opts.mkdirSync || opts.fs.mkdirSync || fs.mkdirSync
+  return opts
+}
+module.exports = optsArg

node_modules/mkdirp/lib/path-arg.js

@@ -0,0 +1,29 @@
+const platform = process.env.__TESTING_MKDIRP_PLATFORM__ || process.platform
+const { resolve, parse } = require('path')
+const pathArg = path => {
+  if (/\0/.test(path)) {
+    // simulate same failure that node raises
+    throw Object.assign(
+      new TypeError('path must be a string without null bytes'),
+      {
+        path,
+        code: 'ERR_INVALID_ARG_VALUE',
+      }
+    )
+  }
+
+  path = resolve(path)
+  if (platform === 'win32') {
+    const badWinChars = /[*|"<>?:]/
+    const {root} = parse(path)
+    if (badWinChars.test(path.substr(root.length))) {
+      throw Object.assign(new Error('Illegal characters in path.'), {
+        path,
+        code: 'EINVAL',
+      })
+    }
+  }
+
+  return path
+}
+module.exports = pathArg

node_modules/mkdirp/lib/use-native.js

@@ -0,0 +1,10 @@
+const fs = require('fs')
+
+const version = process.env.__TESTING_MKDIRP_NODE_VERSION__ || process.version
+const versArr = version.replace(/^v/, '').split('.')
+const hasNative = +versArr[0] > 10 || +versArr[0] === 10 && +versArr[1] >= 12
+
+const useNative = !hasNative ? () => false : opts => opts.mkdir === fs.mkdir
+const useNativeSync = !hasNative ? () => false : opts => opts.mkdirSync === fs.mkdirSync
+
+module.exports = {useNative, useNativeSync}

node_modules/mkdirp/package.json

@@ -1,34 +1,44 @@
 {
   "name": "mkdirp",
   "description": "Recursively mkdir, like `mkdir -p`",
-  "version": "0.5.5",
+  "version": "1.0.4",
-  "publishConfig": {
-    "tag": "legacy"
-  },
-  "author": "James Halliday <mail@substack.net> (http://substack.net)",
   "main": "index.js",
   "keywords": [
     "mkdir",
-    "directory"
+    "directory",
+    "make dir",
+    "make",
+    "dir",
+    "recursive",
+    "native"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/substack/node-mkdirp.git"
+    "url": "https://github.com/isaacs/node-mkdirp.git"
   },
   "scripts": {
-    "test": "tap test/*.js"
+    "test": "tap",
+    "snap": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --follow-tags"
   },
-  "dependencies": {
+  "tap": {
-    "minimist": "^1.2.5"
+    "check-coverage": true,
+    "coverage-map": "map.js"
   },
   "devDependencies": {
-    "mock-fs": "^3.7.0",
+    "require-inject": "^1.4.4",
-    "tap": "^5.4.2"
+    "tap": "^14.10.7"
   },
   "bin": "bin/cmd.js",
   "license": "MIT",
+  "engines": {
+    "node": ">=10"
+  },
   "files": [
     "bin",
+    "lib",
     "index.js"
   ]
 }

node_modules/mkdirp/readme.markdown

@@ -1,26 +1,37 @@
 # mkdirp
 
-Like `mkdir -p`, but in node.js!
+Like `mkdir -p`, but in Node.js!
 
-[![build status](https://secure.travis-ci.org/substack/node-mkdirp.png)](http://travis-ci.org/substack/node-mkdirp)
+Now with a modern API and no\* bugs!
+
+<small>\* may contain some bugs</small>
 
 # example
 
 ## pow.js
 
 ```js
-var mkdirp = require('mkdirp');
+const mkdirp = require('mkdirp')
-    
+
-mkdirp('/tmp/foo/bar/baz', function (err) {
+// return value is a Promise resolving to the first directory created
-    if (err) console.error(err)
+mkdirp('/tmp/foo/bar/baz').then(made =>
-    else console.log('pow!')
+  console.log(`made directories, starting with ${made}`))
-});
 ```
 
-Output
+Output (where `/tmp/foo` already exists)
 
 ```
-pow!
+made directories, starting with /tmp/foo/bar
+```
+
+Or, if you don't have time to wait around for promises:
+
+```js
+const mkdirp = require('mkdirp')
+
+// return value is the first directory created
+const made = mkdirp.sync('/tmp/foo/bar/baz')
+console.log(`made directories, starting with ${made}`)
 ```
 
 And now /tmp/foo/bar/baz exists, huzzah!
@@ -28,55 +39,198 @@ And now /tmp/foo/bar/baz exists, huzzah!
 # methods
 
 ```js
-var mkdirp = require('mkdirp');
+const mkdirp = require('mkdirp')
 ```
 
-## mkdirp(dir, opts, cb)
+## mkdirp(dir, [opts]) -> Promise<String | undefined>
 
 Create a new directory and any necessary subdirectories at `dir` with octal
-permission string `opts.mode`. If `opts` is a non-object, it will be treated as
+permission string `opts.mode`. If `opts` is a string or number, it will be
-the `opts.mode`.
-
-If `opts.mode` isn't specified, it defaults to `0777`.
-
-`cb(err, made)` fires with the error or the first directory `made`
-that had to be created, if any.
-
-You can optionally pass in an alternate `fs` implementation by passing in
-`opts.fs`. Your implementation should have `opts.fs.mkdir(path, mode, cb)` and
-`opts.fs.stat(path, cb)`.
-
-## mkdirp.sync(dir, opts)
-
-Synchronously create a new directory and any necessary subdirectories at `dir`
-with octal permission string `opts.mode`. If `opts` is a non-object, it will be
 treated as the `opts.mode`.
 
-If `opts.mode` isn't specified, it defaults to `0777`.
+If `opts.mode` isn't specified, it defaults to `0o777 &
+(~process.umask())`.
 
-Returns the first directory that had to be created, if any.
+Promise resolves to first directory `made` that had to be created, or
+`undefined` if everything already exists.  Promise rejects if any errors
+are encountered.  Note that, in the case of promise rejection, some
+directories _may_ have been created, as recursive directory creation is not
+an atomic operation.
 
 You can optionally pass in an alternate `fs` implementation by passing in
-`opts.fs`. Your implementation should have `opts.fs.mkdirSync(path, mode)` and
+`opts.fs`. Your implementation should have `opts.fs.mkdir(path, opts, cb)`
-`opts.fs.statSync(path)`.
+and `opts.fs.stat(path, cb)`.
 
-# usage
+You can also override just one or the other of `mkdir` and `stat` by
+passing in `opts.stat` or `opts.mkdir`, or providing an `fs` option that
+only overrides one of these.
+
+## mkdirp.sync(dir, opts) -> String|null
+
+Synchronously create a new directory and any necessary subdirectories at
+`dir` with octal permission string `opts.mode`. If `opts` is a string or
+number, it will be treated as the `opts.mode`.
+
+If `opts.mode` isn't specified, it defaults to `0o777 &
+(~process.umask())`.
+
+Returns the first directory that had to be created, or undefined if
+everything already exists.
+
+You can optionally pass in an alternate `fs` implementation by passing in
+`opts.fs`. Your implementation should have `opts.fs.mkdirSync(path, mode)`
+and `opts.fs.statSync(path)`.
+
+You can also override just one or the other of `mkdirSync` and `statSync`
+by passing in `opts.statSync` or `opts.mkdirSync`, or providing an `fs`
+option that only overrides one of these.
+
+## mkdirp.manual, mkdirp.manualSync
+
+Use the manual implementation (not the native one).  This is the default
+when the native implementation is not available or the stat/mkdir
+implementation is overridden.
+
+## mkdirp.native, mkdirp.nativeSync
+
+Use the native implementation (not the manual one).  This is the default
+when the native implementation is available and stat/mkdir are not
+overridden.
+
+# implementation
+
+On Node.js v10.12.0 and above, use the native `fs.mkdir(p,
+{recursive:true})` option, unless `fs.mkdir`/`fs.mkdirSync` has been
+overridden by an option.
+
+## native implementation
+
+- If the path is a root directory, then pass it to the underlying
+  implementation and return the result/error.  (In this case, it'll either
+  succeed or fail, but we aren't actually creating any dirs.)
+- Walk up the path statting each directory, to find the first path that
+  will be created, `made`.
+- Call `fs.mkdir(path, { recursive: true })` (or `fs.mkdirSync`)
+- If error, raise it to the caller.
+- Return `made`.
+
+## manual implementation
+
+- Call underlying `fs.mkdir` implementation, with `recursive: false`
+- If error:
+  - If path is a root directory, raise to the caller and do not handle it
+  - If ENOENT, mkdirp parent dir, store result as `made`
+  - stat(path)
+    - If error, raise original `mkdir` error
+    - If directory, return `made`
+    - Else, raise original `mkdir` error
+- else
+  - return `undefined` if a root dir, or `made` if set, or `path`
+
+## windows vs unix caveat
+
+On Windows file systems, attempts to create a root directory (ie, a drive
+letter or root UNC path) will fail.  If the root directory exists, then it
+will fail with `EPERM`.  If the root directory does not exist, then it will
+fail with `ENOENT`.
+
+On posix file systems, attempts to create a root directory (in recursive
+mode) will succeed silently, as it is treated like just another directory
+that already exists.  (In non-recursive mode, of course, it fails with
+`EEXIST`.)
+
+In order to preserve this system-specific behavior (and because it's not as
+if we can create the parent of a root directory anyway), attempts to create
+a root directory are passed directly to the `fs` implementation, and any
+errors encountered are not handled.
+
+## native error caveat
+
+The native implementation (as of at least Node.js v13.4.0) does not provide
+appropriate errors in some cases (see
+[nodejs/node#31481](https://github.com/nodejs/node/issues/31481) and
+[nodejs/node#28015](https://github.com/nodejs/node/issues/28015)).
+
+In order to work around this issue, the native implementation will fall
+back to the manual implementation if an `ENOENT` error is encountered.
+
+# choosing a recursive mkdir implementation
+
+There are a few to choose from!  Use the one that suits your needs best :D
+
+## use `fs.mkdir(path, {recursive: true}, cb)` if:
+
+- You wish to optimize performance even at the expense of other factors.
+- You don't need to know the first dir created.
+- You are ok with getting `ENOENT` as the error when some other problem is
+  the actual cause.
+- You can limit your platforms to Node.js v10.12 and above.
+- You're ok with using callbacks instead of promises.
+- You don't need/want a CLI.
+- You don't need to override the `fs` methods in use.
+
+## use this module (mkdirp 1.x) if:
+
+- You need to know the first directory that was created.
+- You wish to use the native implementation if available, but fall back
+  when it's not.
+- You prefer promise-returning APIs to callback-taking APIs.
+- You want more useful error messages than the native recursive mkdir
+  provides (at least as of Node.js v13.4), and are ok with re-trying on
+  `ENOENT` to achieve this.
+- You need (or at least, are ok with) a CLI.
+- You need to override the `fs` methods in use.
+
+## use [`make-dir`](http://npm.im/make-dir) if:
+
+- You do not need to know the first dir created (and wish to save a few
+  `stat` calls when using the native implementation for this reason).
+- You wish to use the native implementation if available, but fall back
+  when it's not.
+- You prefer promise-returning APIs to callback-taking APIs.
+- You are ok with occasionally getting `ENOENT` errors for failures that
+  are actually related to something other than a missing file system entry.
+- You don't need/want a CLI.
+- You need to override the `fs` methods in use.
+
+## use mkdirp 0.x if:
+
+- You need to know the first directory that was created.
+- You need (or at least, are ok with) a CLI.
+- You need to override the `fs` methods in use.
+- You're ok with using callbacks instead of promises.
+- You are not running on Windows, where the root-level ENOENT errors can
+  lead to infinite regress.
+- You think vinyl just sounds warmer and richer for some weird reason.
+- You are supporting truly ancient Node.js versions, before even the advent
+  of a `Promise` language primitive.  (Please don't.  You deserve better.)
+
+# cli
 
 This package also ships with a `mkdirp` command.
 
 ```
+$ mkdirp -h
+
 usage: mkdirp [DIR1,DIR2..] {OPTIONS}
 
-  Create each supplied directory including any necessary parent directories that
+  Create each supplied directory including any necessary parent directories
-  don't yet exist.
+  that don't yet exist.
-  
+
   If the directory already exists, do nothing.
 
 OPTIONS are:
 
-  -m, --mode   If a directory needs to be created, set the mode as an octal
+  -m<mode>       If a directory needs to be created, set the mode as an octal
-               permission string.
+  --mode=<mode>  permission string.
 
+  -v --version   Print the mkdirp version number
+
+  -h --help      Print this helpful banner
+
+  -p --print     Print the first directories created for each path provided
+
+  --manual       Use manual implementation, even if native is available
 ```
 
 # install
@@ -87,13 +241,25 @@ With [npm](http://npmjs.org) do:
 npm install mkdirp
 ```
 
-to get the library, or
+to get the library locally, or
 
 ```
 npm install -g mkdirp
 ```
 
-to get the command.
+to get the command everywhere, or
+
+```
+npx mkdirp ...
+```
+
+to run the command without installing it globally.
+
+# platform support
+
+This module works on node v8, but only v10 and above are officially
+supported, as Node v8 reached its LTS end of life 2020-01-01, which is in
+the past, as of this writing.
 
 # license
 

node_modules/ts-jest/.ts-jest-digest

@@ -1 +1 @@
-d9672057404fee19f80db714ea000c61a1375776
+23a45c3c610603c5fb7b5956ee7a94657fb32b21

node_modules/ts-jest/CHANGELOG.md

@@ -1,3 +1,274 @@
+## [26.5.6](https://github.com/kulshekhar/ts-jest/compare/v26.5.5...v26.5.6) (2021-05-05)
+
+
+### Code Refactoring
+
+* refactor(config): show warning message for `sourceMap: false` ([#2557](https://github.com/kulshekhar/ts-jest/pull/2557)) ([cf60990](https://github.com/kulshekhar/ts-jest/commit/cf609900e2c5937755123bd08ca2c5f2ff5e0651)).
+
+
+
+## [26.5.5](https://github.com/kulshekhar/ts-jest/compare/v26.5.4...v26.5.5) (2021-04-15)
+
+
+### Bug Fixes
+
+* **compiler:** return file content on emitSkipped for non ts/tsx files ([#2515](https://github.com/kulshekhar/ts-jest/issues/2515)) ([0320fb3](https://github.com/kulshekhar/ts-jest/commit/0320fb3ac22056aafe4d7ae966eab84dbf23fda9)), closes [#2513](https://github.com/kulshekhar/ts-jest/issues/2513)
+
+
+
+## [26.5.4](https://github.com/kulshekhar/ts-jest/compare/v26.5.3...v26.5.4) (2021-03-17)
+
+
+### Bug Fixes
+
+* **compiler:** initialize compiler with `.ts`/`.tsx`/`.d.ts` files only ([#2457](https://github.com/kulshekhar/ts-jest/issues/2457)) ([1dc731a](https://github.com/kulshekhar/ts-jest/commit/1dc731a5faf7cda59db1cc642eb99fae973b1246)), closes [#2445](https://github.com/kulshekhar/ts-jest/issues/2445)
+
+
+
+## [26.5.3](https://github.com/kulshekhar/ts-jest/compare/v26.5.2...v26.5.3) (2021-03-03)
+
+
+### Bug Fixes
+
+* **config:** create fallback jest config when jest config is undefined ([#2421](https://github.com/kulshekhar/ts-jest/issues/2421)) ([0fb6b45](https://github.com/kulshekhar/ts-jest/commit/0fb6b45e7dc3dd7588d27f09ac9a8849dff470cb)), closes [#2085](https://github.com/kulshekhar/ts-jest/issues/2085)
+* remove `@types/jest` from direct dep ([#2416](https://github.com/kulshekhar/ts-jest/issues/2416)) ([060302e](https://github.com/kulshekhar/ts-jest/commit/060302ed1eb8708df0acd7ab1d613ff06fc08cf3)), closes [#2406](https://github.com/kulshekhar/ts-jest/issues/2406) [#2411](https://github.com/kulshekhar/ts-jest/issues/2411)
+* **compiler:** return original file content on emit skip ([#2408](https://github.com/kulshekhar/ts-jest/issues/2408)) ([cfba8f4](https://github.com/kulshekhar/ts-jest/commit/cfba8f423dd59536d8b1e1374ef2b20bff2ed857)), closes [#2407](https://github.com/kulshekhar/ts-jest/issues/2407)
+
+
+
+## [26.5.2](https://github.com/kulshekhar/ts-jest/compare/v26.5.1...v26.5.2) (2021-02-21)
+
+
+### Bug Fixes
+
+* **compiler:** exclude files in `outDir` from compiler source files ([#2376](https://github.com/kulshekhar/ts-jest/issues/2376)) ([9034677](https://github.com/kulshekhar/ts-jest/commit/9034677f9ce0968339d3d942a70e888996fac532)), closes [#2350](https://github.com/kulshekhar/ts-jest/issues/2350) [#2374](https://github.com/kulshekhar/ts-jest/issues/2374)
+* **config:** define `matchTestFilePath` before `setupTsJestCfg` ([#2373](https://github.com/kulshekhar/ts-jest/issues/2373)) ([c427fea](https://github.com/kulshekhar/ts-jest/commit/c427fea48a24b5ce6e8b9260d3c322583b062a77)), closes [#2371](https://github.com/kulshekhar/ts-jest/issues/2371)
+* **config:** improve emit skipped error message and ensure `outDir` always `TS_JEST_OUT_DIR` ([#2357](https://github.com/kulshekhar/ts-jest/issues/2357)) ([f2808bb](https://github.com/kulshekhar/ts-jest/commit/f2808bb0b15231c67ccb9a97ed606741213c03e6))
+* **typings:** set correct typing for `tsconfig`/`tsConfig` option ([#2377](https://github.com/kulshekhar/ts-jest/issues/2377)) ([d4f6aff](https://github.com/kulshekhar/ts-jest/commit/d4f6aff3f181761bf25c64ff1a97dd19a69196f9)), closes [#2368](https://github.com/kulshekhar/ts-jest/issues/2368)
+
+
+
+## [26.5.1](https://github.com/kulshekhar/ts-jest/compare/v26.5.0...v26.5.1) (2021-02-09)
+
+
+### Features
+
+* **config:** support typed config options for jest config typescript ([#2336](https://github.com/kulshekhar/ts-jest/issues/2336)) ([f4f5d32](https://github.com/kulshekhar/ts-jest/commit/f4f5d3205d1c80e545a32c02c6a66e7e91386f7f))
+* **presets:** add typing for `presets` entry point ([#2341](https://github.com/kulshekhar/ts-jest/issues/2341)) ([e12b004](https://github.com/kulshekhar/ts-jest/commit/e12b004dcc5848d5ae0638e885147c54e11cc72b)), closes [#2325](https://github.com/kulshekhar/ts-jest/issues/2325)
+
+
+
+# [26.5.0](https://github.com/kulshekhar/ts-jest/compare/v26.5.0...v26.4.4) (2021-01-29)
+
+
+### Bug Fixes
+
+* reduce size of `node_modules` when adding `ts-jest` ([#2309](https://github.com/kulshekhar/ts-jest/issues/2309)) ([6bf2e8a](https://github.com/kulshekhar/ts-jest/commit/b8d5d2090567f23947d9efd87f5f869b16bf2e8a))
+
+
+### Features
+
+* introduce `exclude` to exclude files from diagnostics ([#2308](https://github.com/kulshekhar/ts-jest/issues/2308)) ([cd82fd3](https://github.com/kulshekhar/ts-jest/commit/0c555c250774a7fd9e356cf20a3d8b693cd82fd3))
+
+
+### DEPRECATIONS
+
+* **config**: deprecate `pathRegex` in favor of `exclude` ([#2308](https://github.com/kulshekhar/ts-jest/issues/2308)) ([cd82fd3](https://github.com/kulshekhar/ts-jest/commit/0c555c250774a7fd9e356cf20a3d8b693cd82fd3))
+
+
+
+## [26.4.4](https://github.com/kulshekhar/ts-jest/compare/v26.4.3...v26.4.4) (2020-11-08)
+
+
+### Bug Fixes
+
+* revert usage of `@jest/create-cache-key-function` ([#2108](https://github.com/kulshekhar/ts-jest/issues/2108)) ([dee8231](https://github.com/kulshekhar/ts-jest/commit/dee823172ce1e8eb9e0b2dd3aeed1ab4033bd0d9)), closes [#2080](https://github.com/kulshekhar/ts-jest/issues/2080) [#2090](https://github.com/kulshekhar/ts-jest/issues/2090) [#2104](https://github.com/kulshekhar/ts-jest/issues/2104)
+
+
+### Features
+
+* **testing:** expose all types for util `mocked` ([#2096](https://github.com/kulshekhar/ts-jest/issues/2096)) ([b1d072b](https://github.com/kulshekhar/ts-jest/commit/b1d072b52b9a7665b3a6914b0895f84f6ee3f8c0)), closes [#2086](https://github.com/kulshekhar/ts-jest/issues/2086)
+
+
+
+## [26.4.3](https://github.com/kulshekhar/ts-jest/compare/v26.4.2...v26.4.3) (2020-10-26)
+
+
+### Bug Fixes
+
+* **compiler:** only exclude test files when initializing compiler ([#2062](https://github.com/kulshekhar/ts-jest/issues/2062)) ([7264c13](https://github.com/kulshekhar/ts-jest/commit/7264c137114b6dd895624e3476dd7ec57b64ee13)), closes [#2061](https://github.com/kulshekhar/ts-jest/issues/2061), [#2068](https://github.com/kulshekhar/ts-jest/issues/2068), [#2072](https://github.com/kulshekhar/ts-jest/issues/2072), [#2073](https://github.com/kulshekhar/ts-jest/issues/2073)
+* **config:** resolve `.babelrc` file path before attempting to read it ([#2071](https://github.com/kulshekhar/ts-jest/issues/2071)) ([681bfef](https://github.com/kulshekhar/ts-jest/commit/681bfef41744f09cd50b71072f4d001cb58da82e)), closes [#2064](https://github.com/kulshekhar/ts-jest/issues/2064)
+
+
+### Features
+
+* **config:** allow to override resolve tsconfig behavior ([#2063](https://github.com/kulshekhar/ts-jest/issues/2063)) ([9f46ace](https://github.com/kulshekhar/ts-jest/commit/9f46acefceb1fa71ee2e8b3b3c172ceb0544b4c4))
+
+
+
+## [26.4.2](https://github.com/kulshekhar/ts-jest/compare/v26.4.1...v26.4.2) (2020-10-23)
+
+
+### Features
+
+* **config:** expose several typings as public apis ([#2054](https://github.com/kulshekhar/ts-jest/issues/2054)) ([3b6b705](https://github.com/kulshekhar/ts-jest/commit/3b6b7055e2b9c74e81fb91596c807ace02ab77a1))
+
+
+### Performance Improvements
+
+* **compiler:** speed up bootstrap time for `isolatedModules:false` ([#2055](https://github.com/kulshekhar/ts-jest/issues/2055)) ([230b5dd](https://github.com/kulshekhar/ts-jest/commit/230b5ddbee55357d25dd190cd45aa8a30d7f31e0))
+
+
+### DEPRECATIONS
+
+* **config**: deprecate `tsConfig` in favor of `tsconfig` ([#1997](https://github.com/kulshekhar/ts-jest/pull/1997))
+* **config**: deprecate `packageJson` since internal codes don't use it anymore ([#2034](https://github.com/kulshekhar/ts-jest/pull/2034))
+
+
+
+## [26.4.1](https://github.com/kulshekhar/ts-jest/compare/v26.4.0...v26.4.1) (2020-09-29)
+
+
+### Bug Fixes
+
+* **utils:** `MaybeMockedConstructor` returns T ([#1976](https://github.com/kulshekhar/ts-jest/issues/1976)) ([b7712b2](https://github.com/kulshekhar/ts-jest/commit/b7712b2055d8f32dd97999de1d94e8f3515d79e8))
+* **utils:** revert `path.join` and add check on prefix ends with `/` ([#1989](https://github.com/kulshekhar/ts-jest/issues/1989)) ([3d9035b](https://github.com/kulshekhar/ts-jest/commit/3d9035bd70dc087d4c5a943bb2fe2af2d0822875)), closes [#1982](https://github.com/kulshekhar/ts-jest/issues/1982)
+
+
+
+# [26.4.0](https://github.com/kulshekhar/ts-jest/compare/v26.3.0...v26.4.0) (2020-09-20)
+
+
+### Bug Fixes
+
+* **utils:** `pathsToModuleNameMapper` resolve path mapping with `path.join` ([#1969](https://github.com/kulshekhar/ts-jest/issues/1969)) ([81fce4c](https://github.com/kulshekhar/ts-jest/commit/81fce4c090811a1cc071579a99dc193fb976b117)), closes [#1968](https://github.com/kulshekhar/ts-jest/issues/1968)
+* set minimum `jest-util` version at 26.1.0 ([#1914](https://github.com/kulshekhar/ts-jest/issues/1914)) ([f00414c](https://github.com/kulshekhar/ts-jest/commit/f00414c6fbf8fc5413fd33d0a271c4a164c50d45)), closes [#1913](https://github.com/kulshekhar/ts-jest/issues/1913)
+
+
+### Features
+
+* **config:** allow custom options in custom transformers ([#1966](https://github.com/kulshekhar/ts-jest/issues/1966)) ([1452ce4](https://github.com/kulshekhar/ts-jest/commit/1452ce4afcd36049cddd0db0861f1ac26b66f8c1)), closes [#1942](https://github.com/kulshekhar/ts-jest/issues/1942)
+* **transformers:** support hoisting when using `@jest/globals` ([#1937](https://github.com/kulshekhar/ts-jest/issues/1937)) ([0e5be15](https://github.com/kulshekhar/ts-jest/commit/0e5be1597d755fed11869f67df05eeea54b3106f)), closes [#1593](https://github.com/kulshekhar/ts-jest/issues/1593)
+* **transformers:** add `path-mapping` custom AST transformer ([#1927](https://github.com/kulshekhar/ts-jest/issues/1927)) ([3325186](https://github.com/kulshekhar/ts-jest/commit/3325186b6e55f41eb9bf7d81e092a358fc402b13))
+
+
+### Performance Improvements
+
+* **compiler:** remove `createProgram` for `isolatedModules: true` to boost startup speed ([#1941](https://github.com/kulshekhar/ts-jest/issues/1941)) ([dd84534](https://github.com/kulshekhar/ts-jest/commit/dd8453401840862186f991e2d514e0d328a67987))
+
+
+
+# [26.3.0](https://github.com/kulshekhar/ts-jest/compare/v26.2.0...v26.3.0) (2020-08-25)
+
+
+### Bug Fixes
+
+* **config:** compute cache key without reading `package.json` ([#1893](https://github.com/kulshekhar/ts-jest/issues/1893)) ([4875a58](https://github.com/kulshekhar/ts-jest/commit/4875a58345666e0407f9f5b3f95049ae2c9d056d)), closes [#1892](https://github.com/kulshekhar/ts-jest/issues/1892)
+
+
+### Features
+
+* support TypeScript 4.0 ([#1889](https://github.com/kulshekhar/ts-jest/issues/1889)) ([f070e93](https://github.com/kulshekhar/ts-jest/commit/f070e9334a9cf31fa6f0d73b3f69d805be72601d))
+
+
+
+# [26.2.0](https://github.com/kulshekhar/ts-jest/compare/v26.1.4...v26.2.0) (2020-08-11)
+
+
+### Bug Fixes
+
+* move `@types/jest` to dependencies to work well with yarn 2 ([#1859](https://github.com/kulshekhar/ts-jest/issues/1859)) ([5eb1389](https://github.com/kulshekhar/ts-jest/commit/5eb1389caaa0431e49ae6ca26b18e290208e0a0a)), closes [#1857](https://github.com/kulshekhar/ts-jest/issues/1857)
+
+
+### Features
+
+* **config:** support `after` and `afterDeclarations` AST transformers ([#1831](https://github.com/kulshekhar/ts-jest/issues/1831)) ([be20a7c](https://github.com/kulshekhar/ts-jest/commit/be20a7c78c97027b33aec178da0f533095790871))
+* allow opt-out version warning message by environment variable `TS_JEST_DISABLE_VER_CHECKER` ([#1821](https://github.com/kulshekhar/ts-jest/issues/1821)) ([e6b42fc](https://github.com/kulshekhar/ts-jest/commit/e6b42fcd7a75c7b14e636a45cda04de18a46908b)), closes [#1774](https://github.com/kulshekhar/ts-jest/issues/1774)
+
+
+
+## [26.1.4](https://github.com/kulshekhar/ts-jest/compare/v26.1.3...v26.1.4) (2020-07-28)
+
+
+### Bug Fixes
+
+* **compiler:** check if test file exists before doing type check ([#1827](https://github.com/kulshekhar/ts-jest/issues/1827)) ([cc89d5b](https://github.com/kulshekhar/ts-jest/commit/cc89d5b1f912975cd29114c5b3b0bf18426816da)), closes [#1506](https://github.com/kulshekhar/ts-jest/issues/1506)
+
+
+
+## [26.1.3](https://github.com/kulshekhar/ts-jest/compare/v26.1.2...v26.1.3) (2020-07-16)
+
+
+### Bug Fixes
+
+* revert [#1793](https://github.com/kulshekhar/ts-jest/issues/1793) ([#1804](https://github.com/kulshekhar/ts-jest/issues/1804)) ([5095525](https://github.com/kulshekhar/ts-jest/commit/5095525333c8579c9c5e7f3149294b31f28d6774))
+
+
+
+## [26.1.2](https://github.com/kulshekhar/ts-jest/compare/v26.1.1...v26.1.2) (2020-07-13)
+
+
+### Bug Fixes
+
+* **compiler:** use `resolveModuleNames` TypeScript API to get resolved modules for test files ([#1784](https://github.com/kulshekhar/ts-jest/issues/1784)) ([5f26054](https://github.com/kulshekhar/ts-jest/commit/5f2605457e94b548bd7b9b28fc968554f7eefa91)), closes [#1747](https://github.com/kulshekhar/ts-jest/issues/1747)
+* **config:** invalidate cache when other options in `tsconfig` change ([#1788](https://github.com/kulshekhar/ts-jest/issues/1788)) ([6948855](https://github.com/kulshekhar/ts-jest/commit/69488552eca2846f3fc6ba86ab49d7893caaf521))
+
+
+### Performance Improvements
+
+* **compiler:** cache module resolution for `isolatedModules: false` ([#1786](https://github.com/kulshekhar/ts-jest/issues/1786)) ([7f731ed](https://github.com/kulshekhar/ts-jest/commit/7f731ed8a02755aeb41ecb27df4eaf16db2ddd95))
+* **compiler:** use `globsToMatcher` from `jest-util` ([#1754](https://github.com/kulshekhar/ts-jest/issues/1754)) ([44f3913](https://github.com/kulshekhar/ts-jest/commit/44f3913c2a017734ed87346b1c5fbec639d02062))
+
+
+
+<a name="26.1.1"></a>
+## [26.1.1](https://github.com/kulshekhar/ts-jest/compare/v26.1.0...v26.1.1) (2020-06-21)
+
+
+### Bug Fixes
+
+* **compiler:** generate source map correctly when tsconfig `mapRoot` is set ([#1741](https://github.com/kulshekhar/ts-jest/issues/1741)) ([01ac417](https://github.com/kulshekhar/ts-jest/commit/01ac417)), closes [#1718](https://github.com/kulshekhar/ts-jest/issues/1718)
+* **config:** show version warning when using ts-jest without babel ([#1729](https://github.com/kulshekhar/ts-jest/issues/1729)) ([e512bc0](https://github.com/kulshekhar/ts-jest/commit/e512bc0)), fixes [#1678-issuecomment-641930332](https://github.com//github.com/kulshekhar/ts-jest/pull/1678/issues/issuecomment-641930332), [#1678-issuecomment-639528993](https://github.com//github.com/kulshekhar/ts-jest/pull/1678/issues/issuecomment-639528993)
+
+
+
+<a name="26.1.0"></a>
+# [26.1.0](https://github.com/kulshekhar/ts-jest/compare/v26.0.0...v26.1.0) (2020-05-30)
+
+
+### Bug Fixes
+
+* **typing:** don't mark `BabelConfig` as internal type ([#1667](https://github.com/kulshekhar/ts-jest/issues/1667)) ([558c307](https://github.com/kulshekhar/ts-jest/commit/558c307)), closes [#1666](https://github.com/kulshekhar/ts-jest/issues/1666)
+
+
+### Features
+
+* **config:** show a warning message when TypeScript `target` version doesn't match with recommended NodeJs version ([#1678](https://github.com/kulshekhar/ts-jest/issues/1678)) ([085bdf5](https://github.com/kulshekhar/ts-jest/commit/085bdf5))
+* **config:** support multiple paths for `pathsToModuleNameMapper` ([#1690](https://github.com/kulshekhar/ts-jest/issues/1690)) ([a727bd5](https://github.com/kulshekhar/ts-jest/commit/a727bd5))
+* support TypeScript 3.9 ([#1653](https://github.com/kulshekhar/ts-jest/issues/1653)) ([fc3d5ad](https://github.com/kulshekhar/ts-jest/commit/fc3d5ad))
+
+
+
+<a name="26.0.0"></a>
+# [26.0.0](https://github.com/kulshekhar/ts-jest/compare/v25.5.1...v26.0.0) (2020-05-15)
+
+
+### Bug Fixes
+
+* **compiler:** return `undefined` for `getScriptVersion` when a file doesn't exist in memory cache ([#1641](https://github.com/kulshekhar/ts-jest/issues/1641)) ([6851b8e](https://github.com/kulshekhar/ts-jest/commit/6851b8e))
+
+
+### Features
+
+* support Jest v26 ([#1602](https://github.com/kulshekhar/ts-jest/issues/1602)) ([23b7741](https://github.com/kulshekhar/ts-jest/commit/23b7741))
+
+
+### BREAKING CHANGES
+
+* Requires a minimum of TypeScript v3.8
+* Drop support for Node 8 
+
+
 <a name="25.5.1"></a>
 ## [25.5.1](https://github.com/kulshekhar/ts-jest/compare/v25.5.0...v25.5.1) (2020-05-09)
 

node_modules/ts-jest/README.md

@@ -1,18 +1,19 @@
-# ts-jest
+<h1 align="center">ts-jest</h1>
 
-[![npm version](https://badge.fury.io/js/ts-jest.svg)](https://badge.fury.io/js/ts-jest)
+<p align="center">A TypeScript preprocessor with source map support for Jest that lets you use Jest to test projects written in TypeScript.</p>
-[![NPM downloads](https://img.shields.io/npm/dm/ts-jest.svg?style=flat)](https://npmjs.org/package/ts-jest)
+
-[![Known Vulnerabilities](https://snyk.io/test/github/kulshekhar/ts-jest/badge.svg)](https://snyk.io/test/github/kulshekhar/ts-jest)
+<p align="center">
-[![Coverage Status](https://coveralls.io/repos/github/kulshekhar/ts-jest/badge.svg?branch=master)](https://coveralls.io/github/kulshekhar/ts-jest?branch=master)
+  <a href="https://www.npmjs.com/package/ts-jest"><img src="https://img.shields.io/npm/v/ts-jest/latest.svg?style=flat-square" alt="NPM version" /> </a>
-[![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=kulshekhar/ts-jest)](https://dependabot.com)
+  <a href="https://www.npmjs.com/package/ts-jest"><img src="https://img.shields.io/npm/dm/ts-jest.svg?style=flat-square" alt="NPM downloads"/> </a>
-[![Build Status](https://travis-ci.com/kulshekhar/ts-jest.svg?branch=master)](https://travis-ci.com/kulshekhar/ts-jest)
+  <a href="https://snyk.io/test/github/kulshekhar/ts-jest"><img src="https://snyk.io/test/github/kulshekhar/ts-jest/badge.svg?style=flat-square" alt="Known vulnerabilities"/> </a>
-[![doc-generator](https://github.com/kulshekhar/ts-jest/workflows/doc-generator/badge.svg)](https://github.com/kulshekhar/ts-jest/actions)
+  <a href="https://coveralls.io/github/kulshekhar/ts-jest?branch=master"><img src="https://coveralls.io/repos/github/kulshekhar/ts-jest/badge.svg?branch=master" alt="Coverage status"/> </a>
-[![release-and-publish](https://github.com/kulshekhar/ts-jest/workflows/release-and-publish/badge.svg)](https://github.com/kulshekhar/ts-jest/actions)
+  <a href="https://travis-ci.com/kulshekhar/ts-jest"><img src="https://travis-ci.com/kulshekhar/ts-jest.svg?branch=master" alt="Build status"/> </a>
+  <a href="https://actions-badge.atrox.dev/kulshekhar/ts-jest/goto?ref=master"><img alt="GitHub actions" src="https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2Fkulshekhar%2Fts-jest%2Fbadge%3Fref%3Dmaster&style=flat-square" /> </a>
+  <a href="https://github.com/kulshekhar/ts-jest/blob/master/LICENSE"><img src="https://img.shields.io/npm/l/ts-jest.svg?style=flat-square" alt="GitHub license"/> </a>
+</p>
 
 <img src="./icon.png" align="right" title="ts-jest Logo" width="128" height="128">
 
-**`ts-jest`** is a TypeScript preprocessor with source map support for Jest that lets you use Jest to test projects written in TypeScript.
-
 It supports all features of TypeScript including type-checking. [Read more about Babel7 + `preset-typescript` **vs** TypeScript (and `ts-jest`)](https://kulshekhar.github.io/ts-jest/user/babel7-or-ts).
 
 ---

node_modules/ts-jest/dist/cli/config/init.js

@@ -47,14 +47,16 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.run = void 0;
 var fs_1 = require("fs");
 var json5_1 = require("json5");
 var path_1 = require("path");
 var presets_1 = require("../helpers/presets");
 exports.run = function (args) { return __awaiter(void 0, void 0, void 0, function () {
     var file, filePath, name, isPackage, exists, pkgFile, hasPackage, _a, jestPreset, askedTsconfig, force, jsdom, tsconfig, pkgJson, jsFilesProcessor, shouldPostProcessWithBabel, preset, body, base, tsJestConf, content;
-    return __generator(this, function (_b) {
+    var _b, _c;
-        file = args._[0] || 'jest.config.js';
+    return __generator(this, function (_d) {
+        file = (_c = (_b = args._[0]) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : 'jest.config.js';
         filePath = path_1.join(process.cwd(), file);
         name = path_1.basename(file);
         isPackage = name === 'package.json';

node_modules/ts-jest/dist/cli/config/migrate.js

@@ -56,18 +56,20 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.run = void 0;
 var bs_logger_1 = require("bs-logger");
 var stableStringify = require("fast-json-stable-stringify");
 var fs_1 = require("fs");
 var json5_1 = require("json5");
 var path_1 = require("path");
-var backports_1 = require("../../util/backports");
+var backports_1 = require("../../utils/backports");
 var presets_1 = require("../helpers/presets");
 exports.run = function (args) { return __awaiter(void 0, void 0, void 0, function () {
     var nullLogger, file, filePath, footNotes, name, isPackage, actualConfig, migratedConfig, presetName, preset, jsTransformers, jsWithTs, jsWithBabel, presetValue, migratedValue, presetValue, migratedValue, before, after, stringify, prefix;
-    return __generator(this, function (_a) {
+    var _a;
+    return __generator(this, function (_b) {
         nullLogger = bs_logger_1.createLogger({ targets: [] });
-        file = args._[0];
+        file = (_a = args._[0]) === null || _a === void 0 ? void 0 : _a.toString();
         filePath = path_1.resolve(process.cwd(), file);
         footNotes = [];
         if (!fs_1.existsSync(filePath)) {

node_modules/ts-jest/dist/cli/help.js

@@ -36,6 +36,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.run = void 0;
 exports.run = function (_) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         process.stdout.write("\nUsage:\n  ts-jest command [options] [...args]\n\nCommands:\n  config:init           Creates initial Jest configuration\n  config:migrate        Migrates a given Jest configuration\n  help [command]        Show this help, or help about a command\n\nExample:\n  ts-jest help config:migrate\n");

node_modules/ts-jest/dist/cli/helpers/presets.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsWIthBabel = exports.jsWithTs = exports.defaults = exports.allPresets = void 0;
 var definePreset = function (fullName) { return ({
     fullName: fullName,
     get name() {
@@ -11,10 +12,11 @@ var definePreset = function (fullName) { return ({
     get jsVarName() {
         return this.isDefault
             ? 'defaults'
-            : fullName
+            :
-                .split('/')
+                fullName
-                .pop()
+                    .split('/')
-                .replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
+                    .pop()
+                    .replace(/\-([a-z])/g, function (_, l) { return l.toUpperCase(); });
     },
     get value() {
         return require("../../../" + fullName.replace(/^ts-jest\//, '') + "/jest-preset");

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

@@ -35,18 +35,22 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.processArgv = void 0;
 var bs_logger_1 = require("bs-logger");
-var yargsParser = require("yargs-parser");
+var yargs_parser_1 = __importDefault(require("yargs-parser"));
-var logger_1 = require("../util/logger");
+var logger_1 = require("../utils/logger");
 var VALID_COMMANDS = ['help', 'config:migrate', 'config:init'];
 var logger = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'cli', _a[bs_logger_1.LogContexts.application] = 'ts-jest', _a));
 function cli(args) {
     return __awaiter(this, void 0, void 0, function () {
         var parsedArgv, command, isHelp, _a, run, help, cmd;
         return __generator(this, function (_b) {
-            parsedArgv = yargsParser(args, {
+            parsedArgv = yargs_parser_1.default(args, {
                 boolean: ['dry-run', 'jest-preset', 'allow-js', 'diff', 'babel', 'force', 'jsdom'],
                 string: ['tsconfig', 'js'],
                 count: ['verbose'],

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

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

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

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var fs_1 = require("fs");
-var micromatch = require("micromatch");
-var path_1 = require("path");
-var sha1_1 = require("../util/sha1");
-function getResolvedModulesCache(cacheDir) {
-    return path_1.join(cacheDir, sha1_1.sha1('ts-jest-resolved-modules', '\x00'));
-}
-exports.getResolvedModulesCache = getResolvedModulesCache;
-function cacheResolvedModules(fileName, fileContent, memoryCache, program, cacheDir, logger) {
-    var importReferences = program.getSourceFile(fileName).imports;
-    if (importReferences.length) {
-        logger.debug({ fileName: fileName }, 'cacheResolvedModules(): get resolved modules');
-        memoryCache.resolvedModules[fileName] = Object.create(null);
-        memoryCache.resolvedModules[fileName].modulePaths = importReferences
-            .filter(function (importReference) { var _a; return (_a = importReference.parent.parent.resolvedModules) === null || _a === void 0 ? void 0 : _a.get(importReference.text); })
-            .map(function (importReference) {
-            return path_1.normalize(importReference.parent.parent.resolvedModules.get(importReference.text)
-                .resolvedFileName);
-        })
-            .reduce(function (a, b) { return a.concat(b); }, []);
-        memoryCache.resolvedModules[fileName].testFileContent = fileContent;
-        fs_1.writeFileSync(getResolvedModulesCache(cacheDir), JSON.stringify(memoryCache.resolvedModules));
-    }
-}
-exports.cacheResolvedModules = cacheResolvedModules;
-function isTestFile(testMatchPatterns, fileName) {
-    return testMatchPatterns.some(function (pattern) {
-        return typeof pattern === 'string' ? micromatch.isMatch(fileName, pattern) : pattern.test(fileName);
-    });
-}
-exports.isTestFile = isTestFile;

node_modules/ts-jest/dist/compiler/instance.d.ts

@@ -1 +1,2 @@
-export {};
+export declare const SOURCE_MAPPING_PREFIX = "sourceMappingURL=";
+export declare function updateOutput(outputText: string, normalizedFileName: string, sourceMap: string): string;

node_modules/ts-jest/dist/compiler/instance.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -27,70 +16,40 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var fs_1 = require("fs");
+exports.createCompilerInstance = exports.updateOutput = exports.SOURCE_MAPPING_PREFIX = void 0;
-var mkdirp = require("mkdirp");
-var path_1 = require("path");
-var compiler_utils_1 = require("./compiler-utils");
 var language_service_1 = require("./language-service");
 var transpiler_1 = require("./transpiler");
-function updateOutput(outputText, normalizedFileName, sourceMap, getExtension) {
+var json_1 = require("../utils/json");
-    var base = path_1.basename(normalizedFileName);
+exports.SOURCE_MAPPING_PREFIX = 'sourceMappingURL=';
+function updateOutput(outputText, normalizedFileName, sourceMap) {
     var base64Map = Buffer.from(updateSourceMap(sourceMap, normalizedFileName), 'utf8').toString('base64');
     var sourceMapContent = "data:application/json;charset=utf-8;base64," + base64Map;
-    var sourceMapLength = (base + ".map").length + (getExtension(normalizedFileName).length - path_1.extname(normalizedFileName).length);
+    return (outputText.slice(0, outputText.lastIndexOf(exports.SOURCE_MAPPING_PREFIX) + exports.SOURCE_MAPPING_PREFIX.length) + sourceMapContent);
-    return outputText.slice(0, -sourceMapLength) + sourceMapContent;
 }
+exports.updateOutput = updateOutput;
 var updateSourceMap = function (sourceMapText, normalizedFileName) {
     var sourceMap = JSON.parse(sourceMapText);
     sourceMap.file = normalizedFileName;
     sourceMap.sources = [normalizedFileName];
     delete sourceMap.sourceRoot;
-    return JSON.stringify(sourceMap);
+    return json_1.stringify(sourceMap);
 };
-var compileAndCacheResult = function (memoryCache, compileFn, getExtension, logger) { return function (code, fileName, lineOffset) {
+var compileAndUpdateOutput = function (compileFn, logger) { return function (code, fileName, lineOffset) {
-    logger.debug({ fileName: fileName }, 'compileAndCacheResult(): get compile output');
+    logger.debug({ fileName: fileName }, 'compileAndUpdateOutput(): get compile output');
     var _a = __read(compileFn(code, fileName, lineOffset), 2), value = _a[0], sourceMap = _a[1];
-    var output = updateOutput(value, fileName, sourceMap, getExtension);
+    return updateOutput(value, fileName, sourceMap);
-    memoryCache.files.set(fileName, __assign(__assign({}, memoryCache.files.get(fileName)), { output: output }));
-    return output;
 }; };
 exports.createCompilerInstance = function (configs) {
     var logger = configs.logger.child({ namespace: 'ts-compiler' });
-    var compilerOptions = configs.parsedTsConfig.options, tsJest = configs.tsJest;
+    var compilerOptions = configs.parsedTsConfig.options;
-    var cacheDir = configs.tsCacheDir;
-    var ts = configs.compilerModule;
     var extensions = ['.ts', '.tsx'];
-    var memoryCache = {
-        files: new Map(),
-        resolvedModules: Object.create(null),
-    };
     if (compilerOptions.allowJs) {
         extensions.push('.js');
         extensions.push('.jsx');
     }
-    if (cacheDir) {
+    var compilerInstance = !configs.isolatedModules
-        mkdirp.sync(cacheDir);
+        ? language_service_1.initializeLanguageServiceInstance(configs, logger)
-        try {
+        : transpiler_1.initializeTranspilerInstance(configs, logger);
-            var fsMemoryCache = fs_1.readFileSync(compiler_utils_1.getResolvedModulesCache(cacheDir), 'utf-8');
+    var compile = compileAndUpdateOutput(compilerInstance.compileFn, logger);
-            memoryCache.resolvedModules = JSON.parse(fsMemoryCache);
-        }
-        catch (e) { }
-    }
-    configs.parsedTsConfig.fileNames.forEach(function (fileName) {
-        memoryCache.files.set(fileName, {
-            version: 0,
-        });
-    });
-    var getExtension = compilerOptions.jsx === ts.JsxEmit.Preserve
-        ? function (path) { return (/\.[tj]sx$/.test(path) ? '.jsx' : '.js'); }
-        : function (_) { return '.js'; };
-    var compilerInstance;
-    if (!tsJest.isolatedModules) {
-        compilerInstance = language_service_1.initializeLanguageServiceInstance(configs, memoryCache, logger);
-    }
-    else {
-        compilerInstance = transpiler_1.initializeTranspilerInstance(configs, memoryCache, logger);
-    }
-    var compile = compileAndCacheResult(memoryCache, compilerInstance.compileFn, getExtension, logger);
     return { cwd: configs.cwd, compile: compile, program: compilerInstance.program };
 };

node_modules/ts-jest/dist/compiler/language-service.js

@@ -1,4 +1,40 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -19,35 +55,100 @@ var __spread = (this && this.__spread) || function () {
     for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
     return ar;
 };
+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.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeLanguageServiceInstance = void 0;
 var bs_logger_1 = require("bs-logger");
+var fs_1 = require("fs");
 var path_1 = require("path");
+var memoize = require("lodash/memoize");
+var mkdirp = require("mkdirp");
 var constants_1 = require("../constants");
-var messages_1 = require("../util/messages");
+var messages_1 = require("../utils/messages");
-var compiler_utils_1 = require("./compiler-utils");
+var json_1 = require("../utils/json");
-var memoize = require("lodash.memoize");
+var sha1_1 = require("../utils/sha1");
-function doTypeChecking(configs, fileName, service, logger) {
+function doTypeChecking(configs, diagnosedFiles, fileName, service, logger) {
-    if (configs.shouldReportDiagnostic(fileName)) {
+    if (configs.shouldReportDiagnostics(fileName)) {
         var diagnostics = service.getSemanticDiagnostics(fileName).concat(service.getSyntacticDiagnostics(fileName));
+        diagnosedFiles.push(fileName);
         configs.raiseDiagnostics(diagnostics, fileName, logger);
     }
 }
-exports.initializeLanguageServiceInstance = function (configs, memoryCache, logger) {
+exports.initializeLanguageServiceInstance = function (configs, logger) {
     var _a;
     logger.debug('initializeLanguageServiceInstance(): create typescript compiler');
     var ts = configs.compilerModule;
     var cwd = configs.cwd;
     var cacheDir = configs.tsCacheDir;
     var _b = configs.parsedTsConfig, options = _b.options, fileNames = _b.fileNames;
+    var diagnosedFiles = [];
     var serviceHostTraceCtx = (_a = {
             namespace: 'ts:serviceHost',
             call: null
         },
         _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.trace,
         _a);
+    var memoryCache = {
+        files: new Map(),
+        resolvedModules: new Map(),
+    };
+    var tsResolvedModulesCachePath;
+    if (cacheDir) {
+        mkdirp.sync(cacheDir);
+        tsResolvedModulesCachePath = path_1.join(cacheDir, sha1_1.sha1('ts-jest-resolved-modules', '\x00'));
+        try {
+            var cachedTSResolvedModules = fs_1.readFileSync(tsResolvedModulesCachePath, 'utf-8');
+            memoryCache.resolvedModules = new Map(json_1.parse(cachedTSResolvedModules));
+        }
+        catch (e) { }
+    }
+    configs.parsedTsConfig.fileNames
+        .filter(function (fileName) { return constants_1.TS_TSX_REGEX.test(path_1.extname(fileName)) && !configs.isTestFile(fileName); })
+        .forEach(function (fileName) {
+        memoryCache.files.set(fileName, {
+            version: 0,
+        });
+    });
     function isFileInCache(fileName) {
         return memoryCache.files.has(fileName) && memoryCache.files.get(fileName).version !== 0;
     }
+    var cacheReadFile = logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile));
+    var moduleResolutionHost = {
+        fileExists: memoize(ts.sys.fileExists),
+        readFile: cacheReadFile,
+        directoryExists: memoize(ts.sys.directoryExists),
+        getCurrentDirectory: function () { return cwd; },
+        realpath: ts.sys.realpath && memoize(ts.sys.realpath),
+        getDirectories: memoize(ts.sys.getDirectories),
+    };
+    var moduleResolutionCache = ts.createModuleResolutionCache(cwd, function (x) { return x; }, options);
+    function resolveModuleNames(moduleNames, containingFile) {
+        var _a;
+        var normalizedContainingFile = path_1.normalize(containingFile);
+        var currentResolvedModules = (_a = memoryCache.resolvedModules.get(normalizedContainingFile)) !== null && _a !== void 0 ? _a : [];
+        return moduleNames.map(function (moduleName) {
+            var resolveModuleName = ts.resolveModuleName(moduleName, containingFile, options, moduleResolutionHost, moduleResolutionCache);
+            var resolvedModule = resolveModuleName.resolvedModule;
+            if (configs.isTestFile(normalizedContainingFile) && resolvedModule) {
+                var normalizedResolvedFileName = path_1.normalize(resolvedModule.resolvedFileName);
+                if (!currentResolvedModules.includes(normalizedResolvedFileName)) {
+                    currentResolvedModules.push(normalizedResolvedFileName);
+                    memoryCache.resolvedModules.set(normalizedContainingFile, currentResolvedModules);
+                }
+            }
+            return resolvedModule;
+        });
+    }
     var projectVersion = 1;
     var updateMemoryCache = function (contents, fileName) {
         logger.debug({ fileName: fileName }, 'updateMemoryCache(): update memory cache for language service');
@@ -81,18 +182,19 @@ exports.initializeLanguageServiceInstance = function (configs, memoryCache, logg
         getProjectVersion: function () { return String(projectVersion); },
         getScriptFileNames: function () { return __spread(memoryCache.files.keys()); },
         getScriptVersion: function (fileName) {
+            var _a;
             var normalizedFileName = path_1.normalize(fileName);
-            var version = memoryCache.files.get(normalizedFileName).version;
+            var version = (_a = memoryCache.files.get(normalizedFileName)) === null || _a === void 0 ? void 0 : _a.version;
             return version === undefined ? undefined : String(version);
         },
         getScriptSnapshot: function (fileName) {
             var _a;
             var normalizedFileName = path_1.normalize(fileName);
-            var hit = memoryCache.files.has(normalizedFileName) && memoryCache.files.get(normalizedFileName).version !== 0;
+            var hit = isFileInCache(normalizedFileName);
             logger.trace({ normalizedFileName: normalizedFileName, cacheHit: hit }, 'getScriptSnapshot():', 'cache', hit ? 'hit' : 'miss');
             if (!hit) {
                 memoryCache.files.set(normalizedFileName, {
-                    text: ts.sys.readFile(normalizedFileName),
+                    text: cacheReadFile(normalizedFileName),
                     version: 1,
                 });
             }
@@ -102,46 +204,75 @@ exports.initializeLanguageServiceInstance = function (configs, memoryCache, logg
             return ts.ScriptSnapshot.fromString(contents);
         },
         fileExists: memoize(ts.sys.fileExists),
-        readFile: logger.wrap(serviceHostTraceCtx, 'readFile', memoize(ts.sys.readFile)),
+        readFile: cacheReadFile,
         readDirectory: memoize(ts.sys.readDirectory),
         getDirectories: memoize(ts.sys.getDirectories),
         directoryExists: memoize(ts.sys.directoryExists),
-        realpath: memoize(ts.sys.realpath),
+        realpath: ts.sys.realpath && memoize(ts.sys.realpath),
         getNewLine: function () { return constants_1.LINE_FEED; },
         getCurrentDirectory: function () { return cwd; },
         getCompilationSettings: function () { return options; },
         getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(options); },
-        getCustomTransformers: function () { return configs.tsCustomTransformers; },
+        getCustomTransformers: function () { return configs.customTransformers; },
+        resolveModuleNames: resolveModuleNames,
     };
     logger.debug('initializeLanguageServiceInstance(): creating language service');
     var service = ts.createLanguageService(serviceHost, ts.createDocumentRegistry());
     return {
         compileFn: function (code, fileName) {
+            var e_1, _a;
+            var _b;
             logger.debug({ fileName: fileName }, 'compileFn(): compiling using language service');
             updateMemoryCache(code, fileName);
             var output = service.getEmitOutput(fileName);
-            logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
+            if (tsResolvedModulesCachePath) {
-            doTypeChecking(configs, fileName, service, logger);
+                void (function () { return __awaiter(void 0, void 0, void 0, function () {
-            if (cacheDir) {
+                    return __generator(this, function (_a) {
-                if (compiler_utils_1.isTestFile(configs.testMatchPatterns, fileName)) {
+                        switch (_a.label) {
-                    compiler_utils_1.cacheResolvedModules(fileName, code, memoryCache, service.getProgram(), cacheDir, logger);
+                            case 0: return [4, fs_1.writeFile(tsResolvedModulesCachePath, json_1.stringify(__spread(memoryCache.resolvedModules)), function () { })];
-                }
+                            case 1:
-                else {
+                                _a.sent();
-                    Object.entries(memoryCache.resolvedModules)
+                                return [2];
-                        .filter(function (entry) {
+                        }
-                        return entry[1].modulePaths.find(function (modulePath) { return modulePath === fileName; }) && !memoryCache.files.has(entry[0]);
-                    })
-                        .forEach(function (entry) {
-                        var testFileName = entry[0];
-                        var testFileContent = entry[1].testFileContent;
-                        logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics for test file that imports this module using language service');
-                        updateMemoryCache(testFileContent, testFileName);
-                        doTypeChecking(configs, testFileName, service, logger);
                     });
+                }); })();
+            }
+            if (!diagnosedFiles.includes(fileName)) {
+                logger.debug({ fileName: fileName }, 'compileFn(): computing diagnostics using language service');
+                doTypeChecking(configs, diagnosedFiles, fileName, service, logger);
+            }
+            if (!configs.isTestFile(fileName)) {
+                try {
+                    for (var _c = __values(memoryCache.resolvedModules.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var _e = __read(_d.value, 2), testFileName = _e[0], resolvedModules = _e[1];
+                        if (resolvedModules.includes(fileName) &&
+                            !diagnosedFiles.includes(testFileName) &&
+                            fs_1.existsSync(testFileName)) {
+                            var testFileContent = (_b = memoryCache.files.get(testFileName)) === null || _b === void 0 ? void 0 : _b.text;
+                            if (!testFileContent) {
+                                updateMemoryCache(cacheReadFile(testFileName), testFileName);
+                            }
+                            logger.debug({ testFileName: testFileName }, 'compileFn(): computing diagnostics using language service for test file which uses the module');
+                            doTypeChecking(configs, diagnosedFiles, testFileName, service, logger);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
                 }
             }
             if (output.emitSkipped) {
-                throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped for language service");
+                if (constants_1.TS_TSX_REGEX.test(fileName)) {
+                    throw new Error(messages_1.interpolate("Unable to process '{{file}}', please make sure that `outDir` in your tsconfig is neither `''` or `'.'`. You can also configure Jest config option `transformIgnorePatterns` to inform `ts-jest` to transform {{file}}", { file: fileName }));
+                }
+                else {
+                    logger.warn(messages_1.interpolate("Unable to process '{{file}}', falling back to original file content. You can also configure Jest config option `transformIgnorePatterns` to ignore {{file}} from transformation or make sure that `outDir` in your tsconfig is neither `''` or `'.'`", { file: fileName }));
+                    return [code, '{}'];
+                }
             }
             if (!output.outputFiles.length) {
                 throw new TypeError(messages_1.interpolate("Unable to require `.d.ts` file for file: {{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}}`.", {

node_modules/ts-jest/dist/compiler/transpiler.js

@@ -1,32 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeTranspilerInstance = function (configs, memoryCache, logger) {
+exports.initializeTranspilerInstance = void 0;
+exports.initializeTranspilerInstance = function (configs, logger) {
     logger.debug('initializeTranspilerInstance(): create typescript compiler');
-    var _a = configs.parsedTsConfig, options = _a.options, fileNames = _a.fileNames;
+    var options = configs.parsedTsConfig.options;
     var ts = configs.compilerModule;
-    var program = ts.createProgram(fileNames, options);
-    var updateFileInCache = function (contents, filePath) {
-        var file = memoryCache.files.get(filePath);
-        if (file && file.text !== contents) {
-            file.version++;
-            file.text = contents;
-        }
-    };
     return {
         compileFn: function (code, fileName) {
-            updateFileInCache(code, fileName);
             logger.debug({ fileName: fileName }, 'compileFn(): compiling as isolated module');
             var result = ts.transpileModule(code, {
                 fileName: fileName,
-                transformers: configs.tsCustomTransformers,
+                transformers: configs.customTransformers,
                 compilerOptions: options,
-                reportDiagnostics: configs.shouldReportDiagnostic(fileName),
+                reportDiagnostics: configs.shouldReportDiagnostics(fileName),
             });
-            if (result.diagnostics && configs.shouldReportDiagnostic(fileName)) {
+            if (result.diagnostics && configs.shouldReportDiagnostics(fileName)) {
                 configs.raiseDiagnostics(result.diagnostics, fileName, logger);
             }
             return [result.outputText, result.sourceMapText];
         },
-        program: program,
+        program: undefined,
     };
 };

node_modules/ts-jest/dist/config/config-set.d.ts

@@ -1,11 +1,28 @@
-import { Config } from '@jest/types';
+import type { Config } from '@jest/types';
 import { Logger } from 'bs-logger';
-import { TsCompiler, TsJestGlobalOptions } from '../types';
+import { CompilerOptions, CustomTransformers, Diagnostic, ParsedCommandLine } from 'typescript';
+import type { TTypeScript } from '../types';
+import type { RawCompilerOptions } from '../tsconfig-raw';
 export declare class ConfigSet {
-    readonly parentOptions?: TsJestGlobalOptions | undefined;
+    private readonly parentLogger?;
-    get versions(): Record<string, string>;
-    get tsCompiler(): TsCompiler;
-    get tsJestDigest(): string;
     readonly logger: Logger;
-    constructor(jestConfig: Config.ProjectConfig, parentOptions?: TsJestGlobalOptions | undefined, parentLogger?: Logger);
+    readonly compilerModule: TTypeScript;
+    readonly isolatedModules: boolean;
+    readonly cwd: string;
+    tsCacheDir: string | undefined;
+    parsedTsConfig: ParsedCommandLine | Record<string, any>;
+    customTransformers: CustomTransformers;
+    readonly rootDir: string;
+    protected _overriddenCompilerOptions: Partial<CompilerOptions>;
+    constructor(jestConfig: Config.ProjectConfig | undefined, parentLogger?: Logger | undefined);
+    protected _resolveTsConfig(compilerOptions?: RawCompilerOptions, resolvedConfigFile?: string): Record<string, any>;
+    get tsJestDigest(): string;
+    isTestFile(fileName: string): boolean;
+    shouldStringifyContent(filePath: string): boolean;
+    raiseDiagnostics(diagnostics: Diagnostic[], filePath?: string, logger?: Logger): void;
+    shouldReportDiagnostics(filePath: string): boolean;
+    resolvePath(inputPath: string, { throwIfMissing, nodeResolve }?: {
+        throwIfMissing?: boolean;
+        nodeResolve?: boolean;
+    }): string;
 }

node_modules/ts-jest/dist/config/create-jest-preset.d.ts

@@ -1,10 +0,0 @@
-import { Config } from '@jest/types';
-export interface TsJestPresets {
-    transform: Config.InitialOptions['transform'];
-    testMatch?: string[];
-    moduleFileExtensions?: string[];
-}
-export interface CreateJestPresetOptions {
-    allowJs?: boolean;
-}
-export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: Config.InitialOptions): TsJestPresets;

node_modules/ts-jest/dist/config/paths-to-module-name-mapper.d.ts

@@ -1,5 +1,6 @@
+import type { Config } from '@jest/types';
+declare type JestPathMapping = Config.InitialOptions['moduleNameMapper'];
 export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
-    prefix?: string | undefined;
+    prefix: string;
-}) => {
+}) => JestPathMapping;
-    [key: string]: string | string[];
+export {};
-} | undefined;

node_modules/ts-jest/dist/config/paths-to-module-name-mapper.js

@@ -12,14 +12,15 @@ var __values = (this && this.__values) || function(o) {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathsToModuleNameMapper = void 0;
 var bs_logger_1 = require("bs-logger");
-var logger_1 = require("../util/logger");
+var logger_1 = require("../utils/logger");
-var messages_1 = require("../util/messages");
+var messages_1 = require("../utils/messages");
 var escapeRegex = function (str) { return str.replace(/[-\\^$*+?.()|[\]{}]/g, '\\$&'); };
 var logger = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'path-mapper', _a));
 exports.pathsToModuleNameMapper = function (mapping, _a) {
     var e_1, _b;
-    var _c = (_a === void 0 ? {} : _a).prefix, prefix = _c === void 0 ? '' : _c;
+    var _c = (_a === void 0 ? Object.create(null) : _a).prefix, prefix = _c === void 0 ? '' : _c;
     var jestMap = {};
     try {
         for (var _d = __values(Object.keys(mapping)), _e = _d.next(); !_e.done; _e = _d.next()) {
@@ -30,25 +31,25 @@ exports.pathsToModuleNameMapper = function (mapping, _a) {
                 logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has no target.", { path: fromPath }));
                 continue;
             }
-            else if (toPaths.length > 1) {
-                logger.warn(messages_1.interpolate("Mapping only to first target of \"{{path}}\" because it has more than one ({{count}}).", {
-                    path: fromPath,
-                    count: toPaths.length,
-                }));
-            }
-            var target = toPaths[0];
             var segments = fromPath.split(/\*/g);
             if (segments.length === 1) {
+                var paths = toPaths.map(function (target) {
+                    var enrichedPrefix = prefix !== '' && !prefix.endsWith('/') ? prefix + "/" : prefix;
+                    return "" + enrichedPrefix + target;
+                });
                 pattern = "^" + escapeRegex(fromPath) + "$";
-                jestMap[pattern] = "" + prefix + target;
+                jestMap[pattern] = paths.length === 1 ? paths[0] : paths;
             }
             else if (segments.length === 2) {
+                var paths = toPaths.map(function (target) {
+                    var enrichedPrefix = prefix !== '' && !prefix.endsWith('/') ? prefix + "/" : prefix;
+                    return "" + enrichedPrefix + target.replace(/\*/g, '$1');
+                });
                 pattern = "^" + escapeRegex(segments[0]) + "(.*)" + escapeRegex(segments[1]) + "$";
-                jestMap[pattern] = "" + prefix + target.replace(/\*/g, '$1');
+                jestMap[pattern] = paths.length === 1 ? paths[0] : paths;
             }
             else {
                 logger.warn(messages_1.interpolate("Not mapping \"{{path}}\" because it has more than one star (`*`).", { path: fromPath }));
-                continue;
             }
         }
     }

node_modules/ts-jest/dist/constants.d.ts

@@ -1 +1,4 @@
-export {};
+export declare const LINE_FEED = "\n";
+export declare const TS_TSX_REGEX: RegExp;
+export declare const JS_JSX_REGEX: RegExp;
+export declare const DECLARATION_TYPE_EXT = ".d.ts";

node_modules/ts-jest/dist/constants.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_JEST_TEST_MATCH = exports.DECLARATION_TYPE_EXT = exports.JS_JSX_REGEX = exports.TS_TSX_REGEX = exports.LINE_FEED = void 0;
 exports.LINE_FEED = '\n';
-exports.EXTENSION_REGEX = /\.[^.]+$/;
 exports.TS_TSX_REGEX = /\.tsx?$/;
 exports.JS_JSX_REGEX = /\.jsx?$/;
-exports.JSON_REGEX = /\.json$/i;
+exports.DECLARATION_TYPE_EXT = '.d.ts';
 exports.DEFAULT_JEST_TEST_MATCH = ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'];

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

@@ -1,7 +1,7 @@
-import { createJestPreset as createJestPresetCore } from './config/create-jest-preset';
+import { createJestPreset as createJestPresetCore } from './presets/create-jest-preset';
 import { TsJestTransformer } from './ts-jest-transformer';
-import { TsJestGlobalOptions } from './types';
+import type { TsJestGlobalOptions } from './types';
-import { mocked as mockedCore } from './util/testing';
+import { mocked as mockedCore } from './utils/testing';
 declare module '@jest/types' {
     namespace Config {
         interface ConfigGlobals {
@@ -12,12 +12,8 @@ declare module '@jest/types' {
 export declare const mocked: typeof mockedCore;
 export declare const createJestPreset: typeof createJestPresetCore;
 export declare const pathsToModuleNameMapper: (mapping: import("typescript").MapLike<string[]>, { prefix }?: {
-    prefix?: string | undefined;
+    prefix: string;
 }) => {
     [key: string]: string | string[];
 } | undefined;
-export declare const version: string;
+export declare function createTransformer(): TsJestTransformer;
-export declare const digest: string;
-export declare function createTransformer(baseConfig?: TsJestGlobalOptions): TsJestTransformer;
-declare const jestPreset: import("./config/create-jest-preset").TsJestPresets;
-export { jestPreset, };

node_modules/ts-jest/dist/index.js

@@ -1,36 +1,15 @@
 "use strict";
-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;
-};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformer = exports.pathsToModuleNameMapper = exports.createJestPreset = exports.mocked = void 0;
 var bs_logger_1 = require("bs-logger");
-var fs_1 = require("fs");
+var create_jest_preset_1 = require("./presets/create-jest-preset");
-var path_1 = require("path");
-var create_jest_preset_1 = require("./config/create-jest-preset");
 var paths_to_module_name_mapper_1 = require("./config/paths-to-module-name-mapper");
 var ts_jest_transformer_1 = require("./ts-jest-transformer");
-var logger_1 = require("./util/logger");
+var logger_1 = require("./utils/logger");
-var messages_1 = require("./util/messages");
+var messages_1 = require("./utils/messages");
-var testing_1 = require("./util/testing");
+var testing_1 = require("./utils/testing");
-var version_checkers_1 = require("./util/version-checkers");
+var version_checkers_1 = require("./utils/version-checkers");
 var warn = logger_1.rootLogger.child((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.warn, _a));
 var helperMoved = function (name, helper) {
     return warn.wrap(messages_1.interpolate("The `{{helper}}` helper has been moved to `ts-jest/utils`. Use `import { {{helper}} } from 'ts-jest/utils'` instead.", { helper: name }), helper);
@@ -38,37 +17,8 @@ var helperMoved = function (name, helper) {
 exports.mocked = helperMoved('mocked', testing_1.mocked);
 exports.createJestPreset = helperMoved('createJestPreset', create_jest_preset_1.createJestPreset);
 exports.pathsToModuleNameMapper = helperMoved('pathsToModuleNameMapper', paths_to_module_name_mapper_1.pathsToModuleNameMapper);
-exports.version = require('../package.json').version;
+function createTransformer() {
-exports.digest = fs_1.readFileSync(path_1.resolve(__dirname, '..', '.ts-jest-digest'), 'utf8');
-var transformer;
-function defaultTransformer() {
-    return transformer || (transformer = createTransformer());
-}
-function createTransformer(baseConfig) {
     version_checkers_1.VersionCheckers.jest.warn();
-    return new ts_jest_transformer_1.TsJestTransformer(baseConfig);
+    return new ts_jest_transformer_1.TsJestTransformer();
 }
 exports.createTransformer = createTransformer;
-function process() {
-    var _a;
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return (_a = defaultTransformer()).process.apply(_a, __spread(args));
-}
-exports.process = process;
-function getCacheKey() {
-    var _a;
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return (_a = defaultTransformer()).getCacheKey.apply(_a, __spread(args));
-}
-exports.getCacheKey = getCacheKey;
-exports.canInstrument = false;
-var jestPreset = create_jest_preset_1.createJestPreset();
-exports.jestPreset = jestPreset;
-exports.__singleton = function () { return transformer; };
-exports.__resetModule = function () { return (transformer = undefined); };

node_modules/ts-jest/dist/presets/create-jest-preset.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '@jest/types';
+import type { TsJestPresets } from '../types';
+interface CreateJestPresetOptions {
+    allowJs?: boolean;
+}
+export declare function createJestPreset({ allowJs }?: CreateJestPresetOptions, from?: Config.InitialOptions): TsJestPresets;
+export {};

node_modules/ts-jest/dist/presets/create-jest-preset.js

@@ -11,7 +11,8 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var logger_1 = require("../util/logger");
+exports.createJestPreset = void 0;
+var logger_1 = require("../utils/logger");
 var logger = logger_1.rootLogger.child({ namespace: 'jest-preset' });
 function createJestPreset(_a, from) {
     var _b;

node_modules/ts-jest/dist/transformers/hoist-jest.js

@@ -1,4 +1,15 @@
 "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 __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -20,23 +31,44 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.factory = exports.version = exports.name = void 0;
 var bs_logger_1 = require("bs-logger");
 var HOIST_METHODS = ['mock', 'unmock', 'enableAutomock', 'disableAutomock', 'deepUnmock'];
+var JEST_GLOBALS_MODULE_NAME = '@jest/globals';
+var JEST_GLOBAL_NAME = 'jest';
+var ROOT_LEVEL_AST = 1;
 exports.name = 'hoisting-jest-mock';
-exports.version = 1;
+exports.version = 4;
 function factory(cs) {
     var logger = cs.logger.child({ namespace: 'ts-hoisting' });
     var ts = cs.compilerModule;
-    function shouldHoistExpression(expression) {
+    var importNames = [];
-        return (ts.isCallExpression(expression) &&
+    function shouldHoistExpression(node) {
-            ts.isPropertyAccessExpression(expression.expression) &&
+        if (ts.isCallExpression(node) &&
-            HOIST_METHODS.includes(expression.expression.name.text) &&
+            ts.isPropertyAccessExpression(node.expression) &&
-            ((ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === 'jest') ||
+            HOIST_METHODS.includes(node.expression.name.text)) {
-                shouldHoistExpression(expression.expression.expression)));
+            if (importNames.length) {
+                return ((ts.isIdentifier(node.expression.expression) && importNames.includes(node.expression.expression.text)) ||
+                    (ts.isPropertyAccessExpression(node.expression.expression) &&
+                        ts.isIdentifier(node.expression.expression.expression) &&
+                        importNames.includes(node.expression.expression.expression.text)) ||
+                    shouldHoistExpression(node.expression.expression));
+            }
+            else {
+                return ((ts.isIdentifier(node.expression.expression) && node.expression.expression.text === JEST_GLOBAL_NAME) ||
+                    shouldHoistExpression(node.expression.expression));
+            }
+        }
+        return false;
     }
     function shouldHoistNode(node) {
         return ts.isExpressionStatement(node) && shouldHoistExpression(node.expression);
     }
+    function isJestGlobalImport(node) {
+        return (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.moduleSpecifier.text === JEST_GLOBALS_MODULE_NAME);
+    }
     function createVisitor(ctx, _) {
         var level = 0;
         var hoisted = [];
@@ -56,14 +88,32 @@ function factory(cs) {
             }
         };
         var visitor = function (node) {
+            var _a, _b;
             enter();
             var resultNode = ts.visitEachChild(node, visitor, ctx);
+            if (isJestGlobalImport(resultNode) && ((_a = resultNode.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings) &&
+                (ts.isNamespaceImport(resultNode.importClause.namedBindings) ||
+                    ts.isNamedImports(resultNode.importClause.namedBindings))) {
+                var namedBindings = resultNode.importClause.namedBindings;
+                var jestImportName = ts.isNamespaceImport(namedBindings)
+                    ? namedBindings.name.text
+                    : (_b = namedBindings.elements.find(function (element) { var _a; return element.name.text === JEST_GLOBAL_NAME || ((_a = element.propertyName) === null || _a === void 0 ? void 0 : _a.text) === JEST_GLOBAL_NAME; })) === null || _b === void 0 ? void 0 : _b.name.text;
+                if (jestImportName) {
+                    importNames.push(jestImportName);
+                }
+            }
             if (hoisted[level] && hoisted[level].length) {
                 var hoistedStmts_1 = hoisted[level];
-                var otherStmts = resultNode.statements.filter(function (s) { return !hoistedStmts_1.includes(s); });
+                var otherStmts = resultNode.statements.filter(function (s) { return !hoistedStmts_1.includes(s) && !isJestGlobalImport(s); });
                 var newNode = ts.getMutableClone(resultNode);
-                newNode.statements = ts.createNodeArray(__spread(hoistedStmts_1, otherStmts));
+                var newStatements = __spread(hoistedStmts_1, otherStmts);
-                resultNode = newNode;
+                if (level === ROOT_LEVEL_AST) {
+                    var jestGlobalsImportStmts = resultNode.statements.filter(function (s) { return isJestGlobalImport(s); });
+                    resultNode = __assign(__assign({}, newNode), { statements: ts.createNodeArray(__spread(jestGlobalsImportStmts, newStatements)) });
+                }
+                else {
+                    resultNode = __assign(__assign({}, newNode), { statements: ts.createNodeArray(newStatements) });
+                }
             }
             exit();
             if (shouldHoistNode(resultNode)) {

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

@@ -1,4 +1,24 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var hoisting = require("./hoist-jest");
+exports.internals = void 0;
+var hoisting = __importStar(require("./hoist-jest"));
 exports.internals = [hoisting];

node_modules/ts-jest/dist/transformers/path-mapping.d.ts

@@ -0,0 +1,3 @@
+import type * as _ts from 'typescript';
+import type { ConfigSet } from '../config/config-set';
+export declare function factory(cs: ConfigSet): (ctx: _ts.TransformationContext) => _ts.Transformer<_ts.SourceFile>;

node_modules/ts-jest/dist/transformers/path-mapping.js

@@ -0,0 +1,121 @@
+"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 __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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factory = exports.version = exports.name = void 0;
+var bs_logger_1 = require("bs-logger");
+var path_1 = require("path");
+exports.name = 'path-mapping';
+exports.version = 1;
+var isBaseDir = function (base, dir) { var _a; return !((_a = path_1.relative(base, dir)) === null || _a === void 0 ? void 0 : _a.startsWith('.')); };
+function factory(cs) {
+    var _a;
+    var logger = cs.logger.child({ namespace: 'ts-path-mapping' });
+    var ts = cs.compilerModule;
+    var compilerOptions = cs.parsedTsConfig.options;
+    var rootDirs = (_a = compilerOptions.rootDirs) === null || _a === void 0 ? void 0 : _a.filter(path_1.isAbsolute);
+    var isDynamicImport = function (node) {
+        return ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
+    };
+    var isRequire = function (node) {
+        return ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === 'require' &&
+            ts.isStringLiteral(node.arguments[0]) &&
+            node.arguments.length === 1;
+    };
+    var createVisitor = function (ctx, sf) {
+        var fileName = sf.fileName;
+        var fileDir = path_1.normalize(path_1.dirname(fileName));
+        var rewritePath = function (importPath) {
+            var e_1, _a;
+            var p = importPath;
+            var resolvedModule = ts.resolveModuleName(importPath, fileName, compilerOptions, ts.sys).resolvedModule;
+            if (resolvedModule) {
+                var resolvedFileName = resolvedModule.resolvedFileName;
+                var filePath = fileDir;
+                var modulePath = path_1.dirname(resolvedFileName);
+                if (rootDirs) {
+                    var fileRootDir = '';
+                    var moduleRootDir = '';
+                    try {
+                        for (var rootDirs_1 = __values(rootDirs), rootDirs_1_1 = rootDirs_1.next(); !rootDirs_1_1.done; rootDirs_1_1 = rootDirs_1.next()) {
+                            var rootDir = rootDirs_1_1.value;
+                            if (isBaseDir(rootDir, resolvedFileName) && rootDir.length > moduleRootDir.length)
+                                moduleRootDir = rootDir;
+                            if (isBaseDir(rootDir, fileName) && rootDir.length > fileRootDir.length)
+                                fileRootDir = rootDir;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (rootDirs_1_1 && !rootDirs_1_1.done && (_a = rootDirs_1.return)) _a.call(rootDirs_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    if (fileRootDir && moduleRootDir) {
+                        filePath = path_1.relative(fileRootDir, filePath);
+                        modulePath = path_1.relative(moduleRootDir, modulePath);
+                    }
+                }
+                p = path_1.normalize(path_1.join(path_1.relative(filePath, modulePath), path_1.basename(resolvedFileName)));
+                p = p.startsWith('.') ? p : "./" + p;
+            }
+            return p;
+        };
+        var visitor = function (node) {
+            var rewrittenPath;
+            var newNode = ts.getMutableClone(node);
+            if (isDynamicImport(node) || isRequire(node)) {
+                rewrittenPath = rewritePath(node.arguments[0].text);
+                return __assign(__assign({}, newNode), { arguments: ts.createNodeArray([ts.createStringLiteral(rewrittenPath)]) });
+            }
+            if (ts.isExternalModuleReference(node) && ts.isStringLiteral(node.expression)) {
+                rewrittenPath = rewritePath(node.expression.text);
+                return ts.updateExternalModuleReference(newNode, ts.createLiteral(rewrittenPath));
+            }
+            if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+                rewrittenPath = rewritePath(node.moduleSpecifier.text);
+                return __assign(__assign({}, newNode), { moduleSpecifier: ts.createLiteral(rewrittenPath) });
+            }
+            if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+                rewrittenPath = rewritePath(node.moduleSpecifier.text);
+                return __assign(__assign({}, newNode), { moduleSpecifier: ts.createLiteral(rewrittenPath) });
+            }
+            if (ts.isImportTypeNode(node) &&
+                ts.isLiteralTypeNode(node.argument) &&
+                ts.isStringLiteral(node.argument.literal)) {
+                rewrittenPath = rewritePath(node.argument.literal.text);
+                return __assign(__assign({}, newNode), { argument: ts.createLiteralTypeNode(ts.createStringLiteral(rewrittenPath)) });
+            }
+            return ts.visitEachChild(node, visitor, ctx);
+        };
+        return visitor;
+    };
+    return function (ctx) {
+        var _a;
+        return logger.wrap((_a = {}, _a[bs_logger_1.LogContexts.logLevel] = bs_logger_1.LogLevels.debug, _a.call = null, _a), 'visitSourceFileNode(): path mapping', function (sf) { return ts.visitNode(sf, createVisitor(ctx, sf)); });
+    };
+}
+exports.factory = factory;

node_modules/ts-jest/dist/ts-jest-transformer.d.ts

@@ -1,12 +1,11 @@
-import { CacheKeyOptions, TransformOptions, TransformedSource, Transformer } from '@jest/transform';
+import type { CacheKeyOptions, TransformedSource, Transformer, TransformOptions } from '@jest/transform';
-import { Config } from '@jest/types';
+import type { Config } from '@jest/types';
+import type { Logger } from 'bs-logger';
 import { ConfigSet } from './config/config-set';
-import { TsJestGlobalOptions } from './types';
 export declare class TsJestTransformer implements Transformer {
-    private readonly logger;
+    protected readonly logger: Logger;
-    private readonly id;
+    protected _transformCfgStr: string;
-    private readonly options;
+    constructor();
-    constructor(baseOptions?: TsJestGlobalOptions);
     configsFor(jestConfig: Config.ProjectConfig): ConfigSet;
     process(input: string, filePath: Config.Path, jestConfig: Config.ProjectConfig, transformOptions?: TransformOptions): TransformedSource | string;
     getCacheKey(fileContent: string, filePath: string, _jestConfigStr: string, transformOptions: CacheKeyOptions): string;

node_modules/ts-jest/dist/ts-jest-transformer.js

@@ -11,53 +11,53 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var util_1 = require("util");
+exports.TsJestTransformer = void 0;
 var config_set_1 = require("./config/config-set");
 var constants_1 = require("./constants");
-var json_1 = require("./util/json");
+var json_1 = require("./utils/json");
-var jsonable_value_1 = require("./util/jsonable-value");
+var jsonable_value_1 = require("./utils/jsonable-value");
-var logger_1 = require("./util/logger");
+var logger_1 = require("./utils/logger");
-var messages_1 = require("./util/messages");
+var messages_1 = require("./utils/messages");
-var sha1_1 = require("./util/sha1");
+var sha1_1 = require("./utils/sha1");
-var INSPECT_CUSTOM = util_1.inspect.custom || 'inspect';
 var TsJestTransformer = (function () {
-    function TsJestTransformer(baseOptions) {
+    function TsJestTransformer() {
-        if (baseOptions === void 0) { baseOptions = {}; }
+        this.logger = logger_1.rootLogger.child({ namespace: 'ts-jest-transformer' });
-        this.options = __assign({}, baseOptions);
+        this.logger.debug('created new transformer');
-        this.id = TsJestTransformer._nextTransformerId;
-        this.logger = logger_1.rootLogger.child({
-            transformerId: this.id,
-            namespace: 'jest-transformer',
-        });
-        this.logger.debug({ baseOptions: baseOptions }, 'created new transformer');
     }
-    Object.defineProperty(TsJestTransformer, "_nextTransformerId", {
-        get: function () {
-            return ++TsJestTransformer._lastTransformerId;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    TsJestTransformer.prototype[INSPECT_CUSTOM] = function () {
-        return "[object TsJestTransformer<#" + this.id + ">]";
-    };
     TsJestTransformer.prototype.configsFor = function (jestConfig) {
-        var csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.value === jestConfig; });
+        var ccs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.value === jestConfig; });
-        if (csi)
+        var configSet;
-            return csi.configSet;
+        if (ccs) {
-        var serialized = json_1.stringify(jestConfig);
+            this._transformCfgStr = ccs.transformerCfgStr;
-        csi = TsJestTransformer._configSetsIndex.find(function (cs) { return cs.jestConfig.serialized === serialized; });
+            configSet = ccs.configSet;
-        if (csi) {
+        }
-            csi.jestConfig.value = jestConfig;
+        else {
-            return csi.configSet;
+            var serializedJestCfg_1 = json_1.stringify(jestConfig);
+            var serializedCcs = TsJestTransformer._cachedConfigSets.find(function (cs) { return cs.jestConfig.serialized === serializedJestCfg_1; });
+            if (serializedCcs) {
+                serializedCcs.jestConfig.value = jestConfig;
+                this._transformCfgStr = serializedCcs.transformerCfgStr;
+                configSet = serializedCcs.configSet;
+            }
+            else {
+                this.logger.info('no matching config-set found, creating a new one');
+                configSet = new config_set_1.ConfigSet(jestConfig);
+                var jest_1 = __assign({}, jestConfig);
+                var globals = (jest_1.globals = __assign({}, jest_1.globals));
+                jest_1.name = undefined;
+                jest_1.cacheDirectory = undefined;
+                delete globals['ts-jest'];
+                this._transformCfgStr = new jsonable_value_1.JsonableValue(__assign(__assign({ digest: configSet.tsJestDigest, babel: configSet.babelConfig }, jest_1), { tsconfig: {
+                        options: configSet.parsedTsConfig.options,
+                        raw: configSet.parsedTsConfig.raw,
+                    } })).serialized;
+                TsJestTransformer._cachedConfigSets.push({
+                    jestConfig: new jsonable_value_1.JsonableValue(jestConfig),
+                    configSet: configSet,
+                    transformerCfgStr: this._transformCfgStr,
+                });
+            }
         }
-        var jestConfigObj = jestConfig;
-        this.logger.info('no matching config-set found, creating a new one');
-        var configSet = new config_set_1.ConfigSet(jestConfigObj, this.options, this.logger);
-        TsJestTransformer._configSetsIndex.push({
-            jestConfig: new jsonable_value_1.JsonableValue(jestConfigObj),
-            configSet: configSet,
-        });
         return configSet;
     };
     TsJestTransformer.prototype.process = function (input, filePath, jestConfig, transformOptions) {
@@ -66,13 +66,13 @@ var TsJestTransformer = (function () {
         var source = input;
         var configs = this.configsFor(jestConfig);
         var hooks = configs.hooks;
-        var stringify = configs.shouldStringifyContent(filePath);
+        var shouldStringifyContent = configs.shouldStringifyContent(filePath);
-        var babelJest = stringify ? undefined : configs.babelJestTransformer;
+        var babelJest = shouldStringifyContent ? undefined : configs.babelJestTransformer;
-        var isDefinitionFile = filePath.endsWith('.d.ts');
+        var isDefinitionFile = filePath.endsWith(constants_1.DECLARATION_TYPE_EXT);
         var isJsFile = constants_1.JS_JSX_REGEX.test(filePath);
         var isTsFile = !isDefinitionFile && constants_1.TS_TSX_REGEX.test(filePath);
-        if (stringify) {
+        if (shouldStringifyContent) {
-            result = "module.exports=" + JSON.stringify(source);
+            result = "module.exports=" + json_1.stringify(source);
         }
         else if (isDefinitionFile) {
             result = '';
@@ -103,13 +103,12 @@ var TsJestTransformer = (function () {
         return result;
     };
     TsJestTransformer.prototype.getCacheKey = function (fileContent, filePath, _jestConfigStr, transformOptions) {
-        this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'computing cache key for', filePath);
         var configs = this.configsFor(transformOptions.config);
+        this.logger.debug({ fileName: filePath, transformOptions: transformOptions }, 'computing cache key for', filePath);
         var _a = transformOptions.instrument, instrument = _a === void 0 ? false : _a, _b = transformOptions.rootDir, rootDir = _b === void 0 ? configs.rootDir : _b;
-        return sha1_1.sha1(configs.cacheKey, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
+        return sha1_1.sha1(this._transformCfgStr, '\x00', rootDir, '\x00', "instrument:" + (instrument ? 'on' : 'off'), '\x00', fileContent, '\x00', filePath);
     };
-    TsJestTransformer._configSetsIndex = [];
+    TsJestTransformer._cachedConfigSets = [];
-    TsJestTransformer._lastTransformerId = 0;
     return TsJestTransformer;
 }());
 exports.TsJestTransformer = TsJestTransformer;

node_modules/ts-jest/dist/tsconfig-raw.d.ts

@@ -0,0 +1,105 @@
+export interface RawCompilerOptions {
+    charset?: string;
+    composite?: boolean;
+    declaration?: boolean;
+    declarationDir?: string | null;
+    diagnostics?: boolean;
+    disableReferencedProjectLoad?: boolean;
+    emitBOM?: boolean;
+    emitDeclarationOnly?: boolean;
+    incremental?: boolean;
+    tsBuildInfoFile?: string;
+    inlineSourceMap?: boolean;
+    inlineSources?: boolean;
+    jsx?: 'preserve' | 'react' | 'react-jsx' | 'react-jsxdev' | 'react-native';
+    reactNamespace?: string;
+    jsxFactory?: string;
+    jsxFragmentFactory?: string;
+    jsxImportSource?: string;
+    listFiles?: boolean;
+    mapRoot?: string;
+    module?: 'CommonJS' | 'AMD' | 'System' | 'UMD' | 'ES6' | 'ES2015' | 'ES2020' | 'ESNext' | 'None' | string;
+    moduleResolution?: 'Classic' | 'Node';
+    newLine?: 'crlf' | 'lf';
+    noEmit?: boolean;
+    noEmitHelpers?: boolean;
+    noEmitOnError?: boolean;
+    noImplicitAny?: boolean;
+    noImplicitThis?: boolean;
+    noUnusedLocals?: boolean;
+    noUnusedParameters?: boolean;
+    noLib?: boolean;
+    noResolve?: boolean;
+    noStrictGenericChecks?: boolean;
+    skipDefaultLibCheck?: boolean;
+    skipLibCheck?: boolean;
+    outFile?: string;
+    outDir?: string;
+    preserveConstEnums?: boolean;
+    preserveSymlinks?: boolean;
+    preserveWatchOutput?: boolean;
+    pretty?: boolean;
+    removeComments?: boolean;
+    rootDir?: string;
+    isolatedModules?: boolean;
+    sourceMap?: boolean;
+    sourceRoot?: string;
+    suppressExcessPropertyErrors?: boolean;
+    suppressImplicitAnyIndexErrors?: boolean;
+    target?: 'ES3' | 'ES5' | 'ES6' | 'ES2015' | 'ES2016' | 'ES2017' | 'ES2018' | 'ES2019' | 'ES2020' | 'ESNext' | string;
+    watch?: boolean;
+    fallbackPolling?: 'fixedPollingInterval' | 'priorityPollingInterval' | 'dynamicPriorityPolling';
+    watchDirectory?: 'useFsEvents' | 'fixedPollingInterval' | 'dynamicPriorityPolling';
+    watchFile?: 'fixedPollingInterval' | 'priorityPollingInterval' | 'dynamicPriorityPolling' | 'useFsEvents' | 'useFsEventsOnParentDirectory';
+    experimentalDecorators?: boolean;
+    emitDecoratorMetadata?: boolean;
+    allowUnusedLabels?: boolean;
+    noImplicitReturns?: boolean;
+    noUncheckedIndexedAccess?: boolean;
+    noFallthroughCasesInSwitch?: boolean;
+    allowUnreachableCode?: boolean;
+    forceConsistentCasingInFileNames?: boolean;
+    generateCpuProfile?: string;
+    baseUrl?: string;
+    paths?: {
+        [k: string]: string[];
+    };
+    plugins?: {
+        name?: string;
+        [k: string]: unknown;
+    }[];
+    rootDirs?: string[];
+    typeRoots?: string[];
+    types?: string[];
+    traceResolution?: boolean;
+    allowJs?: boolean;
+    noErrorTruncation?: boolean;
+    allowSyntheticDefaultImports?: boolean;
+    noImplicitUseStrict?: boolean;
+    listEmittedFiles?: boolean;
+    disableSizeLimit?: boolean;
+    lib?: ('ES5' | 'ES6' | 'ES2015' | 'ES2015.Collection' | 'ES2015.Core' | 'ES2015.Generator' | 'ES2015.Iterable' | 'ES2015.Promise' | 'ES2015.Proxy' | 'ES2015.Reflect' | 'ES2015.Symbol.WellKnown' | 'ES2015.Symbol' | 'ES2016' | 'ES2016.Array.Include' | 'ES2017' | 'ES2017.Intl' | 'ES2017.Object' | 'ES2017.SharedMemory' | 'ES2017.String' | 'ES2017.TypedArrays' | 'ES2018' | 'ES2018.AsyncGenerator' | 'ES2018.AsyncIterable' | 'ES2018.Intl' | 'ES2018.Promise' | 'ES2018.Regexp' | 'ES2019' | 'ES2019.Array' | 'ES2019.Object' | 'ES2019.String' | 'ES2019.Symbol' | 'ES2020' | 'ES2020.BigInt' | 'ES2020.Promise' | 'ES2020.String' | 'ES2020.Symbol.WellKnown' | 'ESNext' | 'ESNext.Array' | 'ESNext.AsyncIterable' | 'ESNext.BigInt' | 'ESNext.Intl' | 'ESNext.Promise' | 'ESNext.String' | 'ESNext.Symbol' | 'DOM' | 'DOM.Iterable' | 'ScriptHost' | 'WebWorker' | 'WebWorker.ImportScripts')[];
+    strictNullChecks?: boolean;
+    maxNodeModuleJsDepth?: number;
+    importHelpers?: boolean;
+    importsNotUsedAsValues?: 'remove' | 'preserve' | 'error';
+    alwaysStrict?: boolean;
+    strict?: boolean;
+    strictBindCallApply?: boolean;
+    downlevelIteration?: boolean;
+    checkJs?: boolean;
+    strictFunctionTypes?: boolean;
+    strictPropertyInitialization?: boolean;
+    esModuleInterop?: boolean;
+    allowUmdGlobalAccess?: boolean;
+    keyofStringsOnly?: boolean;
+    useDefineForClassFields?: boolean;
+    declarationMap?: boolean;
+    resolveJsonModule?: boolean;
+    assumeChangesOnlyAffectDirectDependencies?: boolean;
+    extendedDiagnostics?: boolean;
+    listFilesOnly?: boolean;
+    disableSourceOfProjectReferenceRedirect?: boolean;
+    disableSolutionSearching?: boolean;
+    [k: string]: unknown;
+}

node_modules/ts-jest/dist/tsconfig-raw.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/ts-jest/dist/types.d.ts

@@ -1,76 +1,50 @@
-import * as _ts from 'typescript';
+import type { Config } from '@jest/types';
+import type * as _babel from 'babel__core';
+import type * as _ts from 'typescript';
+import type { RawCompilerOptions } from './tsconfig-raw';
+export declare type TTypeScript = typeof _ts;
+export declare type BabelConfig = _babel.TransformOptions;
+export interface AstTransformer<T = Record<string, unknown>> {
+    path: string;
+    options?: T;
+}
+export interface ConfigCustomTransformer {
+    before?: (string | AstTransformer)[];
+    after?: (string | AstTransformer)[];
+    afterDeclarations?: (string | AstTransformer)[];
+}
 export interface TsJestGlobalOptions {
-    tsConfig?: boolean | string | _ts.CompilerOptions;
+    tsConfig?: boolean | string | RawCompilerOptions;
-    tsconfig?: boolean | string | _ts.CompilerOptions;
+    tsconfig?: boolean | string | RawCompilerOptions;
-    packageJson?: boolean | string | object;
+    packageJson?: boolean | string | Record<string, unknown>;
     isolatedModules?: boolean;
     compiler?: string;
-    astTransformers?: string[];
+    astTransformers?: string[] | ConfigCustomTransformer;
     diagnostics?: boolean | {
         pretty?: boolean;
         ignoreCodes?: number | string | (number | string)[];
         pathRegex?: RegExp | string;
+        exclude?: Config.Glob[];
         warnOnly?: boolean;
     };
     babelConfig?: boolean | string | BabelConfig;
     stringifyContentPathRegex?: string | RegExp;
 }
-interface TsJestConfig$tsConfig$file {
+export interface GlobalConfigTsJest extends Config.ConfigGlobals {
-    kind: 'file';
+    'ts-jest': TsJestGlobalOptions;
-    value: string | undefined;
 }
-interface TsJestConfig$tsConfig$inline {
+export interface InitialOptionsTsJest extends Config.InitialOptions {
-    kind: 'inline';
+    globals?: GlobalConfigTsJest;
-    value: _ts.CompilerOptions;
 }
-declare type TsJestConfig$tsConfig = TsJestConfig$tsConfig$file | TsJestConfig$tsConfig$inline | undefined;
+export declare type TsJestPresets = Pick<Config.InitialOptions, 'moduleFileExtensions' | 'transform' | 'testMatch'>;
-interface TsJestConfig$diagnostics {
+export interface TsJestDiagnosticsCfg {
     pretty: boolean;
     ignoreCodes: number[];
     pathRegex?: string | undefined;
+    exclude: Config.Glob[];
     throws: boolean;
     warnOnly?: boolean;
 }
-interface TsJestConfig$babelConfig$file {
-    kind: 'file';
-    value: string | undefined;
-}
-interface TsJestConfig$babelConfig$inline {
-    kind: 'inline';
-    value: BabelConfig;
-}
-declare type TsJestConfig$babelConfig = TsJestConfig$babelConfig$file | TsJestConfig$babelConfig$inline | undefined;
-interface TsJestConfig$packageJson$file {
-    kind: 'file';
-    value: string | undefined;
-}
-interface TsJestConfig$packageJson$inline {
-    kind: 'inline';
-    value: any;
-}
-declare type TsJestConfig$packageJson = TsJestConfig$packageJson$file | TsJestConfig$packageJson$inline | undefined;
-declare type TsJestConfig$stringifyContentPathRegex = string | undefined;
-export interface TsJestConfig {
-    tsConfig: TsJestConfig$tsConfig;
-    packageJson: TsJestConfig$packageJson;
-    isolatedModules: boolean;
-    compiler: string;
-    diagnostics: TsJestConfig$diagnostics;
-    babelConfig: TsJestConfig$babelConfig;
-    transformers: string[];
-    stringifyContentPathRegex: TsJestConfig$stringifyContentPathRegex;
-}
 export interface TsCompiler {
     program: _ts.Program | undefined;
 }
-export declare type TSFiles = Map<string, TSFile>;
-export interface TSFile {
-    text?: string;
-    output?: string;
-    version: number;
-    projectReference?: {
-        project?: _ts.ResolvedProjectReference;
-        outputFileName?: string;
-    };
-}
-export {};

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

@@ -1,3 +0,0 @@
-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

@@ -1,8 +0,0 @@
-"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/json.d.ts

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

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

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

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

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

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

@@ -1,56 +0,0 @@
-"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' });
-exports.VersionCheckers = {
-    jest: createVersionChecker('jest', ">=25 <26"),
-    typescript: createVersionChecker('typescript', ">=3.4 <4"),
-    babelJest: createVersionChecker('babel-jest', ">=25 <26"),
-    babelCore: createVersionChecker('@babel/core', ">=7.0.0-beta.0 <8"),
-};
-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 ? "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;
-        },
-    };
-}

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

@@ -12,13 +12,16 @@ var __assign = (this && this.__assign) || function () {
 };
 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 constants_1 = require("../constants");
 var context = (_a = {}, _a[bs_logger_1.LogContexts.namespace] = 'backports', _a);
 exports.backportJestConfig = function (logger, config) {
+    var _a, _b;
     logger.debug(__assign(__assign({}, context), { config: config }), 'backporting config');
-    var _a = (config || {}).globals, globals = _a === void 0 ? {} : _a;
+    var _c = (config || {}).globals, globals = _c === void 0 ? {} : _c;
-    var _b = globals["ts-jest"], tsJest = _b === void 0 ? {} : _b;
+    var _d = globals["ts-jest"], tsJest = _d === void 0 ? {} : _d;
     var mergeTsJest = {};
     var hadWarnings = false;
     var warnConfig = function (oldPath, newPath, note) {
@@ -84,7 +87,7 @@ exports.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>.");
     }
-    return __assign(__assign({}, config), { globals: __assign(__assign({}, globals), { 'ts-jest': __assign(__assign({}, mergeTsJest), tsJest) }) });
+    return __assign(__assign({}, config), { testMatch: (_a = config.testMatch) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_JEST_TEST_MATCH, testRegex: (_b = config.testRegex) !== null && _b !== void 0 ? _b : [], globals: __assign(__assign({}, globals), { 'ts-jest': __assign(__assign({}, mergeTsJest), tsJest) }) });
 };
 exports.backportTsJestDebugEnvVar = function (logger) {
     if ('TS_JEST_DEBUG' in process.env) {

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

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

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

@@ -37,6 +37,7 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 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");
@@ -61,7 +62,7 @@ var Importer = (function () {
                 jest: [passThru(version_checkers_1.VersionCheckers.jest.warn)],
             });
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     Importer.prototype.babelJest = function (why) {

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = exports.parse = exports.stringify = void 0;
 var stableStringify = require("fast-json-stable-stringify");
 var UNDEFINED = 'undefined';
 function stringify(input) {

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

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

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

@@ -1,5 +1,6 @@
 "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;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memoize = void 0;
 var cacheProp = Symbol.for('[memoize]');
 function Memoize(keyBuilder) {
     return function (_, propertyKey, descriptor) {

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

@@ -1,5 +1,6 @@
 "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] : _); });

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

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

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

@@ -1,5 +1,6 @@
 "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() {

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

@@ -1,28 +1,28 @@
 /// <reference types="jest" />
-declare type MockableFunction = (...args: any[]) => any;
+export declare type MockableFunction = (...args: any[]) => any;
-declare type MethodKeysOf<T> = {
+export declare type MethodKeysOf<T> = {
     [K in keyof T]: T[K] extends MockableFunction ? K : never;
 }[keyof T];
-declare type PropertyKeysOf<T> = {
+export 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;
+export 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;
+export 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>> {
+export 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>> : {};
+export declare type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R ? jest.MockInstance<R, ConstructorArgumentsOf<T>> : T;
-declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
+export declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
     [K in keyof T]: T[K];
 };
-declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
+export declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
-declare type MockedObject<T> = MaybeMockedConstructor<T> & {
+export 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> & {
+export 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]>;
@@ -31,4 +31,3 @@ export declare type MaybeMockedDeep<T> = T extends MockableFunction ? MockedFunc
 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/utils/testing.js

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

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

@@ -3,7 +3,7 @@ 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]; };
+            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) {
@@ -13,6 +13,7 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSError = exports.INSPECT_CUSTOM = void 0;
 var make_error_1 = require("make-error");
 var util_1 = require("util");
 var logger_1 = require("./logger");

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', ">=26 <27"),
+    typescript: createVersionChecker('typescript', ">=3.8 <5"),
+    babelJest: createVersionChecker('babel-jest', ">=26 <27"),
+    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 = get_package_version_1.getPackageVersion(name);
+        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 ? "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;
+        },
+    };
+}

node_modules/ts-jest/jest-preset.js

@@ -1 +1 @@
-module.exports = require('./presets/default/jest-preset')
+module.exports = require('./presets').defaults

node_modules/ts-jest/node_modules/semver/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/ts-jest/node_modules/semver/README.md

@@ -0,0 +1,568 @@
+semver(1) -- The semantic versioner for npm
+===========================================
+
+## Install
+
+```bash
+npm install semver
+````
+
+## Usage
+
+As a node module:
+
+```js
+const semver = require('semver')
+
+semver.valid('1.2.3') // '1.2.3'
+semver.valid('a.b.c') // null
+semver.clean('  =v1.2.3   ') // '1.2.3'
+semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
+semver.gt('1.2.3', '9.8.7') // false
+semver.lt('1.2.3', '9.8.7') // true
+semver.minVersion('>=1.0.0') // '1.0.0'
+semver.valid(semver.coerce('v2')) // '2.0.0'
+semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
+```
+
+You can also just load the module for the function that you care about, if
+you'd like to minimize your footprint.
+
+```js
+// load the whole API at once in a single object
+const semver = require('semver')
+
+// or just load the bits you need
+// all of them listed here, just pick and choose what you want
+
+// classes
+const SemVer = require('semver/classes/semver')
+const Comparator = require('semver/classes/comparator')
+const Range = require('semver/classes/range')
+
+// functions for working with versions
+const semverParse = require('semver/functions/parse')
+const semverValid = require('semver/functions/valid')
+const semverClean = require('semver/functions/clean')
+const semverInc = require('semver/functions/inc')
+const semverDiff = require('semver/functions/diff')
+const semverMajor = require('semver/functions/major')
+const semverMinor = require('semver/functions/minor')
+const semverPatch = require('semver/functions/patch')
+const semverPrerelease = require('semver/functions/prerelease')
+const semverCompare = require('semver/functions/compare')
+const semverRcompare = require('semver/functions/rcompare')
+const semverCompareLoose = require('semver/functions/compare-loose')
+const semverCompareBuild = require('semver/functions/compare-build')
+const semverSort = require('semver/functions/sort')
+const semverRsort = require('semver/functions/rsort')
+
+// low-level comparators between versions
+const semverGt = require('semver/functions/gt')
+const semverLt = require('semver/functions/lt')
+const semverEq = require('semver/functions/eq')
+const semverNeq = require('semver/functions/neq')
+const semverGte = require('semver/functions/gte')
+const semverLte = require('semver/functions/lte')
+const semverCmp = require('semver/functions/cmp')
+const semverCoerce = require('semver/functions/coerce')
+
+// working with ranges
+const semverSatisfies = require('semver/functions/satisfies')
+const semverMaxSatisfying = require('semver/ranges/max-satisfying')
+const semverMinSatisfying = require('semver/ranges/min-satisfying')
+const semverToComparators = require('semver/ranges/to-comparators')
+const semverMinVersion = require('semver/ranges/min-version')
+const semverValidRange = require('semver/ranges/valid')
+const semverOutside = require('semver/ranges/outside')
+const semverGtr = require('semver/ranges/gtr')
+const semverLtr = require('semver/ranges/ltr')
+const semverIntersects = require('semver/ranges/intersects')
+const simplifyRange = require('semver/ranges/simplify')
+const rangeSubset = require('semver/ranges/subset')
+```
+
+As a command-line utility:
+
+```
+$ semver -h
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, or prerelease.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.
+```
+
+## Versions
+
+A "version" is described by the `v2.0.0` specification found at
+<https://semver.org/>.
+
+A leading `"="` or `"v"` character is stripped off and ignored.
+
+## Ranges
+
+A `version range` is a set of `comparators` which specify versions
+that satisfy the range.
+
+A `comparator` is composed of an `operator` and a `version`.  The set
+of primitive `operators` is:
+
+* `<` Less than
+* `<=` Less than or equal to
+* `>` Greater than
+* `>=` Greater than or equal to
+* `=` Equal.  If no operator is specified, then equality is assumed,
+  so this operator is optional, but MAY be included.
+
+For example, the comparator `>=1.2.7` would match the versions
+`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
+or `1.1.0`.
+
+Comparators can be joined by whitespace to form a `comparator set`,
+which is satisfied by the **intersection** of all of the comparators
+it includes.
+
+A range is composed of one or more comparator sets, joined by `||`.  A
+version matches a range if and only if every comparator in at least
+one of the `||`-separated comparator sets is satisfied by the version.
+
+For example, the range `>=1.2.7 <1.3.0` would match the versions
+`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
+or `1.1.0`.
+
+The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
+`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
+
+### Prerelease Tags
+
+If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
+it will only be allowed to satisfy comparator sets if at least one
+comparator with the same `[major, minor, patch]` tuple also has a
+prerelease tag.
+
+For example, the range `>1.2.3-alpha.3` would be allowed to match the
+version `1.2.3-alpha.7`, but it would *not* be satisfied by
+`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
+than" `1.2.3-alpha.3` according to the SemVer sort rules.  The version
+range only accepts prerelease tags on the `1.2.3` version.  The
+version `3.4.5` *would* satisfy the range, because it does not have a
+prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
+
+The purpose for this behavior is twofold.  First, prerelease versions
+frequently are updated very quickly, and contain many breaking changes
+that are (by the author's design) not yet fit for public consumption.
+Therefore, by default, they are excluded from range matching
+semantics.
+
+Second, a user who has opted into using a prerelease version has
+clearly indicated the intent to use *that specific* set of
+alpha/beta/rc versions.  By including a prerelease tag in the range,
+the user is indicating that they are aware of the risk.  However, it
+is still not appropriate to assume that they have opted into taking a
+similar risk on the *next* set of prerelease versions.
+
+Note that this behavior can be suppressed (treating all prerelease
+versions as if they were normal versions, for the purpose of range
+matching) by setting the `includePrerelease` flag on the options
+object to any
+[functions](https://github.com/npm/node-semver#functions) that do
+range matching.
+
+#### Prerelease Identifiers
+
+The method `.inc` takes an additional `identifier` string argument that
+will append the value of the string as a prerelease identifier:
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta')
+// '1.2.4-beta.0'
+```
+
+command-line example:
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta
+1.2.4-beta.0
+```
+
+Which then can be used to increment further:
+
+```bash
+$ semver 1.2.4-beta.0 -i prerelease
+1.2.4-beta.1
+```
+
+### Advanced Range Syntax
+
+Advanced range syntax desugars to primitive comparators in
+deterministic ways.
+
+Advanced ranges may be combined in the same way as primitive
+comparators using white space or `||`.
+
+#### Hyphen Ranges `X.Y.Z - A.B.C`
+
+Specifies an inclusive set.
+
+* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+
+If a partial version is provided as the first version in the inclusive
+range, then the missing pieces are replaced with zeroes.
+
+* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
+
+If a partial version is provided as the second version in the
+inclusive range, then all versions that start with the supplied parts
+of the tuple are accepted, but nothing that would be greater than the
+provided tuple parts.
+
+* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0-0`
+* `1.2.3 - 2` := `>=1.2.3 <3.0.0-0`
+
+#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
+
+Any of `X`, `x`, or `*` may be used to "stand in" for one of the
+numeric values in the `[major, minor, patch]` tuple.
+
+* `*` := `>=0.0.0` (Any non-prerelease version satisfies, unless
+  `includePrerelease` is specified, in which case any version at all
+  satisfies)
+* `1.x` := `>=1.0.0 <2.0.0-0` (Matching major version)
+* `1.2.x` := `>=1.2.0 <1.3.0-0` (Matching major and minor versions)
+
+A partial version range is treated as an X-Range, so the special
+character is in fact optional.
+
+* `""` (empty string) := `*` := `>=0.0.0`
+* `1` := `1.x.x` := `>=1.0.0 <2.0.0-0`
+* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0-0`
+
+#### Tilde Ranges `~1.2.3` `~1.2` `~1`
+
+Allows patch-level changes if a minor version is specified on the
+comparator.  Allows minor-level changes if not.
+
+* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0-0`
+* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0-0` (Same as `1.2.x`)
+* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0-0` (Same as `1.x`)
+* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0-0`
+* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0-0` (Same as `0.2.x`)
+* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0-0` (Same as `0.x`)
+* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0-0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+
+#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
+
+Allows changes that do not modify the left-most non-zero element in the
+`[major, minor, patch]` tuple.  In other words, this allows patch and
+minor updates for versions `1.0.0` and above, patch updates for
+versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
+
+Many authors treat a `0.x` version as if the `x` were the major
+"breaking-change" indicator.
+
+Caret ranges are ideal when an author may make breaking changes
+between `0.2.4` and `0.3.0` releases, which is a common practice.
+However, it presumes that there will *not* be breaking changes between
+`0.2.4` and `0.2.5`.  It allows for changes that are presumed to be
+additive (but non-breaking), according to commonly observed practices.
+
+* `^1.2.3` := `>=1.2.3 <2.0.0-0`
+* `^0.2.3` := `>=0.2.3 <0.3.0-0`
+* `^0.0.3` := `>=0.0.3 <0.0.4-0`
+* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0-0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4-0`  Note that prereleases in the
+  `0.0.3` version *only* will be allowed, if they are greater than or
+  equal to `beta`.  So, `0.0.3-pr.2` would be allowed.
+
+When parsing caret ranges, a missing `patch` value desugars to the
+number `0`, but will allow flexibility within that value, even if the
+major and minor versions are both `0`.
+
+* `^1.2.x` := `>=1.2.0 <2.0.0-0`
+* `^0.0.x` := `>=0.0.0 <0.1.0-0`
+* `^0.0` := `>=0.0.0 <0.1.0-0`
+
+A missing `minor` and `patch` values will desugar to zero, but also
+allow flexibility within those values, even if the major version is
+zero.
+
+* `^1.x` := `>=1.0.0 <2.0.0-0`
+* `^0.x` := `>=0.0.0 <1.0.0-0`
+
+### Range Grammar
+
+Putting all this together, here is a Backus-Naur grammar for ranges,
+for the benefit of parser authors:
+
+```bnf
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+
+```
+
+## Functions
+
+All methods and classes take a final `options` object argument.  All
+options in this object are `false` by default.  The options supported
+are:
+
+- `loose`  Be more forgiving about not-quite-valid semver strings.
+  (Any resulting output will always be 100% strict compliant, of
+  course.)  For backwards compatibility reasons, if the `options`
+  argument is a boolean value instead of an object, it is interpreted
+  to be the `loose` param.
+- `includePrerelease`  Set to suppress the [default
+  behavior](https://github.com/npm/node-semver#prerelease-tags) of
+  excluding prerelease tagged versions from ranges unless they are
+  explicitly opted into.
+
+Strict-mode Comparators and Ranges will be strict about the SemVer
+strings that they parse.
+
+* `valid(v)`: Return the parsed version, or null if it's not valid.
+* `inc(v, release)`: Return the version incremented by the release
+  type (`major`,   `premajor`, `minor`, `preminor`, `patch`,
+  `prepatch`, or `prerelease`), or null if it's not valid
+  * `premajor` in one call will bump the version up to the next major
+    version and down to a prerelease of that major version.
+    `preminor`, and `prepatch` work the same way.
+  * If called from a non-prerelease version, the `prerelease` will work the
+    same as `prepatch`. It increments the patch version, then makes a
+    prerelease. If the input version is already a prerelease it simply
+    increments it.
+* `prerelease(v)`: Returns an array of prerelease components, or null
+  if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
+* `major(v)`: Return the major version number.
+* `minor(v)`: Return the minor version number.
+* `patch(v)`: Return the patch version number.
+* `intersects(r1, r2, loose)`: Return true if the two supplied ranges
+  or comparators intersect.
+* `parse(v)`: Attempt to parse a string as a semantic version, returning either
+  a `SemVer` object or `null`.
+
+### Comparison
+
+* `gt(v1, v2)`: `v1 > v2`
+* `gte(v1, v2)`: `v1 >= v2`
+* `lt(v1, v2)`: `v1 < v2`
+* `lte(v1, v2)`: `v1 <= v2`
+* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
+  even if they're not the exact same string.  You already know how to
+  compare strings.
+* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
+* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
+  the corresponding function above.  `"==="` and `"!=="` do simple
+  string comparison, but are included for completeness.  Throws if an
+  invalid comparison string is provided.
+* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
+* `rcompare(v1, v2)`: The reverse of compare.  Sorts an array of versions
+  in descending order when passed to `Array.sort()`.
+* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions
+  are equal.  Sorts in ascending order if passed to `Array.sort()`.
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
+* `diff(v1, v2)`: Returns difference between two versions by the release type
+  (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
+  or null if the versions are the same.
+
+### Comparators
+
+* `intersects(comparator)`: Return true if the comparators intersect
+
+### Ranges
+
+* `validRange(range)`: Return the valid range or null if it's not valid
+* `satisfies(version, range)`: Return true if the version satisfies the
+  range.
+* `maxSatisfying(versions, range)`: Return the highest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minSatisfying(versions, range)`: Return the lowest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minVersion(range)`: Return the lowest version that can possibly match
+  the given range.
+* `gtr(version, range)`: Return `true` if version is greater than all the
+  versions possible in the range.
+* `ltr(version, range)`: Return `true` if version is less than all the
+  versions possible in the range.
+* `outside(version, range, hilo)`: Return true if the version is outside
+  the bounds of the range in either the high or low direction.  The
+  `hilo` argument must be either the string `'>'` or `'<'`.  (This is
+  the function called by `gtr` and `ltr`.)
+* `intersects(range)`: Return true if any of the ranges comparators intersect
+* `simplifyRange(versions, range)`: Return a "simplified" range that
+  matches the same items in `versions` list as the range specified.  Note
+  that it does *not* guarantee that it would match the same versions in all
+  cases, only for the set of versions provided.  This is useful when
+  generating ranges by joining together multiple versions with `||`
+  programmatically, to provide the user with something a bit more
+  ergonomic.  If the provided range is shorter in string-length than the
+  generated range, then that is returned.
+* `subset(subRange, superRange)`: Return `true` if the `subRange` range is
+  entirely contained by the `superRange` range.
+
+Note that, since ranges may be non-contiguous, a version might not be
+greater than a range, less than a range, *or* satisfy a range!  For
+example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
+until `2.0.0`, so the version `1.2.10` would not be greater than the
+range (because `2.0.1` satisfies, which is higher), nor less than the
+range (since `1.2.8` satisfies, which is lower), and it also does not
+satisfy the range.
+
+If you want to know if a version satisfies or does not satisfy a
+range, use the `satisfies(version, range)` function.
+
+### Coercion
+
+* `coerce(version, options)`: Coerces a string to semver if possible
+
+This aims to provide a very forgiving translation of a non-semver string to
+semver. It looks for the first digit in a string, and consumes all
+remaining characters which satisfy at least a partial semver (e.g., `1`,
+`1.2`, `1.2.3`) up to the max permitted length (256 characters).  Longer
+versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).  All
+surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
+`3.4.0`).  Only text which lacks digits will fail coercion (`version one`
+is not valid).  The maximum  length for any semver component considered for
+coercion is 16 characters; longer components will be ignored
+(`10000000000000000.4.7.4` becomes `4.7.4`).  The maximum value for any
+semver component is `Number.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+components are invalid (`9999999999999999.4.7.4` is likely invalid).
+
+If the `options.rtl` flag is set, then `coerce` will return the right-most
+coercible tuple that does not share an ending index with a longer coercible
+tuple.  For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
+`4.0.0`.  `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
+any other overlapping SemVer tuple.
+
+### Clean
+
+* `clean(version)`: Clean a string to be a valid semver if possible
+
+This will return a cleaned and trimmed semver version. If the provided
+version is not valid a null will be returned. This does not work for
+ranges.
+
+ex.
+* `s.clean(' = v 2.1.5foo')`: `null`
+* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean(' = v 2.1.5-foo')`: `null`
+* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean('=v2.1.5')`: `'2.1.5'`
+* `s.clean('  =v2.1.5')`: `2.1.5`
+* `s.clean('      2.1.5   ')`: `'2.1.5'`
+* `s.clean('~1.0.0')`: `null`
+
+## Exported Modules
+
+<!--
+TODO: Make sure that all of these items are documented (classes aren't,
+eg), and then pull the module name into the documentation for that specific
+thing.
+-->
+
+You may pull in just the part of this semver utility that you need, if you
+are sensitive to packing and tree-shaking concerns.  The main
+`require('semver')` export uses getter functions to lazily load the parts
+of the API that are used.
+
+The following modules are available:
+
+* `require('semver')`
+* `require('semver/classes')`
+* `require('semver/classes/comparator')`
+* `require('semver/classes/range')`
+* `require('semver/classes/semver')`
+* `require('semver/functions/clean')`
+* `require('semver/functions/cmp')`
+* `require('semver/functions/coerce')`
+* `require('semver/functions/compare')`
+* `require('semver/functions/compare-build')`
+* `require('semver/functions/compare-loose')`
+* `require('semver/functions/diff')`
+* `require('semver/functions/eq')`
+* `require('semver/functions/gt')`
+* `require('semver/functions/gte')`
+* `require('semver/functions/inc')`
+* `require('semver/functions/lt')`
+* `require('semver/functions/lte')`
+* `require('semver/functions/major')`
+* `require('semver/functions/minor')`
+* `require('semver/functions/neq')`
+* `require('semver/functions/parse')`
+* `require('semver/functions/patch')`
+* `require('semver/functions/prerelease')`
+* `require('semver/functions/rcompare')`
+* `require('semver/functions/rsort')`
+* `require('semver/functions/satisfies')`
+* `require('semver/functions/sort')`
+* `require('semver/functions/valid')`
+* `require('semver/ranges/gtr')`
+* `require('semver/ranges/intersects')`
+* `require('semver/ranges/ltr')`
+* `require('semver/ranges/max-satisfying')`
+* `require('semver/ranges/min-satisfying')`
+* `require('semver/ranges/min-version')`
+* `require('semver/ranges/outside')`
+* `require('semver/ranges/to-comparators')`
+* `require('semver/ranges/valid')`

node_modules/ts-jest/node_modules/semver/bin/semver.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+const argv = process.argv.slice(2)
+
+let versions = []
+
+const range = []
+
+let inc = null
+
+const version = require('../package.json').version
+
+let loose = false
+
+let includePrerelease = false
+
+let coerce = false
+
+let rtl = false
+
+let identifier
+
+const semver = require('../')
+
+let reverse = false
+
+let options = {}
+
+const main = () => {
+  if (!argv.length) {
+    return help()
+  }
+  while (argv.length) {
+    let a = argv.shift()
+    const indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      const value = a.slice(indexOfEqualSign + 1)
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(value)
+    }
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        switch (argv[0]) {
+          case 'major': case 'minor': case 'patch': case 'prerelease':
+          case 'premajor': case 'preminor': case 'prepatch':
+            inc = argv.shift()
+            break
+          default:
+            inc = 'patch'
+            break
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '--rtl':
+        rtl = true
+        break
+      case '--ltr':
+        rtl = false
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }
+
+  versions = versions.map((v) => {
+    return coerce ? (semver.coerce(v, options) || { version: v }).version : v
+  }).filter((v) => {
+    return semver.valid(v)
+  })
+  if (!versions.length) {
+    return fail()
+  }
+  if (inc && (versions.length !== 1 || range.length)) {
+    return failInc()
+  }
+
+  for (let i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter((v) => {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) {
+      return fail()
+    }
+  }
+  return success(versions)
+}
+
+const failInc = () => {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+const fail = () => process.exit(1)
+
+const success = () => {
+  const compare = reverse ? 'rcompare' : 'compare'
+  versions.sort((a, b) => {
+    return semver[compare](a, b, options)
+  }).map((v) => {
+    return semver.clean(v, options)
+  }).map((v) => {
+    return inc ? semver.inc(v, inc, options, identifier) : v
+  }).forEach((v, i, _) => {
+    console.log(v)
+  })
+}
+
+const help = () => console.log(
+`SemVer ${version}
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, or prerelease.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.`)
+
+main()

node_modules/ts-jest/node_modules/semver/classes/comparator.js

@@ -0,0 +1,136 @@
+const ANY = Symbol('SemVer ANY')
+// hoisted class for cyclic dependency
+class Comparator {
+  static get ANY () {
+    return ANY
+  }
+
+  constructor (comp, options) {
+    options = parseOptions(options)
+
+    if (comp instanceof Comparator) {
+      if (comp.loose === !!options.loose) {
+        return comp
+      } else {
+        comp = comp.value
+      }
+    }
+
+    debug('comparator', comp, options)
+    this.options = options
+    this.loose = !!options.loose
+    this.parse(comp)
+
+    if (this.semver === ANY) {
+      this.value = ''
+    } else {
+      this.value = this.operator + this.semver.version
+    }
+
+    debug('comp', this)
+  }
+
+  parse (comp) {
+    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
+    const m = comp.match(r)
+
+    if (!m) {
+      throw new TypeError(`Invalid comparator: ${comp}`)
+    }
+
+    this.operator = m[1] !== undefined ? m[1] : ''
+    if (this.operator === '=') {
+      this.operator = ''
+    }
+
+    // if it literally is just '>' or '' then allow anything.
+    if (!m[2]) {
+      this.semver = ANY
+    } else {
+      this.semver = new SemVer(m[2], this.options.loose)
+    }
+  }
+
+  toString () {
+    return this.value
+  }
+
+  test (version) {
+    debug('Comparator.test', version, this.options.loose)
+
+    if (this.semver === ANY || version === ANY) {
+      return true
+    }
+
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options)
+      } catch (er) {
+        return false
+      }
+    }
+
+    return cmp(version, this.operator, this.semver, this.options)
+  }
+
+  intersects (comp, options) {
+    if (!(comp instanceof Comparator)) {
+      throw new TypeError('a Comparator is required')
+    }
+
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false,
+      }
+    }
+
+    if (this.operator === '') {
+      if (this.value === '') {
+        return true
+      }
+      return new Range(comp.value, options).test(this.value)
+    } else if (comp.operator === '') {
+      if (comp.value === '') {
+        return true
+      }
+      return new Range(this.value, options).test(comp.semver)
+    }
+
+    const sameDirectionIncreasing =
+      (this.operator === '>=' || this.operator === '>') &&
+      (comp.operator === '>=' || comp.operator === '>')
+    const sameDirectionDecreasing =
+      (this.operator === '<=' || this.operator === '<') &&
+      (comp.operator === '<=' || comp.operator === '<')
+    const sameSemVer = this.semver.version === comp.semver.version
+    const differentDirectionsInclusive =
+      (this.operator === '>=' || this.operator === '<=') &&
+      (comp.operator === '>=' || comp.operator === '<=')
+    const oppositeDirectionsLessThan =
+      cmp(this.semver, '<', comp.semver, options) &&
+      (this.operator === '>=' || this.operator === '>') &&
+        (comp.operator === '<=' || comp.operator === '<')
+    const oppositeDirectionsGreaterThan =
+      cmp(this.semver, '>', comp.semver, options) &&
+      (this.operator === '<=' || this.operator === '<') &&
+        (comp.operator === '>=' || comp.operator === '>')
+
+    return (
+      sameDirectionIncreasing ||
+      sameDirectionDecreasing ||
+      (sameSemVer && differentDirectionsInclusive) ||
+      oppositeDirectionsLessThan ||
+      oppositeDirectionsGreaterThan
+    )
+  }
+}
+
+module.exports = Comparator
+
+const parseOptions = require('../internal/parse-options')
+const { re, t } = require('../internal/re')
+const cmp = require('../functions/cmp')
+const debug = require('../internal/debug')
+const SemVer = require('./semver')
+const Range = require('./range')

node_modules/ts-jest/node_modules/semver/classes/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  SemVer: require('./semver.js'),
+  Range: require('./range.js'),
+  Comparator: require('./comparator.js'),
+}

node_modules/ts-jest/node_modules/semver/classes/range.js

@@ -0,0 +1,519 @@
+// hoisted class for cyclic dependency
+class Range {
+  constructor (range, options) {
+    options = parseOptions(options)
+
+    if (range instanceof Range) {
+      if (
+        range.loose === !!options.loose &&
+        range.includePrerelease === !!options.includePrerelease
+      ) {
+        return range
+      } else {
+        return new Range(range.raw, options)
+      }
+    }
+
+    if (range instanceof Comparator) {
+      // just put it in the set and return
+      this.raw = range.value
+      this.set = [[range]]
+      this.format()
+      return this
+    }
+
+    this.options = options
+    this.loose = !!options.loose
+    this.includePrerelease = !!options.includePrerelease
+
+    // First, split based on boolean or ||
+    this.raw = range
+    this.set = range
+      .split('||')
+      // map the range to a 2d array of comparators
+      .map(r => this.parseRange(r.trim()))
+      // throw out any comparator lists that are empty
+      // this generally means that it was not a valid range, which is allowed
+      // in loose mode, but will still throw if the WHOLE range is invalid.
+      .filter(c => c.length)
+
+    if (!this.set.length) {
+      throw new TypeError(`Invalid SemVer Range: ${range}`)
+    }
+
+    // if we have any that are not the null set, throw out null sets.
+    if (this.set.length > 1) {
+      // keep the first one, in case they're all null sets
+      const first = this.set[0]
+      this.set = this.set.filter(c => !isNullSet(c[0]))
+      if (this.set.length === 0) {
+        this.set = [first]
+      } else if (this.set.length > 1) {
+        // if we have any that are *, then the range is just *
+        for (const c of this.set) {
+          if (c.length === 1 && isAny(c[0])) {
+            this.set = [c]
+            break
+          }
+        }
+      }
+    }
+
+    this.format()
+  }
+
+  format () {
+    this.range = this.set
+      .map((comps) => {
+        return comps.join(' ').trim()
+      })
+      .join('||')
+      .trim()
+    return this.range
+  }
+
+  toString () {
+    return this.range
+  }
+
+  parseRange (range) {
+    range = range.trim()
+
+    // memoize range parsing for performance.
+    // this is a very hot path, and fully deterministic.
+    const memoOpts = Object.keys(this.options).join(',')
+    const memoKey = `parseRange:${memoOpts}:${range}`
+    const cached = cache.get(memoKey)
+    if (cached) {
+      return cached
+    }
+
+    const loose = this.options.loose
+    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
+    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))
+    debug('hyphen replace', range)
+    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
+    debug('comparator trim', range)
+
+    // `~ 1.2.3` => `~1.2.3`
+    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
+
+    // `^ 1.2.3` => `^1.2.3`
+    range = range.replace(re[t.CARETTRIM], caretTrimReplace)
+
+    // normalize spaces
+    range = range.split(/\s+/).join(' ')
+
+    // At this point, the range is completely trimmed and
+    // ready to be split into comparators.
+
+    let rangeList = range
+      .split(' ')
+      .map(comp => parseComparator(comp, this.options))
+      .join(' ')
+      .split(/\s+/)
+      // >=0.0.0 is equivalent to *
+      .map(comp => replaceGTE0(comp, this.options))
+
+    if (loose) {
+      // in loose mode, throw out any that are not valid comparators
+      rangeList = rangeList.filter(comp => {
+        debug('loose invalid filter', comp, this.options)
+        return !!comp.match(re[t.COMPARATORLOOSE])
+      })
+    }
+    debug('range list', rangeList)
+
+    // if any comparators are the null set, then replace with JUST null set
+    // if more than one comparator, remove any * comparators
+    // also, don't include the same comparator more than once
+    const rangeMap = new Map()
+    const comparators = rangeList.map(comp => new Comparator(comp, this.options))
+    for (const comp of comparators) {
+      if (isNullSet(comp)) {
+        return [comp]
+      }
+      rangeMap.set(comp.value, comp)
+    }
+    if (rangeMap.size > 1 && rangeMap.has('')) {
+      rangeMap.delete('')
+    }
+
+    const result = [...rangeMap.values()]
+    cache.set(memoKey, result)
+    return result
+  }
+
+  intersects (range, options) {
+    if (!(range instanceof Range)) {
+      throw new TypeError('a Range is required')
+    }
+
+    return this.set.some((thisComparators) => {
+      return (
+        isSatisfiable(thisComparators, options) &&
+        range.set.some((rangeComparators) => {
+          return (
+            isSatisfiable(rangeComparators, options) &&
+            thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options)
+              })
+            })
+          )
+        })
+      )
+    })
+  }
+
+  // if ANY of the sets match ALL of its comparators, then pass
+  test (version) {
+    if (!version) {
+      return false
+    }
+
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options)
+      } catch (er) {
+        return false
+      }
+    }
+
+    for (let i = 0; i < this.set.length; i++) {
+      if (testSet(this.set[i], version, this.options)) {
+        return true
+      }
+    }
+    return false
+  }
+}
+module.exports = Range
+
+const LRU = require('lru-cache')
+const cache = new LRU({ max: 1000 })
+
+const parseOptions = require('../internal/parse-options')
+const Comparator = require('./comparator')
+const debug = require('../internal/debug')
+const SemVer = require('./semver')
+const {
+  re,
+  t,
+  comparatorTrimReplace,
+  tildeTrimReplace,
+  caretTrimReplace,
+} = require('../internal/re')
+
+const isNullSet = c => c.value === '<0.0.0-0'
+const isAny = c => c.value === ''
+
+// take a set of comparators and determine whether there
+// exists a version which can satisfy it
+const isSatisfiable = (comparators, options) => {
+  let result = true
+  const remainingComparators = comparators.slice()
+  let testComparator = remainingComparators.pop()
+
+  while (result && remainingComparators.length) {
+    result = remainingComparators.every((otherComparator) => {
+      return testComparator.intersects(otherComparator, options)
+    })
+
+    testComparator = remainingComparators.pop()
+  }
+
+  return result
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+const parseComparator = (comp, options) => {
+  debug('comp', comp, options)
+  comp = replaceCarets(comp, options)
+  debug('caret', comp)
+  comp = replaceTildes(comp, options)
+  debug('tildes', comp)
+  comp = replaceXRanges(comp, options)
+  debug('xrange', comp)
+  comp = replaceStars(comp, options)
+  debug('stars', comp)
+  return comp
+}
+
+const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+const replaceTildes = (comp, options) =>
+  comp.trim().split(/\s+/).map((c) => {
+    return replaceTilde(c, options)
+  }).join(' ')
+
+const replaceTilde = (comp, options) => {
+  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug('tilde', comp, _, M, m, p, pr)
+    let ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
+    } else if (isX(p)) {
+      // ~1.2 == >=1.2.0 <1.3.0-0
+      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
+    } else if (pr) {
+      debug('replaceTilde pr', pr)
+      ret = `>=${M}.${m}.${p}-${pr
+      } <${M}.${+m + 1}.0-0`
+    } else {
+      // ~1.2.3 == >=1.2.3 <1.3.0-0
+      ret = `>=${M}.${m}.${p
+      } <${M}.${+m + 1}.0-0`
+    }
+
+    debug('tilde return', ret)
+    return ret
+  })
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+// ^1.2.3 --> >=1.2.3 <2.0.0-0
+// ^1.2.0 --> >=1.2.0 <2.0.0-0
+const replaceCarets = (comp, options) =>
+  comp.trim().split(/\s+/).map((c) => {
+    return replaceCaret(c, options)
+  }).join(' ')
+
+const replaceCaret = (comp, options) => {
+  debug('caret', comp, options)
+  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
+  const z = options.includePrerelease ? '-0' : ''
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug('caret', comp, _, M, m, p, pr)
+    let ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
+    } else if (isX(p)) {
+      if (M === '0') {
+        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
+      } else {
+        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`
+      }
+    } else if (pr) {
+      debug('replaceCaret pr', pr)
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${m}.${+p + 1}-0`
+        } else {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${+m + 1}.0-0`
+        }
+      } else {
+        ret = `>=${M}.${m}.${p}-${pr
+        } <${+M + 1}.0.0-0`
+      }
+    } else {
+      debug('no pr')
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${m}.${+p + 1}-0`
+        } else {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${+m + 1}.0-0`
+        }
+      } else {
+        ret = `>=${M}.${m}.${p
+        } <${+M + 1}.0.0-0`
+      }
+    }
+
+    debug('caret return', ret)
+    return ret
+  })
+}
+
+const replaceXRanges = (comp, options) => {
+  debug('replaceXRanges', comp, options)
+  return comp.split(/\s+/).map((c) => {
+    return replaceXRange(c, options)
+  }).join(' ')
+}
+
+const replaceXRange = (comp, options) => {
+  comp = comp.trim()
+  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
+  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+    debug('xRange', comp, ret, gtlt, M, m, p, pr)
+    const xM = isX(M)
+    const xm = xM || isX(m)
+    const xp = xm || isX(p)
+    const anyX = xp
+
+    if (gtlt === '=' && anyX) {
+      gtlt = ''
+    }
+
+    // if we're including prereleases in the match, then we need
+    // to fix this to -0, the lowest possible prerelease value
+    pr = options.includePrerelease ? '-0' : ''
+
+    if (xM) {
+      if (gtlt === '>' || gtlt === '<') {
+        // nothing is allowed
+        ret = '<0.0.0-0'
+      } else {
+        // nothing is forbidden
+        ret = '*'
+      }
+    } else if (gtlt && anyX) {
+      // we know patch is an x, because we have any x at all.
+      // replace X with 0
+      if (xm) {
+        m = 0
+      }
+      p = 0
+
+      if (gtlt === '>') {
+        // >1 => >=2.0.0
+        // >1.2 => >=1.3.0
+        gtlt = '>='
+        if (xm) {
+          M = +M + 1
+          m = 0
+          p = 0
+        } else {
+          m = +m + 1
+          p = 0
+        }
+      } else if (gtlt === '<=') {
+        // <=0.7.x is actually <0.8.0, since any 0.7.x should
+        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+        gtlt = '<'
+        if (xm) {
+          M = +M + 1
+        } else {
+          m = +m + 1
+        }
+      }
+
+      if (gtlt === '<') {
+        pr = '-0'
+      }
+
+      ret = `${gtlt + M}.${m}.${p}${pr}`
+    } else if (xm) {
+      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`
+    } else if (xp) {
+      ret = `>=${M}.${m}.0${pr
+      } <${M}.${+m + 1}.0-0`
+    }
+
+    debug('xRange return', ret)
+
+    return ret
+  })
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+const replaceStars = (comp, options) => {
+  debug('replaceStars', comp, options)
+  // Looseness is ignored here.  star is always as loose as it gets!
+  return comp.trim().replace(re[t.STAR], '')
+}
+
+const replaceGTE0 = (comp, options) => {
+  debug('replaceGTE0', comp, options)
+  return comp.trim()
+    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
+}
+
+// This function is passed to string.replace(re[t.HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
+const hyphenReplace = incPr => ($0,
+  from, fM, fm, fp, fpr, fb,
+  to, tM, tm, tp, tpr, tb) => {
+  if (isX(fM)) {
+    from = ''
+  } else if (isX(fm)) {
+    from = `>=${fM}.0.0${incPr ? '-0' : ''}`
+  } else if (isX(fp)) {
+    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`
+  } else if (fpr) {
+    from = `>=${from}`
+  } else {
+    from = `>=${from}${incPr ? '-0' : ''}`
+  }
+
+  if (isX(tM)) {
+    to = ''
+  } else if (isX(tm)) {
+    to = `<${+tM + 1}.0.0-0`
+  } else if (isX(tp)) {
+    to = `<${tM}.${+tm + 1}.0-0`
+  } else if (tpr) {
+    to = `<=${tM}.${tm}.${tp}-${tpr}`
+  } else if (incPr) {
+    to = `<${tM}.${tm}.${+tp + 1}-0`
+  } else {
+    to = `<=${to}`
+  }
+
+  return (`${from} ${to}`).trim()
+}
+
+const testSet = (set, version, options) => {
+  for (let i = 0; i < set.length; i++) {
+    if (!set[i].test(version)) {
+      return false
+    }
+  }
+
+  if (version.prerelease.length && !options.includePrerelease) {
+    // Find the set of versions that are allowed to have prereleases
+    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+    // That should allow `1.2.3-pr.2` to pass.
+    // However, `1.2.4-alpha.notready` should NOT be allowed,
+    // even though it's within the range set by the comparators.
+    for (let i = 0; i < set.length; i++) {
+      debug(set[i].semver)
+      if (set[i].semver === Comparator.ANY) {
+        continue
+      }
+
+      if (set[i].semver.prerelease.length > 0) {
+        const allowed = set[i].semver
+        if (allowed.major === version.major &&
+            allowed.minor === version.minor &&
+            allowed.patch === version.patch) {
+          return true
+        }
+      }
+    }
+
+    // Version has a -pre, but it's not one of the ones we like.
+    return false
+  }
+
+  return true
+}

node_modules/ts-jest/node_modules/semver/classes/semver.js

@@ -0,0 +1,287 @@
+const debug = require('../internal/debug')
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')
+const { re, t } = require('../internal/re')
+
+const parseOptions = require('../internal/parse-options')
+const { compareIdentifiers } = require('../internal/identifiers')
+class SemVer {
+  constructor (version, options) {
+    options = parseOptions(options)
+
+    if (version instanceof SemVer) {
+      if (version.loose === !!options.loose &&
+          version.includePrerelease === !!options.includePrerelease) {
+        return version
+      } else {
+        version = version.version
+      }
+    } else if (typeof version !== 'string') {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
+
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH} characters`
+      )
+    }
+
+    debug('SemVer', version, options)
+    this.options = options
+    this.loose = !!options.loose
+    // this isn't actually relevant for versions, but keep it so that we
+    // don't run into trouble passing this.options around.
+    this.includePrerelease = !!options.includePrerelease
+
+    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
+
+    if (!m) {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
+
+    this.raw = version
+
+    // these are actually numbers
+    this.major = +m[1]
+    this.minor = +m[2]
+    this.patch = +m[3]
+
+    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+      throw new TypeError('Invalid major version')
+    }
+
+    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+      throw new TypeError('Invalid minor version')
+    }
+
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError('Invalid patch version')
+    }
+
+    // numberify any prerelease numeric ids
+    if (!m[4]) {
+      this.prerelease = []
+    } else {
+      this.prerelease = m[4].split('.').map((id) => {
+        if (/^[0-9]+$/.test(id)) {
+          const num = +id
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num
+          }
+        }
+        return id
+      })
+    }
+
+    this.build = m[5] ? m[5].split('.') : []
+    this.format()
+  }
+
+  format () {
+    this.version = `${this.major}.${this.minor}.${this.patch}`
+    if (this.prerelease.length) {
+      this.version += `-${this.prerelease.join('.')}`
+    }
+    return this.version
+  }
+
+  toString () {
+    return this.version
+  }
+
+  compare (other) {
+    debug('SemVer.compare', this.version, this.options, other)
+    if (!(other instanceof SemVer)) {
+      if (typeof other === 'string' && other === this.version) {
+        return 0
+      }
+      other = new SemVer(other, this.options)
+    }
+
+    if (other.version === this.version) {
+      return 0
+    }
+
+    return this.compareMain(other) || this.comparePre(other)
+  }
+
+  compareMain (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    return (
+      compareIdentifiers(this.major, other.major) ||
+      compareIdentifiers(this.minor, other.minor) ||
+      compareIdentifiers(this.patch, other.patch)
+    )
+  }
+
+  comparePre (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    // NOT having a prerelease is > having one
+    if (this.prerelease.length && !other.prerelease.length) {
+      return -1
+    } else if (!this.prerelease.length && other.prerelease.length) {
+      return 1
+    } else if (!this.prerelease.length && !other.prerelease.length) {
+      return 0
+    }
+
+    let i = 0
+    do {
+      const a = this.prerelease[i]
+      const b = other.prerelease[i]
+      debug('prerelease compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  compareBuild (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    let i = 0
+    do {
+      const a = this.build[i]
+      const b = other.build[i]
+      debug('prerelease compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  inc (release, identifier) {
+    switch (release) {
+      case 'premajor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor = 0
+        this.major++
+        this.inc('pre', identifier)
+        break
+      case 'preminor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor++
+        this.inc('pre', identifier)
+        break
+      case 'prepatch':
+        // If this is already a prerelease, it will bump to the next version
+        // drop any prereleases that might already exist, since they are not
+        // relevant at this point.
+        this.prerelease.length = 0
+        this.inc('patch', identifier)
+        this.inc('pre', identifier)
+        break
+      // If the input is a non-prerelease version, this acts the same as
+      // prepatch.
+      case 'prerelease':
+        if (this.prerelease.length === 0) {
+          this.inc('patch', identifier)
+        }
+        this.inc('pre', identifier)
+        break
+
+      case 'major':
+        // If this is a pre-major version, bump up to the same major version.
+        // Otherwise increment major.
+        // 1.0.0-5 bumps to 1.0.0
+        // 1.1.0 bumps to 2.0.0
+        if (
+          this.minor !== 0 ||
+          this.patch !== 0 ||
+          this.prerelease.length === 0
+        ) {
+          this.major++
+        }
+        this.minor = 0
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'minor':
+        // If this is a pre-minor version, bump up to the same minor version.
+        // Otherwise increment minor.
+        // 1.2.0-5 bumps to 1.2.0
+        // 1.2.1 bumps to 1.3.0
+        if (this.patch !== 0 || this.prerelease.length === 0) {
+          this.minor++
+        }
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'patch':
+        // If this is not a pre-release version, it will increment the patch.
+        // If it is a pre-release it will bump up to the same patch version.
+        // 1.2.0-5 patches to 1.2.0
+        // 1.2.0 patches to 1.2.1
+        if (this.prerelease.length === 0) {
+          this.patch++
+        }
+        this.prerelease = []
+        break
+      // This probably shouldn't be used publicly.
+      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+      case 'pre':
+        if (this.prerelease.length === 0) {
+          this.prerelease = [0]
+        } else {
+          let i = this.prerelease.length
+          while (--i >= 0) {
+            if (typeof this.prerelease[i] === 'number') {
+              this.prerelease[i]++
+              i = -2
+            }
+          }
+          if (i === -1) {
+            // didn't increment anything
+            this.prerelease.push(0)
+          }
+        }
+        if (identifier) {
+          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = [identifier, 0]
+            }
+          } else {
+            this.prerelease = [identifier, 0]
+          }
+        }
+        break
+
+      default:
+        throw new Error(`invalid increment argument: ${release}`)
+    }
+    this.format()
+    this.raw = this.version
+    return this
+  }
+}
+
+module.exports = SemVer

node_modules/ts-jest/node_modules/semver/functions/clean.js

@@ -0,0 +1,6 @@
+const parse = require('./parse')
+const clean = (version, options) => {
+  const s = parse(version.trim().replace(/^[=v]+/, ''), options)
+  return s ? s.version : null
+}
+module.exports = clean

node_modules/ts-jest/node_modules/semver/functions/cmp.js

@@ -0,0 +1,52 @@
+const eq = require('./eq')
+const neq = require('./neq')
+const gt = require('./gt')
+const gte = require('./gte')
+const lt = require('./lt')
+const lte = require('./lte')
+
+const cmp = (a, op, b, loose) => {
+  switch (op) {
+    case '===':
+      if (typeof a === 'object') {
+        a = a.version
+      }
+      if (typeof b === 'object') {
+        b = b.version
+      }
+      return a === b
+
+    case '!==':
+      if (typeof a === 'object') {
+        a = a.version
+      }
+      if (typeof b === 'object') {
+        b = b.version
+      }
+      return a !== b
+
+    case '':
+    case '=':
+    case '==':
+      return eq(a, b, loose)
+
+    case '!=':
+      return neq(a, b, loose)
+
+    case '>':
+      return gt(a, b, loose)
+
+    case '>=':
+      return gte(a, b, loose)
+
+    case '<':
+      return lt(a, b, loose)
+
+    case '<=':
+      return lte(a, b, loose)
+
+    default:
+      throw new TypeError(`Invalid operator: ${op}`)
+  }
+}
+module.exports = cmp

node_modules/ts-jest/node_modules/semver/functions/coerce.js

@@ -0,0 +1,52 @@
+const SemVer = require('../classes/semver')
+const parse = require('./parse')
+const { re, t } = require('../internal/re')
+
+const coerce = (version, options) => {
+  if (version instanceof SemVer) {
+    return version
+  }
+
+  if (typeof version === 'number') {
+    version = String(version)
+  }
+
+  if (typeof version !== 'string') {
+    return null
+  }
+
+  options = options || {}
+
+  let match = null
+  if (!options.rtl) {
+    match = version.match(re[t.COERCE])
+  } else {
+    // Find the right-most coercible string that does not share
+    // a terminus with a more left-ward coercible string.
+    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+    //
+    // Walk through the string checking with a /g regexp
+    // Manually set the index so as to pick up overlapping matches.
+    // Stop when we get a match that ends at the string end, since no
+    // coercible string can be more right-ward without the same terminus.
+    let next
+    while ((next = re[t.COERCERTL].exec(version)) &&
+        (!match || match.index + match[0].length !== version.length)
+    ) {
+      if (!match ||
+            next.index + next[0].length !== match.index + match[0].length) {
+        match = next
+      }
+      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
+    }
+    // leave it in a clean state
+    re[t.COERCERTL].lastIndex = -1
+  }
+
+  if (match === null) {
+    return null
+  }
+
+  return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
+}
+module.exports = coerce

node_modules/ts-jest/node_modules/semver/functions/compare-build.js

@@ -0,0 +1,7 @@
+const SemVer = require('../classes/semver')
+const compareBuild = (a, b, loose) => {
+  const versionA = new SemVer(a, loose)
+  const versionB = new SemVer(b, loose)
+  return versionA.compare(versionB) || versionA.compareBuild(versionB)
+}
+module.exports = compareBuild