Merge pull request #29 from Azure/cluster-connect-release-v1

Cluster connect release v1

.github/CODEOWNERS

@@ -1 +0,0 @@
-* @Azure/aks-atlanta

.github/ISSUE_TEMPLATE/issue--bug-report---feature-request.md

@@ -1,7 +0,0 @@
----
-name: "Issue: Bug Report / Feature Request"
-about: Create a report to help us improve
-title: ""
-labels: need-to-triage
-assignees: "@Azure/aks-atlanta"
----

.github/workflows/default-labels.yml

@@ -1,35 +0,0 @@
-name: Setting Default Labels
-
-# Controls when the action will run.
-on:
-  schedule:
-    - cron: "0 0/3 * * *"
-
-# A workflow run is made up of one or more jobs that can run sequentially or in parallel
-jobs:
-  build:
-    # The type of runner that the job will run on
-    runs-on: ubuntu-latest
-
-    # Steps represent a sequence of tasks that will be executed as part of the job
-    steps:
-      - uses: actions/stale@v3
-        name: Setting Issue as Idle
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-issue-message: "This issue is idle because it has been open for 14 days with no activity."
-          stale-issue-label: "idle"
-          days-before-stale: 14
-          days-before-close: -1
-          operations-per-run: 100
-          exempt-issue-labels: "backlog"
-
-      - uses: actions/stale@v3
-        name: Setting PR as Idle
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-pr-message: "This PR is idle because it has been open for 14 days with no activity."
-          stale-pr-label: "idle"
-          days-before-stale: 14
-          days-before-close: -1
-          operations-per-run: 100

.github/workflows/integration-tests.yml

@@ -1,143 +0,0 @@
-name: Run Integration Tests
-on:
-  pull_request:
-    branches:
-      - master
-      - "releases/*"
-  push:
-    branches:
-      - master
-      - "releases/*"
-
-jobs:
-  kubeconfig-method-integration-test:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Source Code
-        id: checkout-code
-        uses: actions/checkout@v2
-      - name: Npm Install and Build
-        id: npm-build
-        run: |
-          npm install
-          npm run build
-      - name: Set Context
-        uses: ./
-        with:
-          method: kubeconfig
-          context: exp-scratch
-          kubeconfig: |
-            apiVersion: v1
-            clusters:
-              - cluster:
-                  certificate-authority: fake-ca-file
-                  server: https://1.2.3.4
-                name: development
-              - cluster:
-                  insecure-skip-tls-verify: true
-                  server: https://5.6.7.8
-                name: scratch
-            contexts:
-              - context:
-                  cluster: development
-                  namespace: frontend
-                  user: developer
-                name: dev-frontend
-              - context:
-                  cluster: development
-                  namespace: storage
-                  user: developer
-                name: dev-storage
-              - context:
-                  cluster: scratch
-                  namespace: default
-                  user: experimenter
-                name: exp-scratch
-            current-context: ""
-            kind: Config
-            preferences: {}
-            users:
-              - name: developer
-                user:
-                  client-certificate: fake-cert-file
-                  client-key: fake-key-file
-              - name: experimenter
-                user:
-                  password: some-password
-                  username: exp
-      - name: Vertify Results
-        run: |
-          echo "$EXPECTED_KC" > /tmp/expected_kc.json
-          DIFF=$(diff <(jq -S -c . $KUBECONFIG) <(jq -S -c . /tmp/expected_kc.json))
-          if [ "$DIFF" != "" ]; then exit 1; else echo -e "Kubeconfig matches expected"; fi
-        env:
-          EXPECTED_KC: |
-            {
-                "apiVersion": "v1",
-                "clusters": [
-                    {
-                        "cluster": {
-                            "certificate-authority": "fake-ca-file",
-                            "insecure-skip-tls-verify": false,
-                            "server": "https://1.2.3.4"
-                        },
-                        "name": "development"
-                    },
-                    {
-                        "cluster": {
-                            "insecure-skip-tls-verify": true,
-                            "server": "https://5.6.7.8"
-                        },
-                        "name": "scratch"
-                    }
-                ],
-                "contexts": [
-                    {
-                        "context": {
-                            "cluster": "development",
-                            "name": "dev-frontend",
-                            "namespace": "frontend",
-                            "user": "developer"
-                        },
-                        "name": "dev-frontend"
-                    },
-                    {
-                        "context": {
-                            "cluster": "development",
-                            "name": "dev-storage",
-                            "namespace": "storage",
-                            "user": "developer"
-                        },
-                        "name": "dev-storage"
-                    },
-                    {
-                        "context": {
-                            "cluster": "scratch",
-                            "name": "exp-scratch",
-                            "namespace": "default",
-                            "user": "experimenter"
-                        },
-                        "name": "exp-scratch"
-                    }
-                ],
-                "current-context": "exp-scratch",
-                "kind": "Config",
-                "preferences": {
-                },
-                "users": [
-                    {
-                        "name": "developer",
-                        "user": {
-                            "client-certificate": "fake-cert-file",
-                            "client-key": "fake-key-file"
-                        }
-                    },
-                    {
-                        "name": "experimenter",
-                        "user": {
-                            "password": "some-password",
-                            "username": "exp"
-                        }
-                    }
-                ]
-            }

.github/workflows/ts-build-check.yml

@@ -1,41 +0,0 @@
-name: TypeScript Build Check
-
-on: pull_request
-
-jobs:
-  ts-build-check:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Pull Request
-        uses: actions/checkout@v2
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-          path: original-pr
-      - name: Setup Node
-        uses: actions/setup-node@v1
-        with:
-          node-version: 12.x
-      - name: Clone and Build Pull Request
-        run: |
-          cp $GITHUB_WORKSPACE/original-pr/ $GITHUB_WORKSPACE/built-pr -r
-          cd $GITHUB_WORKSPACE/built-pr/
-          npm i
-          npm run build
-      - name: Compare Built Directories
-        id: diff
-        run: |
-          DIFF=$(diff $GITHUB_WORKSPACE/original-pr/lib $GITHUB_WORKSPACE/built-pr/lib -rqiEZbwBd)
-          if [ "$DIFF" != "" ]; then exit 1; else echo -e "PR contains up-to-date compiled JavaScript."; fi
-      - name: Comment Unbuilt TypeScript
-        if: failure() && steps.diff.outcome == 'failure'
-        uses: actions/github-script@v2
-        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
-          script: |
-            github.issues.createComment({
-              issue_number: ${{ github.event.number }},
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: 'Please compile the TypeScript code with `npm run build`. The compiled JavaScript is not up-to-date.'
-            })

.github/workflows/unit-tests.yml

@@ -1,20 +0,0 @@
-name: Run Unit Tests
-on:
-  pull_request:
-    branches:
-      - master
-      - "releases/*"
-  push:
-    branches:
-      - master
-      - "releases/*"
-
-jobs:
-  unit-test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v1
-      - name: Run Unit Tests
-        run: |
-          npm install
-          npm test

.gitignore

@@ -327,4 +327,3 @@ ASALocalRun/
 
 # MFractors (Xamarin productivity tool) working folder 
 .mfractor/
-coverage

README.md

@@ -1,38 +1,84 @@
 # Kubernetes set context
 
-This action can be used to set cluster context before other actions like [`azure/k8s-deploy`](https://github.com/Azure/k8s-deploy/tree/master) and [`azure/k8s-create-secret`](https://github.com/Azure/k8s-create-secret/tree/master). It should also be used before `kubectl` commands (in script) are run subsequently in the workflow.
+This action can be used to set cluster context before other actions like [`azure/k8s-deploy`](https://github.com/Azure/k8s-deploy/tree/master), [`azure/k8s-create-secret`](https://github.com/Azure/k8s-create-secret/tree/master) or any kubectl commands (in script) can be run subsequently in the workflow.
 
-It is a requirement to use [`azure/login`](https://github.com/Azure/login/tree/master) in your workflow before using this action when using the `service-account` or `service-principal` methods.
+It is a requirement to use [`azure/login`](https://github.com/Azure/login/tree/master) in your workflow before using this action. 
 
 There are three approaches for specifying the deployment target:
 
 - Kubeconfig file provided as input to the action
 - Service account approach where the secret associated with the service account is provided as input to the action
-- Service principal approach (only applicable for arc cluster) where service principal provided with 'creds' is used as input to action
+- Service principal approach(only applicable for arc cluster) where service principal provided with 'creds' is used as input to action 
 
-In all these approaches it is recommended to store these contents (kubeconfig file content or secret content) in a [secret](https://docs.github.com/en/actions/security-guides/encrypted-secrets/).
+If inputs related to all these approaches are provided, kubeconfig approach related inputs are given precedence.
 
-Refer to the [action metadata file](./action.yml) for details about inputs. Note that different inputs are required for different method and cluster types. Use the below examples as a reference.
+In all these approaches it is recommended to store these contents (kubeconfig file content or secret content) in a [secret](https://developer.github.com/actions/managing-workflows/storing-secrets/) which could be referenced later in the action.
+
+## Action inputs
+
+<table>
+  <thead>
+    <tr>
+      <th>Action inputs</th>
+      <th>Description</th>
+    </tr>
+  </thead>
+  <tr>
+    <td><code>method</code><br/>Method</td>
+    <td>(Optional) Acceptable values: kubeconfig/service-account/service-principal. Default value: kubeconfig</td>
+  </tr>
+  <tr>
+    <td><code>kubeconfig</code><br/>Kubectl config</td>
+    <td>(Relevant for kubeconfig approach) Configuration file to be used with kubectl</td>
+  </tr>
+  <tr>
+    <td><code>context</code><br/>Context</td>
+    <td>(Relevant for kubeconfig approach) Context to be used within the provided kubeconfig file</td>
+  </tr>
+  <tr>
+    <td><code>k8s-url</code><br/>API server URL</td>
+    <td>(Relevant for service account approach) API Server URL for the K8s cluster</td>
+  </tr>
+  <tr>
+    <td><code>k8s-secret</code><br/>Secret</td>
+    <td>(Relevant for service account approach) Secret associated with the service account to be used for deployments</td>
+  </tr>
+  <tr>
+    <td><code>cluster-type</code><br/>Type of cluster</td>
+    <td>Type of cluster. Acceptable values: generic/arc</td>
+  </tr>
+  <tr>
+    <td><code>cluster-name</code><br/>Name of arc cluster</td>
+    <td>Name of Azure Arc enabled Kubernetes cluster. Required only if cluster-type is 'arc'.</td>
+  </tr>
+  <tr>
+    <td><code>resource-group</code><br/>resource group</td>
+    <td>Resource group containing the Azure Arc enabled Kubernetes cluster. Required only if cluster-type is 'arc'.</td>
+  </tr>
+  <tr>
+    <td><code>token</code><br/>Service account token</td>
+    <td>Applicable for 'service-account' method.</td>
+  </tr>
+</table>
 
 ## Example usage
 
 ### Kubeconfig approach
 
 ```yaml
-- uses: azure/k8s-set-context@v2
+- uses: azure/k8s-set-context@v1
   with:
     method: kubeconfig
-    kubeconfig: <your kubeconfig>
-    context: <context name> # current-context from kubeconfig is used as default
+    kubeconfig: <your kubeconfig> # Use secret (https://developer.github.com/actions/managing-workflows/storing-secrets/)
+    context: <context name>  #If left unspecified, current-context from kubeconfig is used as default
+  id: setcontext
 ```
 
-**Please note** that the input requires the _contents_ of the kubeconfig file, and not its path.
+Following are the ways to fetch kubeconfig file onto your local development machine so that the same can be used in the action input shown above:
 
-Following are the ways to fetch kubeconfig file onto your local development machine so that the same can be used in the action input shown above.
+#### For Azure Kubernetes Service cluster
 
-#### Azure Kubernetes Service cluster
-
-```bash
+```sh
 az aks get-credentials --name
                        --resource-group
                        [--admin]
@@ -43,60 +89,65 @@ az aks get-credentials --name
 
 Further details can be found in [az aks get-credentials documentation](https://docs.microsoft.com/en-us/cli/azure/aks?view=azure-cli-latest#az-aks-get-credentials).
 
-#### Generic Kubernetes cluster
+#### For any generic Kubernetes cluster
 
 Please refer to documentation on fetching [kubeconfig for any generic K8s cluster](https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/)
 
 ### Service account approach
 
 ```yaml
-- uses: azure/k8s-set-context@v2
+- uses: azure/k8s-set-context@v1
   with:
     method: service-account
-    k8s-url: <URL of the cluster's API server>
+    k8s-url: <URL of the clsuter's API server>
     k8s-secret: <secret associated with the service account>
+  id: setcontext
 ```
 
 For fetching Server URL, execute the following command on your shell:
 
-```bash
+```sh
 kubectl config view --minify -o 'jsonpath={.clusters[0].cluster.server}'
 ```
 
 For fetching Secret object required to connect and authenticate with the cluster, the following sequence of commands need to be run:
 
-```bash
+```sh
 kubectl get serviceAccounts <service-account-name> -n <namespace> -o 'jsonpath={.secrets[*].name}'
+```
 
+```sh
 kubectl get secret <service-account-secret-name> -n <namespace> -o yaml
 ```
 
 ### Service account approach for arc cluster
 
 ```yaml
-- uses: azure/k8s-set-context@v2
+- uses: azure/k8s-set-context@v1
   with:
     method: service-account
-    cluster-type: arc
+    cluster-type: 'arc'
     cluster-name: <cluster-name>
     resource-group: <resource-group>
-    token: "${{ secrets.SA_TOKEN }}"
+    token: '${{ secrets.SA_TOKEN }}'
+  id: setcontext
 ```
 
 ### Service principal approach for arc cluster
 
 ```yaml
-- uses: azure/k8s-set-context@v2
+- uses: azure/k8s-set-context@v1
   with:
     method: service-principal
-    cluster-type: arc
+    cluster-type: 'arc'
     cluster-name: <cluster-name>
     resource-group: <resource-group>
+  id: setcontext
 ```
 
 ## Contributing
 
-This project welcomes contributions and suggestions. Most contributions require you to agree to a
+This project welcomes contributions and suggestions.  Most contributions require you to agree to a
 Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
 the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.
 

action.yml

@@ -1,39 +1,47 @@
-name: "Kubernetes Set Context"
-description: "Set the context of a target Kubernetes cluster and export the kubeconfig which is used by subsequent actions"
-inputs:
-  # Please ensure you have used azure/login in the workflow before this action
+name: 'Kubernetes set context'
+description: 'Kubernetes set context'
+inputs: 
+# Used for setting the target K8s cluster context which will be used by other actions like azure/k8s-actions/k8s-deploy or azure/k8s-actions/k8s-create-secret
   cluster-type:
-    description: "Acceptable values: generic or arc"
+    description: 'Acceptable values: generic or arc'
     required: true
-    default: "generic"
+    default: 'generic'
   method:
-    description: "Acceptable values: kubeconfig or service-account or service-principal"
+    description: 'Acceptable values: kubeconfig or service-account or service-principal'
     required: true
-    default: "kubeconfig"
+    default: 'kubeconfig'
   kubeconfig:
-    description: "Contents of kubeconfig file"
+    description: 'Kubernetes Config'
     required: false
+    default: ''
   context:
-    description: "If your kubeconfig has multiple contexts, use this field to use a specific context, otherwise the default one would be chosen"
-    required: false
-  k8s-url:
-    description: "Cluster Url"
-    required: false
-  k8s-secret:
-    description: "Service account secret (run kubectl get serviceaccounts <service-account-name> -o yaml and copy the service-account-secret-name)"
-    required: false
-  token:
-    description: "Token extracted from the secret of service account (should be base 64 decoded)"
-    required: false
-  resource-group:
-    description: "Azure resource group name"
-    required: false
-  cluster-name:
-    description: "Azure connected cluster name"
+    description: 'If your kubeconfig has multiple contexts, use this field to use a specific context, otherwise the default one would be chosen'
     required: false
+    default: ''
 
+  k8s-url:
+    description: 'Cluster Url'
+    required: false
+    default: ''
+  k8s-secret:
+    description: 'Service account secret. Run kubectl get serviceaccounts <service-account-name> -o yaml and copy the service-account-secret-name. Copy the ouptut of kubectl get secret <service-account-secret-name> -o yaml'
+    required: false
+    default: ''
+  token:
+    description: 'Token extracted from the secret of service account (should be base 64 decoded)'
+    required: false
+    default: ''
+  resource-group:
+    description: 'Azure resource group name'
+    required: false
+    default: ''
+  cluster-name:
+    description: 'Azure connected cluster name'
+    required: false
+    default: ''
+  
 branding:
-  color: "blue"
+  color: 'green' # optional, decorates the entry in the GitHub Marketplace
 runs:
-  using: "node12"
-  main: "lib/run.js"
+  using: 'node12'
+  main: 'lib/login.js'

jest.config.js

@@ -1,20 +0,0 @@
-module.exports = {
-  restoreMocks: true,
-  clearMocks: true,
-  resetMocks: true,
-  moduleFileExtensions: ["js", "ts"],
-  testEnvironment: "node",
-  testMatch: ["**/*.test.ts"],
-  transform: {
-    "^.+\\.ts$": "ts-jest",
-  },
-  verbose: true,
-  coverageThreshold: {
-    global: {
-      branches: 0,
-      functions: 40,
-      lines: 22,
-      statements: 22,
-    },
-  },
-};

lib/arc-login.js

@@ -0,0 +1,92 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core = require("@actions/core");
+const path = require("path");
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const io = require("@actions/io");
+const exec = require("@actions/exec");
+var azPath;
+const kubeconfig_timeout = 120; //timeout in seconds
+function getArcKubeconfig() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let method = core.getInput('method');
+            if (method != 'service-account' && method != 'service-principal') {
+                throw Error("Supported methods for arc cluster are 'service-account' and 'service-principal'.");
+            }
+            let resourceGroupName = core.getInput('resource-group');
+            let clusterName = core.getInput('cluster-name');
+            if (!resourceGroupName) {
+                throw Error("'resourceGroupName' is not passed for arc cluster.");
+            }
+            if (!clusterName) {
+                throw Error("'clusterName' is not passed for arc cluster.");
+            }
+            azPath = yield io.which("az", true);
+            yield executeAzCliCommand(`account show`, false);
+            try {
+                yield executeAzCliCommand(`extension remove -n connectedk8s`, false);
+            }
+            catch (_a) {
+                //ignore if this causes an error
+            }
+            yield executeAzCliCommand(`extension add -n connectedk8s`, false);
+            yield executeAzCliCommand(`extension list`, false);
+            const runnerTempDirectory = process.env['RUNNER_TEMP']; // Using process.env until the core libs are updated
+            const kubeconfigPath = path.join(runnerTempDirectory, `kubeconfig_${Date.now()}`);
+            if (method == 'service-account') {
+                let saToken = core.getInput('token');
+                if (!saToken) {
+                    throw Error("'saToken' is not passed for 'service-account' method.");
+                }
+                console.log("using 'service-account' method for authenticating to arc cluster.");
+                const proc = child_process_1.spawn(azPath, ['connectedk8s', 'proxy', '-n', clusterName, '-g', resourceGroupName, '-f', kubeconfigPath, '--token', saToken], {
+                    detached: true,
+                    stdio: 'ignore'
+                });
+                proc.unref();
+            }
+            else {
+                console.log("using 'service-principal' method for authenticating to arc cluster.");
+                const proc = child_process_1.spawn(azPath, ['connectedk8s', 'proxy', '-n', clusterName, '-g', resourceGroupName, '-f', kubeconfigPath], {
+                    detached: true,
+                    stdio: 'ignore'
+                });
+                proc.unref();
+            }
+            console.log(`Waiting for ${kubeconfig_timeout} seconds for kubeconfig to be merged....`);
+            yield sleep(kubeconfig_timeout * 1000); //sleeping for 2 minutes to allow kubeconfig to be merged
+            fs.chmodSync(kubeconfigPath, '600');
+            core.exportVariable('KUBECONFIG', kubeconfigPath);
+            console.log('KUBECONFIG environment variable is set');
+        }
+        catch (ex) {
+            return Promise.reject(ex);
+        }
+    });
+}
+exports.getArcKubeconfig = getArcKubeconfig;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function executeAzCliCommand(command, silent, execOptions = {}, args = []) {
+    return __awaiter(this, void 0, void 0, function* () {
+        execOptions.silent = !!silent;
+        try {
+            yield exec.exec(`"${azPath}" ${command}`, args, execOptions);
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    });
+}

lib/client.js

@@ -0,0 +1,99 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = require("util");
+const fs = require("fs");
+const httpClient = require("typed-rest-client/HttpClient");
+const core = require("@actions/core");
+var httpCallbackClient = new httpClient.HttpClient('GITHUB_RUNNER', null, {});
+class WebRequest {
+}
+exports.WebRequest = WebRequest;
+class WebResponse {
+}
+exports.WebResponse = WebResponse;
+class WebRequestOptions {
+}
+exports.WebRequestOptions = WebRequestOptions;
+function sendRequest(request, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let i = 0;
+        let retryCount = options && options.retryCount ? options.retryCount : 5;
+        let retryIntervalInSeconds = options && options.retryIntervalInSeconds ? options.retryIntervalInSeconds : 2;
+        let retriableErrorCodes = options && options.retriableErrorCodes ? options.retriableErrorCodes : ["ETIMEDOUT", "ECONNRESET", "ENOTFOUND", "ESOCKETTIMEDOUT", "ECONNREFUSED", "EHOSTUNREACH", "EPIPE", "EA_AGAIN"];
+        let retriableStatusCodes = options && options.retriableStatusCodes ? options.retriableStatusCodes : [408, 409, 500, 502, 503, 504];
+        let timeToWait = retryIntervalInSeconds;
+        while (true) {
+            try {
+                if (request.body && typeof (request.body) !== 'string' && !request.body["readable"]) {
+                    request.body = fs.createReadStream(request.body["path"]);
+                }
+                let response = yield sendRequestInternal(request);
+                if (retriableStatusCodes.indexOf(response.statusCode) != -1 && ++i < retryCount) {
+                    core.debug(util.format("Encountered a retriable status code: %s. Message: '%s'.", response.statusCode, response.statusMessage));
+                    yield sleepFor(timeToWait);
+                    timeToWait = timeToWait * retryIntervalInSeconds + retryIntervalInSeconds;
+                    continue;
+                }
+                return response;
+            }
+            catch (error) {
+                if (retriableErrorCodes.indexOf(error.code) != -1 && ++i < retryCount) {
+                    core.debug(util.format("Encountered a retriable error:%s. Message: %s.", error.code, error.message));
+                    yield sleepFor(timeToWait);
+                    timeToWait = timeToWait * retryIntervalInSeconds + retryIntervalInSeconds;
+                }
+                else {
+                    if (error.code) {
+                        core.debug("error code =" + error.code);
+                    }
+                    throw error;
+                }
+            }
+        }
+    });
+}
+exports.sendRequest = sendRequest;
+function sleepFor(sleepDurationInSeconds) {
+    return new Promise((resolve, reject) => {
+        setTimeout(resolve, sleepDurationInSeconds * 1000);
+    });
+}
+exports.sleepFor = sleepFor;
+function sendRequestInternal(request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        core.debug(util.format("[%s]%s", request.method, request.uri));
+        var response = yield httpCallbackClient.request(request.method, request.uri, request.body, request.headers);
+        return yield toWebResponse(response);
+    });
+}
+function toWebResponse(response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var res = new WebResponse();
+        if (response) {
+            res.statusCode = response.message.statusCode;
+            res.statusMessage = response.message.statusMessage;
+            res.headers = response.message.headers;
+            var body = yield response.readBody();
+            if (body) {
+                try {
+                    res.body = JSON.parse(body);
+                }
+                catch (error) {
+                    core.debug("Could not parse response: " + JSON.stringify(error));
+                    core.debug("Response: " + JSON.stringify(res.body));
+                    res.body = body;
+                }
+            }
+        }
+        return res;
+    });
+}

lib/kubeconfigs/arc.js

@@ -1,84 +0,0 @@
-"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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getArcKubeconfig = exports.KUBECONFIG_LOCATION = void 0;
-const core = __importStar(require("@actions/core"));
-const io = __importStar(require("@actions/io"));
-const method_1 = require("../types/method");
-const path = __importStar(require("path"));
-const azCommands_1 = require("./azCommands");
-const RUNNER_TEMP = process.env["RUNNER_TEMP"] || "";
-exports.KUBECONFIG_LOCATION = path.join(RUNNER_TEMP, `arc_kubeconfig_${Date.now()}`);
-/**
- * Gets the kubeconfig based on provided method for an Arc Kubernetes cluster
- * @returns The kubeconfig wrapped in a Promise
- */
-function getArcKubeconfig() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const resourceGroupName = core.getInput("resource-group", { required: true });
-        const clusterName = core.getInput("cluster-name", { required: true });
-        const azPath = yield io.which("az", true);
-        const method = method_1.parseMethod(core.getInput("method", { required: true }));
-        yield azCommands_1.runAzCliCommand(azPath, ["extension", "add", "-n", "connectedk8s"]);
-        switch (method) {
-            case method_1.Method.SERVICE_ACCOUNT:
-                const saToken = core.getInput("token", { required: true });
-                return yield azCommands_1.runAzKubeconfigCommandBlocking(azPath, [
-                    "connectedk8s",
-                    "proxy",
-                    "-n",
-                    clusterName,
-                    "-g",
-                    resourceGroupName,
-                    "--token",
-                    saToken,
-                    "-f",
-                    exports.KUBECONFIG_LOCATION,
-                ], exports.KUBECONFIG_LOCATION);
-            case method_1.Method.SERVICE_PRINCIPAL:
-                return yield azCommands_1.runAzKubeconfigCommandBlocking(azPath, [
-                    "connectedk8s",
-                    "proxy",
-                    "-n",
-                    clusterName,
-                    "-g",
-                    resourceGroupName,
-                    "-f",
-                    exports.KUBECONFIG_LOCATION,
-                ], exports.KUBECONFIG_LOCATION);
-            case undefined:
-                core.warning("Defaulting to kubeconfig method");
-            case method_1.Method.KUBECONFIG:
-            default:
-                throw Error("Kubeconfig method not supported for Arc cluster");
-        }
-    });
-}
-exports.getArcKubeconfig = getArcKubeconfig;

lib/kubeconfigs/azCommands.js

@@ -1,67 +0,0 @@
-"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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runAzKubeconfigCommandBlocking = exports.runAzCliCommand = void 0;
-const fs = __importStar(require("fs"));
-const exec_1 = require("@actions/exec");
-const child_process_1 = require("child_process");
-const AZ_TIMEOUT_SECONDS = 120;
-/**
- * Executes an az cli command
- * @param azPath The path to the az tool
- * @param args The arguments to be invoked
- * @param options Optional options for the command execution
- */
-function runAzCliCommand(azPath, args, options = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield exec_1.exec(azPath, args, options);
-    });
-}
-exports.runAzCliCommand = runAzCliCommand;
-/**
- * Executes an az cli command that will set the kubeconfig
- * @param azPath The path to the az tool
- * @param args The arguments to be be invoked
- * @param kubeconfigPath The path to the kubeconfig that is updated by the command
- * @returns The contents of the kubeconfig
- */
-function runAzKubeconfigCommandBlocking(azPath, args, kubeconfigPath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const proc = child_process_1.spawn(azPath, args, {
-            detached: true,
-            stdio: "ignore",
-        });
-        proc.unref();
-        yield sleep(AZ_TIMEOUT_SECONDS);
-        return fs.readFileSync(kubeconfigPath).toString();
-    });
-}
-exports.runAzKubeconfigCommandBlocking = runAzKubeconfigCommandBlocking;
-const sleep = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1000));

lib/kubeconfigs/default.js

@@ -1,87 +0,0 @@
-"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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createKubeconfig = exports.getDefaultKubeconfig = void 0;
-const core = __importStar(require("@actions/core"));
-const jsyaml = __importStar(require("js-yaml"));
-const k8sSecret_1 = require("../types/k8sSecret");
-const method_1 = require("../types/method");
-/**
- * Gets the kubeconfig based on provided method for a default Kubernetes cluster
- * @returns The kubeconfig
- */
-function getDefaultKubeconfig() {
-    const method = method_1.parseMethod(core.getInput("method", { required: true }));
-    switch (method) {
-        case method_1.Method.SERVICE_ACCOUNT: {
-            const clusterUrl = core.getInput("k8s-url", { required: true });
-            core.debug("Found clusterUrl. Creating kubeconfig using certificate and token");
-            const k8sSecret = core.getInput("k8s-secret", {
-                required: true,
-            });
-            const parsedK8sSecret = k8sSecret_1.parseK8sSecret(jsyaml.load(k8sSecret));
-            const certAuth = parsedK8sSecret.data["ca.crt"];
-            const token = Buffer.from(parsedK8sSecret.data.token, "base64").toString();
-            return createKubeconfig(certAuth, token, clusterUrl);
-        }
-        case method_1.Method.SERVICE_PRINCIPAL: {
-            core.warning("Service Principal method not supported for default cluster type");
-        }
-        case undefined: {
-            core.warning("Defaulting to kubeconfig method");
-        }
-        default: {
-            core.debug("Setting context using kubeconfig");
-            return core.getInput("kubeconfig", { required: true });
-        }
-    }
-}
-exports.getDefaultKubeconfig = getDefaultKubeconfig;
-/**
- * Creates a kubeconfig and returns the string representation
- * @param certAuth The certificate authentication of the cluster
- * @param token The user token
- * @param clusterUrl The server url of the cluster
- * @returns The kubeconfig as a string
- */
-function createKubeconfig(certAuth, token, clusterUrl) {
-    const kubeconfig = {
-        apiVersion: "v1",
-        kind: "Config",
-        clusters: [
-            {
-                cluster: {
-                    "certificate-authority-data": certAuth,
-                    server: clusterUrl,
-                },
-            },
-        ],
-        users: [
-            {
-                user: {
-                    token: token,
-                },
-            },
-        ],
-    };
-    return JSON.stringify(kubeconfig);
-}
-exports.createKubeconfig = createKubeconfig;

lib/login.js

@@ -0,0 +1,135 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core = require("@actions/core");
+const path = require("path");
+const fs = require("fs");
+const io = require("@actions/io");
+const toolCache = require("@actions/tool-cache");
+const os = require("os");
+const toolrunner_1 = require("@actions/exec/lib/toolrunner");
+const jsyaml = require("js-yaml");
+const util = require("util");
+const arc_login_1 = require("./arc-login");
+function getKubeconfig() {
+    const method = core.getInput('method', { required: true });
+    if (method == 'kubeconfig') {
+        const kubeconfig = core.getInput('kubeconfig', { required: true });
+        core.debug("Setting context using kubeconfig");
+        return kubeconfig;
+    }
+    else if (method == 'service-account') {
+        const clusterUrl = core.getInput('k8s-url', { required: true });
+        core.debug("Found clusterUrl, creating kubeconfig using certificate and token");
+        let k8sSecret = core.getInput('k8s-secret', { required: true });
+        var parsedk8sSecret = jsyaml.safeLoad(k8sSecret);
+        let kubernetesServiceAccountSecretFieldNotPresent = 'The service acount secret yaml does not contain %s; field. Make sure that its present and try again.';
+        if (!parsedk8sSecret) {
+            throw Error("The service account secret yaml specified is invalid. Make sure that its a valid yaml and try again.");
+        }
+        if (!parsedk8sSecret.data) {
+            throw Error(util.format(kubernetesServiceAccountSecretFieldNotPresent, "data"));
+        }
+        if (!parsedk8sSecret.data.token) {
+            throw Error(util.format(kubernetesServiceAccountSecretFieldNotPresent, "data.token"));
+        }
+        if (!parsedk8sSecret.data["ca.crt"]) {
+            throw Error(util.format(kubernetesServiceAccountSecretFieldNotPresent, "data[ca.crt]"));
+        }
+        const certAuth = parsedk8sSecret.data["ca.crt"];
+        const token = Buffer.from(parsedk8sSecret.data.token, 'base64').toString();
+        const kubeconfigObject = {
+            "apiVersion": "v1",
+            "kind": "Config",
+            "clusters": [
+                {
+                    "cluster": {
+                        "certificate-authority-data": certAuth,
+                        "server": clusterUrl
+                    }
+                }
+            ],
+            "users": [
+                {
+                    "user": {
+                        "token": token
+                    }
+                }
+            ]
+        };
+        return JSON.stringify(kubeconfigObject);
+    }
+    else {
+        throw Error("Invalid method specified. Acceptable values are kubeconfig and service-account.");
+    }
+}
+function getExecutableExtension() {
+    if (os.type().match(/^Win/)) {
+        return '.exe';
+    }
+    return '';
+}
+function getKubectlPath() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let kubectlPath = yield io.which('kubectl', false);
+        if (!kubectlPath) {
+            const allVersions = toolCache.findAllVersions('kubectl');
+            kubectlPath = allVersions.length > 0 ? toolCache.find('kubectl', allVersions[0]) : '';
+            if (!kubectlPath) {
+                throw new Error('Kubectl is not installed');
+            }
+            kubectlPath = path.join(kubectlPath, `kubectl${getExecutableExtension()}`);
+        }
+        return kubectlPath;
+    });
+}
+function setContext(kubeconfigPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let context = core.getInput('context');
+        if (context) {
+            //To use kubectl commands, the environment variable KUBECONFIG needs to be set for this step 
+            process.env['KUBECONFIG'] = kubeconfigPath;
+            const kubectlPath = yield getKubectlPath();
+            let toolRunner = new toolrunner_1.ToolRunner(kubectlPath, ['config', 'use-context', context]);
+            yield toolRunner.exec();
+            toolRunner = new toolrunner_1.ToolRunner(kubectlPath, ['config', 'current-context']);
+            yield toolRunner.exec();
+        }
+    });
+}
+function run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let kubeconfig = '';
+            const cluster_type = core.getInput('cluster-type', { required: true });
+            if (cluster_type == 'arc') {
+                yield arc_login_1.getArcKubeconfig().catch(ex => {
+                    throw new Error('Error: Could not get the KUBECONFIG for arc cluster: ' + ex);
+                });
+            }
+            else {
+                const runnerTempDirectory = process.env['RUNNER_TEMP']; // Using process.env until the core libs are updated
+                const kubeconfigPath = path.join(runnerTempDirectory, `kubeconfig_${Date.now()}`);
+                kubeconfig = getKubeconfig();
+                core.debug(`Writing kubeconfig contents to ${kubeconfigPath}`);
+                fs.writeFileSync(kubeconfigPath, kubeconfig);
+                fs.chmodSync(kubeconfigPath, '600');
+                core.exportVariable('KUBECONFIG', kubeconfigPath);
+                console.log('KUBECONFIG environment variable is set');
+                yield setContext(kubeconfigPath);
+            }
+        }
+        catch (ex) {
+            return Promise.reject(ex);
+        }
+    });
+}
+run().catch(core.setFailed);

lib/run.js

@@ -1,61 +0,0 @@
-"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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
-const core = __importStar(require("@actions/core"));
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const cluster_1 = require("./types/cluster");
-const utils_1 = require("./utils");
-/**
- * Sets the Kubernetes context based on supplied action inputs
- */
-function run() {
-    return __awaiter(this, void 0, void 0, function* () {
-        // get inputs
-        const clusterType = cluster_1.parseCluster(core.getInput("cluster-type", {
-            required: true,
-        }));
-        const runnerTempDirectory = process.env["RUNNER_TEMP"];
-        const kubeconfigPath = path.join(runnerTempDirectory, `kubeconfig_${Date.now()}`);
-        // get kubeconfig and update context
-        const kubeconfig = yield utils_1.getKubeconfig(clusterType);
-        const kubeconfigWithContext = utils_1.setContext(kubeconfig);
-        // output kubeconfig
-        core.debug(`Writing kubeconfig contents to ${kubeconfigPath}`);
-        fs.writeFileSync(kubeconfigPath, kubeconfigWithContext);
-        fs.chmodSync(kubeconfigPath, "600");
-        core.debug("Setting KUBECONFIG environment variable");
-        core.exportVariable("KUBECONFIG", kubeconfigPath);
-    });
-}
-exports.run = run;
-// Run the application
-run().catch(core.setFailed);

lib/types/cluster.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCluster = exports.Cluster = void 0;
-var Cluster;
-(function (Cluster) {
-    Cluster["ARC"] = "arc";
-    Cluster["GENERIC"] = "generic";
-})(Cluster = exports.Cluster || (exports.Cluster = {}));
-/**
- * Converts a string to the Cluster enum
- * @param str The cluster type (case insensitive)
- * @returns The Cluster enum or undefined if it can't be parsed
- */
-exports.parseCluster = (str) => Cluster[Object.keys(Cluster).filter((k) => Cluster[k].toString().toLowerCase() === str.toLowerCase())[0]];

lib/types/k8sSecret.js

@@ -1,41 +0,0 @@
-"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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseK8sSecret = void 0;
-const util = __importStar(require("util"));
-/**
- * Throws an error if an object does not have all required fields to be a K8sSecret
- * @param secret
- * @returns A type guarded K8sSecret
- */
-function parseK8sSecret(secret) {
-    if (!secret)
-        throw Error("K8s secret yaml is invalid");
-    if (!secret.data)
-        throw k8sSecretMissingFieldError("data");
-    if (!secret.data.token)
-        throw k8sSecretMissingFieldError("token");
-    if (!secret.data["ca.crt"])
-        throw k8sSecretMissingFieldError("ca.crt");
-    return secret;
-}
-exports.parseK8sSecret = parseK8sSecret;
-const k8sSecretMissingFieldError = (field) => Error(util.format("K8s secret yaml does not contain %s field", field));

lib/types/method.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMethod = exports.Method = void 0;
-var Method;
-(function (Method) {
-    Method["KUBECONFIG"] = "kubeconfig";
-    Method["SERVICE_ACCOUNT"] = "service-account";
-    Method["SERVICE_PRINCIPAL"] = "service-principal";
-})(Method = exports.Method || (exports.Method = {}));
-/**
- * Converts a string to the Method enum
- * @param str The method (case insensitive)
- * @returns The Method enum or undefined if it can't be parsed
- */
-exports.parseMethod = (str) => Method[Object.keys(Method).filter((k) => Method[k].toString().toLowerCase() === str.toLowerCase())[0]];

lib/utils.js

@@ -1,76 +0,0 @@
-"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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setContext = exports.getKubeconfig = void 0;
-const core = __importStar(require("@actions/core"));
-const client_node_1 = require("@kubernetes/client-node");
-const default_1 = require("./kubeconfigs/default");
-const arc_1 = require("./kubeconfigs/arc");
-const cluster_1 = require("./types/cluster");
-/**
- * Gets the kubeconfig based on Kubernetes cluster type
- * @param type The cluster type for the kubeconfig (defaults to generic)
- * @returns A promise of the kubeconfig
- */
-function getKubeconfig(type) {
-    return __awaiter(this, void 0, void 0, function* () {
-        switch (type) {
-            case cluster_1.Cluster.ARC: {
-                return yield arc_1.getArcKubeconfig();
-            }
-            case undefined: {
-                core.warning("Cluster type not recognized. Defaulting to generic.");
-            }
-            default: {
-                return default_1.getDefaultKubeconfig();
-            }
-        }
-    });
-}
-exports.getKubeconfig = getKubeconfig;
-/**
- * Sets the context by updating the kubeconfig
- * @param kubeconfig The kubeconfig
- * @returns Updated kubeconfig with the context
- */
-function setContext(kubeconfig) {
-    const context = core.getInput("context");
-    if (!context) {
-        core.debug("Can't set context because context is unspecified.");
-        return kubeconfig;
-    }
-    // load current kubeconfig
-    const kc = new client_node_1.KubeConfig();
-    kc.loadFromString(kubeconfig);
-    // update kubeconfig
-    kc.setCurrentContext(context);
-    return kc.exportConfig();
-}
-exports.setContext = setContext;

node_modules/.bin/esparse

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../esprima/bin/esparse.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../esprima/bin/esparse.js" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/.bin/esparse.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\esprima\bin\esparse.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\esprima\bin\esparse.js" %*
+)

node_modules/.bin/esvalidate

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../esprima/bin/esvalidate.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../esprima/bin/esvalidate.js" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/.bin/esvalidate.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\esprima\bin\esvalidate.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\esprima\bin\esvalidate.js" %*
+)

node_modules/.bin/js-yaml

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../js-yaml/bin/js-yaml.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../js-yaml/bin/js-yaml.js" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/.bin/js-yaml.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\js-yaml\bin\js-yaml.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\js-yaml\bin\js-yaml.js" %*
+)

node_modules/.bin/semver

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../semver/bin/semver.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../semver/bin/semver.js" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/.bin/semver.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\semver\bin\semver.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\semver\bin\semver.js" %*
+)

node_modules/.bin/tsc

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
+  ret=$?
+else 
+  node  "$basedir/../typescript/bin/tsc" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/.bin/tsc.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\typescript\bin\tsc" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\typescript\bin\tsc" %*
+)

node_modules/.bin/tsserver

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../typescript/bin/tsserver" "$@"
+  ret=$?
+else 
+  node  "$basedir/../typescript/bin/tsserver" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/.bin/tsserver.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\typescript\bin\tsserver" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\typescript\bin\tsserver" %*
+)

node_modules/.bin/uuid

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../uuid/bin/uuid" "$@"
+  ret=$?
+else 
+  node  "$basedir/../uuid/bin/uuid" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/.bin/uuid.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\uuid\bin\uuid" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\uuid\bin\uuid" %*
+)

node_modules/@actions/core/package.json

@@ -1,16 +1,38 @@
 {
-  "name": "@actions/core",
-  "version": "1.2.6",
-  "description": "Actions core lib",
-  "keywords": [
-    "github",
-    "actions",
-    "core"
+  "_from": "@actions/core@^1.2.6",
+  "_id": "@actions/core@1.2.6",
+  "_inBundle": false,
+  "_integrity": "sha512-ZQYitnqiyBc3D+k7LsgSBmMDVkOVidaagDG7j3fOym77jNunWRuYx7VSHa9GNfFZh+zh61xsCjRj4JxMZlDqTA==",
+  "_location": "/@actions/core",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@actions/core@^1.2.6",
+    "name": "@actions/core",
+    "escapedName": "@actions%2fcore",
+    "scope": "@actions",
+    "rawSpec": "^1.2.6",
+    "saveSpec": null,
+    "fetchSpec": "^1.2.6"
+  },
+  "_requiredBy": [
+    "/",
+    "/@actions/tool-cache"
   ],
-  "homepage": "https://github.com/actions/toolkit/tree/main/packages/core",
-  "license": "MIT",
-  "main": "lib/core.js",
-  "types": "lib/core.d.ts",
+  "_resolved": "https://registry.npmjs.org/@actions/core/-/core-1.2.6.tgz",
+  "_shasum": "a78d49f41a4def18e88ce47c2cac615d5694bf09",
+  "_spec": "@actions/core@^1.2.6",
+  "_where": "D:\\Work\\Actions\\k8s-set-context",
+  "bugs": {
+    "url": "https://github.com/actions/toolkit/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Actions core lib",
+  "devDependencies": {
+    "@types/node": "^12.0.2"
+  },
   "directories": {
     "lib": "lib",
     "test": "__tests__"
@@ -19,6 +41,15 @@
     "lib",
     "!.DS_Store"
   ],
+  "homepage": "https://github.com/actions/toolkit/tree/main/packages/core",
+  "keywords": [
+    "github",
+    "actions",
+    "core"
+  ],
+  "license": "MIT",
+  "main": "lib/core.js",
+  "name": "@actions/core",
   "publishConfig": {
     "access": "public"
   },
@@ -32,10 +63,6 @@
     "test": "echo \"Error: run tests from root\" && exit 1",
     "tsc": "tsc"
   },
-  "bugs": {
-    "url": "https://github.com/actions/toolkit/issues"
-  },
-  "devDependencies": {
-    "@types/node": "^12.0.2"
-  }
+  "types": "lib/core.d.ts",
+  "version": "1.2.6"
 }

node_modules/@actions/exec/package.json

@@ -1,15 +1,41 @@
 {
-  "name": "@actions/exec",
-  "version": "1.0.1",
-  "description": "Actions exec lib",
-  "keywords": [
-    "github",
-    "actions",
-    "exec"
+  "_args": [
+    [
+      "@actions/exec@1.0.1",
+      "E:\\k8s-actions\\k8s-set-context"
+    ]
   ],
-  "homepage": "https://github.com/actions/toolkit/tree/master/packages/exec",
-  "license": "MIT",
-  "main": "lib/exec.js",
+  "_from": "@actions/exec@1.0.1",
+  "_id": "@actions/exec@1.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-nvFkxwiicvpzNiCBF4wFBDfnBvi7xp/as7LE1hBxBxKG2L29+gkIPBiLKMVORL+Hg3JNf07AKRfl0V5djoypjQ==",
+  "_location": "/@actions/exec",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "@actions/exec@1.0.1",
+    "name": "@actions/exec",
+    "escapedName": "@actions%2fexec",
+    "scope": "@actions",
+    "rawSpec": "1.0.1",
+    "saveSpec": null,
+    "fetchSpec": "1.0.1"
+  },
+  "_requiredBy": [
+    "/",
+    "/@actions/tool-cache"
+  ],
+  "_resolved": "https://registry.npmjs.org/@actions/exec/-/exec-1.0.1.tgz",
+  "_spec": "1.0.1",
+  "_where": "E:\\k8s-actions\\k8s-set-context",
+  "bugs": {
+    "url": "https://github.com/actions/toolkit/issues"
+  },
+  "description": "Actions exec lib",
+  "devDependencies": {
+    "@actions/io": "^1.0.1"
+  },
   "directories": {
     "lib": "lib",
     "test": "__tests__"
@@ -17,6 +43,16 @@
   "files": [
     "lib"
   ],
+  "gitHead": "a2ab4bcf78e4f7080f0d45856e6eeba16f0bbc52",
+  "homepage": "https://github.com/actions/toolkit/tree/master/packages/exec",
+  "keywords": [
+    "github",
+    "actions",
+    "exec"
+  ],
+  "license": "MIT",
+  "main": "lib/exec.js",
+  "name": "@actions/exec",
   "publishConfig": {
     "access": "public"
   },
@@ -28,11 +64,5 @@
     "test": "echo \"Error: run tests from root\" && exit 1",
     "tsc": "tsc"
   },
-  "bugs": {
-    "url": "https://github.com/actions/toolkit/issues"
-  },
-  "devDependencies": {
-    "@actions/io": "^1.0.1"
-  },
-  "gitHead": "a2ab4bcf78e4f7080f0d45856e6eeba16f0bbc52"
+  "version": "1.0.1"
 }

node_modules/@actions/io/package.json

@@ -1,15 +1,37 @@
 {
-  "name": "@actions/io",
-  "version": "1.0.1",
-  "description": "Actions io lib",
-  "keywords": [
-    "github",
-    "actions",
-    "io"
+  "_args": [
+    [
+      "@actions/io@1.0.1",
+      "E:\\k8s-actions\\k8s-set-context"
+    ]
   ],
-  "homepage": "https://github.com/actions/toolkit/tree/master/packages/io",
-  "license": "MIT",
-  "main": "lib/io.js",
+  "_from": "@actions/io@1.0.1",
+  "_id": "@actions/io@1.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-rhq+tfZukbtaus7xyUtwKfuiCRXd1hWSfmJNEpFgBQJ4woqPEpsBw04awicjwz9tyG2/MVhAEMfVn664Cri5zA==",
+  "_location": "/@actions/io",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "@actions/io@1.0.1",
+    "name": "@actions/io",
+    "escapedName": "@actions%2fio",
+    "scope": "@actions",
+    "rawSpec": "1.0.1",
+    "saveSpec": null,
+    "fetchSpec": "1.0.1"
+  },
+  "_requiredBy": [
+    "/@actions/tool-cache"
+  ],
+  "_resolved": "https://registry.npmjs.org/@actions/io/-/io-1.0.1.tgz",
+  "_spec": "1.0.1",
+  "_where": "E:\\k8s-actions\\k8s-set-context",
+  "bugs": {
+    "url": "https://github.com/actions/toolkit/issues"
+  },
+  "description": "Actions io lib",
   "directories": {
     "lib": "lib",
     "test": "__tests__"
@@ -17,6 +39,16 @@
   "files": [
     "lib"
   ],
+  "gitHead": "a2ab4bcf78e4f7080f0d45856e6eeba16f0bbc52",
+  "homepage": "https://github.com/actions/toolkit/tree/master/packages/io",
+  "keywords": [
+    "github",
+    "actions",
+    "io"
+  ],
+  "license": "MIT",
+  "main": "lib/io.js",
+  "name": "@actions/io",
   "publishConfig": {
     "access": "public"
   },
@@ -28,8 +60,5 @@
     "test": "echo \"Error: run tests from root\" && exit 1",
     "tsc": "tsc"
   },
-  "bugs": {
-    "url": "https://github.com/actions/toolkit/issues"
-  },
-  "gitHead": "a2ab4bcf78e4f7080f0d45856e6eeba16f0bbc52"
+  "version": "1.0.1"
 }

node_modules/@actions/tool-cache/package.json

@@ -1,34 +1,33 @@
 {
-  "name": "@actions/tool-cache",
-  "version": "1.1.1",
-  "description": "Actions tool-cache lib",
-  "keywords": [
-    "github",
-    "actions",
-    "exec"
+  "_args": [
+    [
+      "@actions/tool-cache@1.1.1",
+      "E:\\k8s-actions\\k8s-set-context"
+    ]
   ],
-  "homepage": "https://github.com/actions/toolkit/tree/master/packages/exec",
-  "license": "MIT",
-  "main": "lib/tool-cache.js",
-  "directories": {
-    "lib": "lib",
-    "test": "__tests__"
+  "_from": "@actions/tool-cache@1.1.1",
+  "_id": "@actions/tool-cache@1.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-AILekrrj/L4N/5z5TGtUKVie4nKjxDioCgOEymyYxzPhGfjIxfE71tN2VTTpiICEWJ883rPRj2+WinTr1b6yVA==",
+  "_location": "/@actions/tool-cache",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "@actions/tool-cache@1.1.1",
+    "name": "@actions/tool-cache",
+    "escapedName": "@actions%2ftool-cache",
+    "scope": "@actions",
+    "rawSpec": "1.1.1",
+    "saveSpec": null,
+    "fetchSpec": "1.1.1"
   },
-  "files": [
-    "lib",
-    "scripts"
+  "_requiredBy": [
+    "/"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/actions/toolkit.git"
-  },
-  "scripts": {
-    "test": "echo \"Error: run tests from root\" && exit 1",
-    "tsc": "tsc"
-  },
+  "_resolved": "https://registry.npmjs.org/@actions/tool-cache/-/tool-cache-1.1.1.tgz",
+  "_spec": "1.1.1",
+  "_where": "E:\\k8s-actions\\k8s-set-context",
   "bugs": {
     "url": "https://github.com/actions/toolkit/issues"
   },
@@ -40,11 +39,41 @@
     "typed-rest-client": "^1.4.0",
     "uuid": "^3.3.2"
   },
+  "description": "Actions tool-cache lib",
   "devDependencies": {
     "@types/nock": "^10.0.3",
     "@types/semver": "^6.0.0",
     "@types/uuid": "^3.4.4",
     "nock": "^10.0.6"
   },
-  "gitHead": "a2ab4bcf78e4f7080f0d45856e6eeba16f0bbc52"
+  "directories": {
+    "lib": "lib",
+    "test": "__tests__"
+  },
+  "files": [
+    "lib",
+    "scripts"
+  ],
+  "gitHead": "a2ab4bcf78e4f7080f0d45856e6eeba16f0bbc52",
+  "homepage": "https://github.com/actions/toolkit/tree/master/packages/exec",
+  "keywords": [
+    "github",
+    "actions",
+    "exec"
+  ],
+  "license": "MIT",
+  "main": "lib/tool-cache.js",
+  "name": "@actions/tool-cache",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/actions/toolkit.git"
+  },
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1",
+    "tsc": "tsc"
+  },
+  "version": "1.1.1"
 }

node_modules/@babel/code-frame/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2014-present Sebastian McKenzie and other contributors
-
-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.

node_modules/@babel/code-frame/README.md

@@ -1,19 +0,0 @@
-# @babel/code-frame
-
-> Generate errors that contain a code frame that point to source locations.
-
-See our website [@babel/code-frame](https://babeljs.io/docs/en/babel-code-frame) for more information.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/code-frame
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/code-frame --dev
-```

node_modules/@babel/code-frame/lib/index.js

@@ -1,167 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.codeFrameColumns = codeFrameColumns;
-exports.default = _default;
-
-var _highlight = _interopRequireWildcard(require("@babel/highlight"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-let deprecationWarningShown = false;
-
-function getDefs(chalk) {
-  return {
-    gutter: chalk.grey,
-    marker: chalk.red.bold,
-    message: chalk.red.bold
-  };
-}
-
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-
-function getMarkerLines(loc, source, opts) {
-  const startLoc = Object.assign({
-    column: 0,
-    line: -1
-  }, loc.start);
-  const endLoc = Object.assign({}, startLoc, loc.end);
-  const {
-    linesAbove = 2,
-    linesBelow = 3
-  } = opts || {};
-  const startLine = startLoc.line;
-  const startColumn = startLoc.column;
-  const endLine = endLoc.line;
-  const endColumn = endLoc.column;
-  let start = Math.max(startLine - (linesAbove + 1), 0);
-  let end = Math.min(source.length, endLine + linesBelow);
-
-  if (startLine === -1) {
-    start = 0;
-  }
-
-  if (endLine === -1) {
-    end = source.length;
-  }
-
-  const lineDiff = endLine - startLine;
-  const markerLines = {};
-
-  if (lineDiff) {
-    for (let i = 0; i <= lineDiff; i++) {
-      const lineNumber = i + startLine;
-
-      if (!startColumn) {
-        markerLines[lineNumber] = true;
-      } else if (i === 0) {
-        const sourceLength = source[lineNumber - 1].length;
-        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
-      } else if (i === lineDiff) {
-        markerLines[lineNumber] = [0, endColumn];
-      } else {
-        const sourceLength = source[lineNumber - i].length;
-        markerLines[lineNumber] = [0, sourceLength];
-      }
-    }
-  } else {
-    if (startColumn === endColumn) {
-      if (startColumn) {
-        markerLines[startLine] = [startColumn, 0];
-      } else {
-        markerLines[startLine] = true;
-      }
-    } else {
-      markerLines[startLine] = [startColumn, endColumn - startColumn];
-    }
-  }
-
-  return {
-    start,
-    end,
-    markerLines
-  };
-}
-
-function codeFrameColumns(rawLines, loc, opts = {}) {
-  const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
-  const chalk = (0, _highlight.getChalk)(opts);
-  const defs = getDefs(chalk);
-
-  const maybeHighlight = (chalkFn, string) => {
-    return highlighted ? chalkFn(string) : string;
-  };
-
-  const lines = rawLines.split(NEWLINE);
-  const {
-    start,
-    end,
-    markerLines
-  } = getMarkerLines(loc, lines, opts);
-  const hasColumns = loc.start && typeof loc.start.column === "number";
-  const numberMaxWidth = String(end).length;
-  const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
-  let frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => {
-    const number = start + 1 + index;
-    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
-    const gutter = ` ${paddedNumber} |`;
-    const hasMarker = markerLines[number];
-    const lastMarkerLine = !markerLines[number + 1];
-
-    if (hasMarker) {
-      let markerLine = "";
-
-      if (Array.isArray(hasMarker)) {
-        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
-        const numberOfMarkers = hasMarker[1] || 1;
-        markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
-
-        if (lastMarkerLine && opts.message) {
-          markerLine += " " + maybeHighlight(defs.message, opts.message);
-        }
-      }
-
-      return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
-    } else {
-      return ` ${maybeHighlight(defs.gutter, gutter)}${line.length > 0 ? ` ${line}` : ""}`;
-    }
-  }).join("\n");
-
-  if (opts.message && !hasColumns) {
-    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
-  }
-
-  if (highlighted) {
-    return chalk.reset(frame);
-  } else {
-    return frame;
-  }
-}
-
-function _default(rawLines, lineNumber, colNumber, opts = {}) {
-  if (!deprecationWarningShown) {
-    deprecationWarningShown = true;
-    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
-
-    if (process.emitWarning) {
-      process.emitWarning(message, "DeprecationWarning");
-    } else {
-      const deprecationError = new Error(message);
-      deprecationError.name = "DeprecationWarning";
-      console.warn(new Error(message));
-    }
-  }
-
-  colNumber = Math.max(colNumber, 0);
-  const location = {
-    start: {
-      column: colNumber,
-      line: lineNumber
-    }
-  };
-  return codeFrameColumns(rawLines, location, opts);
-}

node_modules/@babel/code-frame/package.json

@@ -1,26 +0,0 @@
-{
-  "name": "@babel/code-frame",
-  "version": "7.12.13",
-  "description": "Generate errors that contain a code frame that point to source locations.",
-  "author": "Sebastian McKenzie <sebmck@gmail.com>",
-  "homepage": "https://babel.dev/docs/en/next/babel-code-frame",
-  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/babel/babel.git",
-    "directory": "packages/babel-code-frame"
-  },
-  "main": "lib/index.js",
-  "dependencies": {
-    "@babel/highlight": "^7.12.13"
-  },
-  "devDependencies": {
-    "@types/chalk": "^2.0.0",
-    "chalk": "^2.0.0",
-    "strip-ansi": "^4.0.0"
-  }
-}

node_modules/@babel/compat-data/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2014-present Sebastian McKenzie and other contributors
-
-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.

node_modules/@babel/compat-data/corejs2-built-ins.js

@@ -1 +0,0 @@
-module.exports = require("./data/corejs2-built-ins.json");

node_modules/@babel/compat-data/corejs3-shipped-proposals.js

@@ -1 +0,0 @@
-module.exports = require("./data/corejs3-shipped-proposals.json");

node_modules/@babel/compat-data/data/corejs3-shipped-proposals.json

@@ -1,5 +0,0 @@
-[
-  "esnext.global-this",
-  "esnext.promise.all-settled",
-  "esnext.string.match-all"
-]

node_modules/@babel/compat-data/data/native-modules.json

@@ -1,18 +0,0 @@
-{
-  "es6.module": {
-    "chrome": "61",
-    "and_chr": "61",
-    "edge": "16",
-    "firefox": "60",
-    "and_ff": "60",
-    "node": "13.2.0",
-    "opera": "48",
-    "op_mob": "48",
-    "safari": "10.1",
-    "ios": "10.3",
-    "samsung": "8.2",
-    "android": "61",
-    "electron": "2.0",
-    "ios_saf": "10.3"
-  }
-}

node_modules/@babel/compat-data/data/overlapping-plugins.json

@@ -1,21 +0,0 @@
-{
-  "transform-async-to-generator": [
-    "bugfix/transform-async-arrows-in-class"
-  ],
-  "transform-parameters": [
-    "bugfix/transform-edge-default-parameters"
-  ],
-  "transform-function-name": [
-    "bugfix/transform-edge-function-name"
-  ],
-  "transform-block-scoping": [
-    "bugfix/transform-safari-block-shadowing",
-    "bugfix/transform-safari-for-shadowing"
-  ],
-  "transform-template-literals": [
-    "bugfix/transform-tagged-template-caching"
-  ],
-  "proposal-optional-chaining": [
-    "bugfix/transform-v8-spread-parameters-in-optional-chaining"
-  ]
-}

node_modules/@babel/compat-data/data/plugin-bugfixes.json

@@ -1,141 +0,0 @@
-{
-  "transform-async-to-generator": {
-    "chrome": "55",
-    "opera": "42",
-    "edge": "15",
-    "firefox": "52",
-    "safari": "10.1",
-    "node": "7.6",
-    "ios": "10.3",
-    "samsung": "6",
-    "electron": "1.6"
-  },
-  "bugfix/transform-async-arrows-in-class": {
-    "chrome": "55",
-    "opera": "42",
-    "edge": "15",
-    "firefox": "52",
-    "safari": "11",
-    "node": "7.6",
-    "ios": "11",
-    "samsung": "6",
-    "electron": "1.6"
-  },
-  "transform-parameters": {
-    "chrome": "49",
-    "opera": "36",
-    "edge": "15",
-    "firefox": "53",
-    "safari": "10",
-    "node": "6",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.37"
-  },
-  "bugfix/transform-edge-default-parameters": {
-    "chrome": "49",
-    "opera": "36",
-    "edge": "18",
-    "firefox": "52",
-    "safari": "10",
-    "node": "6",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.37"
-  },
-  "transform-function-name": {
-    "chrome": "51",
-    "opera": "38",
-    "edge": "14",
-    "firefox": "53",
-    "safari": "10",
-    "node": "6.5",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "1.2"
-  },
-  "bugfix/transform-edge-function-name": {
-    "chrome": "51",
-    "opera": "38",
-    "edge": "79",
-    "firefox": "53",
-    "safari": "10",
-    "node": "6.5",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "1.2"
-  },
-  "transform-block-scoping": {
-    "chrome": "49",
-    "opera": "36",
-    "edge": "14",
-    "firefox": "51",
-    "safari": "10",
-    "node": "6",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.37"
-  },
-  "bugfix/transform-safari-block-shadowing": {
-    "chrome": "49",
-    "opera": "36",
-    "edge": "12",
-    "firefox": "44",
-    "safari": "11",
-    "node": "6",
-    "ie": "11",
-    "ios": "11",
-    "samsung": "5",
-    "electron": "0.37"
-  },
-  "bugfix/transform-safari-for-shadowing": {
-    "chrome": "49",
-    "opera": "36",
-    "edge": "12",
-    "firefox": "4",
-    "safari": "11",
-    "node": "6",
-    "ie": "11",
-    "ios": "11",
-    "samsung": "5",
-    "electron": "0.37"
-  },
-  "transform-template-literals": {
-    "chrome": "41",
-    "opera": "28",
-    "edge": "13",
-    "firefox": "34",
-    "safari": "9",
-    "node": "4",
-    "ios": "9",
-    "samsung": "3.4",
-    "electron": "0.21"
-  },
-  "bugfix/transform-tagged-template-caching": {
-    "chrome": "41",
-    "opera": "28",
-    "edge": "12",
-    "firefox": "34",
-    "safari": "13",
-    "node": "4",
-    "ios": "13",
-    "samsung": "3.4",
-    "electron": "0.21"
-  },
-  "proposal-optional-chaining": {
-    "chrome": "80",
-    "opera": "67",
-    "edge": "80",
-    "firefox": "74",
-    "safari": "13.1",
-    "node": "14",
-    "ios": "13.4",
-    "samsung": "13",
-    "electron": "8.0"
-  },
-  "bugfix/transform-v8-spread-parameters-in-optional-chaining": {
-    "firefox": "74",
-    "safari": "13.1",
-    "ios": "13.4"
-  }
-}

node_modules/@babel/compat-data/data/plugins.json

@@ -1,451 +0,0 @@
-{
-  "proposal-class-static-block": {
-    "chrome": "91"
-  },
-  "proposal-private-property-in-object": {
-    "chrome": "91",
-    "firefox": "90"
-  },
-  "proposal-class-properties": {
-    "chrome": "74",
-    "opera": "62",
-    "edge": "79",
-    "firefox": "90",
-    "safari": "14.1",
-    "node": "12",
-    "samsung": "11",
-    "electron": "6.0"
-  },
-  "proposal-private-methods": {
-    "chrome": "84",
-    "opera": "70",
-    "edge": "84",
-    "firefox": "90",
-    "safari": "tp",
-    "node": "14.6",
-    "electron": "10.0"
-  },
-  "proposal-numeric-separator": {
-    "chrome": "75",
-    "opera": "62",
-    "edge": "79",
-    "firefox": "70",
-    "safari": "13",
-    "node": "12.5",
-    "ios": "13",
-    "samsung": "11",
-    "electron": "6.0"
-  },
-  "proposal-logical-assignment-operators": {
-    "chrome": "85",
-    "opera": "71",
-    "edge": "85",
-    "firefox": "79",
-    "safari": "14",
-    "node": "15",
-    "ios": "14",
-    "electron": "10.0"
-  },
-  "proposal-nullish-coalescing-operator": {
-    "chrome": "80",
-    "opera": "67",
-    "edge": "80",
-    "firefox": "72",
-    "safari": "13.1",
-    "node": "14",
-    "ios": "13.4",
-    "samsung": "13",
-    "electron": "8.0"
-  },
-  "proposal-optional-chaining": {
-    "firefox": "74",
-    "safari": "13.1",
-    "ios": "13.4"
-  },
-  "proposal-json-strings": {
-    "chrome": "66",
-    "opera": "53",
-    "edge": "79",
-    "firefox": "62",
-    "safari": "12",
-    "node": "10",
-    "ios": "12",
-    "samsung": "9",
-    "electron": "3.0"
-  },
-  "proposal-optional-catch-binding": {
-    "chrome": "66",
-    "opera": "53",
-    "edge": "79",
-    "firefox": "58",
-    "safari": "11.1",
-    "node": "10",
-    "ios": "11.3",
-    "samsung": "9",
-    "electron": "3.0"
-  },
-  "transform-parameters": {
-    "chrome": "49",
-    "opera": "36",
-    "edge": "18",
-    "firefox": "53",
-    "safari": "10",
-    "node": "6",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.37"
-  },
-  "proposal-async-generator-functions": {
-    "chrome": "63",
-    "opera": "50",
-    "edge": "79",
-    "firefox": "57",
-    "safari": "12",
-    "node": "10",
-    "ios": "12",
-    "samsung": "8",
-    "electron": "3.0"
-  },
-  "proposal-object-rest-spread": {
-    "chrome": "60",
-    "opera": "47",
-    "edge": "79",
-    "firefox": "55",
-    "safari": "11.1",
-    "node": "8.3",
-    "ios": "11.3",
-    "samsung": "8",
-    "electron": "2.0"
-  },
-  "transform-dotall-regex": {
-    "chrome": "62",
-    "opera": "49",
-    "edge": "79",
-    "firefox": "78",
-    "safari": "11.1",
-    "node": "8.10",
-    "ios": "11.3",
-    "samsung": "8",
-    "electron": "3.0"
-  },
-  "proposal-unicode-property-regex": {
-    "chrome": "64",
-    "opera": "51",
-    "edge": "79",
-    "firefox": "78",
-    "safari": "11.1",
-    "node": "10",
-    "ios": "11.3",
-    "samsung": "9",
-    "electron": "3.0"
-  },
-  "transform-named-capturing-groups-regex": {
-    "chrome": "64",
-    "opera": "51",
-    "edge": "79",
-    "firefox": "78",
-    "safari": "11.1",
-    "node": "10",
-    "ios": "11.3",
-    "samsung": "9",
-    "electron": "3.0"
-  },
-  "transform-async-to-generator": {
-    "chrome": "55",
-    "opera": "42",
-    "edge": "15",
-    "firefox": "52",
-    "safari": "11",
-    "node": "7.6",
-    "ios": "11",
-    "samsung": "6",
-    "electron": "1.6"
-  },
-  "transform-exponentiation-operator": {
-    "chrome": "52",
-    "opera": "39",
-    "edge": "14",
-    "firefox": "52",
-    "safari": "10.1",
-    "node": "7",
-    "ios": "10.3",
-    "samsung": "6",
-    "electron": "1.3"
-  },
-  "transform-template-literals": {
-    "chrome": "41",
-    "opera": "28",
-    "edge": "13",
-    "firefox": "34",
-    "safari": "13",
-    "node": "4",
-    "ios": "13",
-    "samsung": "3.4",
-    "electron": "0.21"
-  },
-  "transform-literals": {
-    "chrome": "44",
-    "opera": "31",
-    "edge": "12",
-    "firefox": "53",
-    "safari": "9",
-    "node": "4",
-    "ios": "9",
-    "samsung": "4",
-    "electron": "0.30"
-  },
-  "transform-function-name": {
-    "chrome": "51",
-    "opera": "38",
-    "edge": "79",
-    "firefox": "53",
-    "safari": "10",
-    "node": "6.5",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "1.2"
-  },
-  "transform-arrow-functions": {
-    "chrome": "47",
-    "opera": "34",
-    "edge": "13",
-    "firefox": "45",
-    "safari": "10",
-    "node": "6",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.36"
-  },
-  "transform-block-scoped-functions": {
-    "chrome": "41",
-    "opera": "28",
-    "edge": "12",
-    "firefox": "46",
-    "safari": "10",
-    "node": "4",
-    "ie": "11",
-    "ios": "10",
-    "samsung": "3.4",
-    "electron": "0.21"
-  },
-  "transform-classes": {
-    "chrome": "46",
-    "opera": "33",
-    "edge": "13",
-    "firefox": "45",
-    "safari": "10",
-    "node": "5",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.36"
-  },
-  "transform-object-super": {
-    "chrome": "46",
-    "opera": "33",
-    "edge": "13",
-    "firefox": "45",
-    "safari": "10",
-    "node": "5",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.36"
-  },
-  "transform-shorthand-properties": {
-    "chrome": "43",
-    "opera": "30",
-    "edge": "12",
-    "firefox": "33",
-    "safari": "9",
-    "node": "4",
-    "ios": "9",
-    "samsung": "4",
-    "electron": "0.27"
-  },
-  "transform-duplicate-keys": {
-    "chrome": "42",
-    "opera": "29",
-    "edge": "12",
-    "firefox": "34",
-    "safari": "9",
-    "node": "4",
-    "ios": "9",
-    "samsung": "3.4",
-    "electron": "0.25"
-  },
-  "transform-computed-properties": {
-    "chrome": "44",
-    "opera": "31",
-    "edge": "12",
-    "firefox": "34",
-    "safari": "7.1",
-    "node": "4",
-    "ios": "8",
-    "samsung": "4",
-    "electron": "0.30"
-  },
-  "transform-for-of": {
-    "chrome": "51",
-    "opera": "38",
-    "edge": "15",
-    "firefox": "53",
-    "safari": "10",
-    "node": "6.5",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "1.2"
-  },
-  "transform-sticky-regex": {
-    "chrome": "49",
-    "opera": "36",
-    "edge": "13",
-    "firefox": "3",
-    "safari": "10",
-    "node": "6",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.37"
-  },
-  "transform-unicode-escapes": {
-    "chrome": "44",
-    "opera": "31",
-    "edge": "12",
-    "firefox": "53",
-    "safari": "9",
-    "node": "4",
-    "ios": "9",
-    "samsung": "4",
-    "electron": "0.30"
-  },
-  "transform-unicode-regex": {
-    "chrome": "50",
-    "opera": "37",
-    "edge": "13",
-    "firefox": "46",
-    "safari": "12",
-    "node": "6",
-    "ios": "12",
-    "samsung": "5",
-    "electron": "1.1"
-  },
-  "transform-spread": {
-    "chrome": "46",
-    "opera": "33",
-    "edge": "13",
-    "firefox": "45",
-    "safari": "10",
-    "node": "5",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.36"
-  },
-  "transform-destructuring": {
-    "chrome": "51",
-    "opera": "38",
-    "edge": "15",
-    "firefox": "53",
-    "safari": "10",
-    "node": "6.5",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "1.2"
-  },
-  "transform-block-scoping": {
-    "chrome": "49",
-    "opera": "36",
-    "edge": "14",
-    "firefox": "51",
-    "safari": "11",
-    "node": "6",
-    "ios": "11",
-    "samsung": "5",
-    "electron": "0.37"
-  },
-  "transform-typeof-symbol": {
-    "chrome": "38",
-    "opera": "25",
-    "edge": "12",
-    "firefox": "36",
-    "safari": "9",
-    "node": "0.12",
-    "ios": "9",
-    "samsung": "3",
-    "electron": "0.20"
-  },
-  "transform-new-target": {
-    "chrome": "46",
-    "opera": "33",
-    "edge": "14",
-    "firefox": "41",
-    "safari": "10",
-    "node": "5",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "0.36"
-  },
-  "transform-regenerator": {
-    "chrome": "50",
-    "opera": "37",
-    "edge": "13",
-    "firefox": "53",
-    "safari": "10",
-    "node": "6",
-    "ios": "10",
-    "samsung": "5",
-    "electron": "1.1"
-  },
-  "transform-member-expression-literals": {
-    "chrome": "7",
-    "opera": "12",
-    "edge": "12",
-    "firefox": "2",
-    "safari": "5.1",
-    "node": "0.10",
-    "ie": "9",
-    "android": "4",
-    "ios": "6",
-    "phantom": "2",
-    "samsung": "1",
-    "electron": "0.20"
-  },
-  "transform-property-literals": {
-    "chrome": "7",
-    "opera": "12",
-    "edge": "12",
-    "firefox": "2",
-    "safari": "5.1",
-    "node": "0.10",
-    "ie": "9",
-    "android": "4",
-    "ios": "6",
-    "phantom": "2",
-    "samsung": "1",
-    "electron": "0.20"
-  },
-  "transform-reserved-words": {
-    "chrome": "13",
-    "opera": "10.50",
-    "edge": "12",
-    "firefox": "2",
-    "safari": "3.1",
-    "node": "0.10",
-    "ie": "9",
-    "android": "4.4",
-    "ios": "6",
-    "phantom": "2",
-    "samsung": "1",
-    "electron": "0.20"
-  },
-  "proposal-export-namespace-from": {
-    "chrome": "72",
-    "and_chr": "72",
-    "edge": "79",
-    "firefox": "80",
-    "and_ff": "80",
-    "node": "13.2",
-    "opera": "60",
-    "op_mob": "51",
-    "samsung": "11.0",
-    "android": "72",
-    "electron": "5.0"
-  }
-}

node_modules/@babel/compat-data/native-modules.js

@@ -1 +0,0 @@
-module.exports = require("./data/native-modules.json");

node_modules/@babel/compat-data/overlapping-plugins.js

@@ -1 +0,0 @@
-module.exports = require("./data/overlapping-plugins.json");

node_modules/@babel/compat-data/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "@babel/compat-data",
-  "version": "7.14.4",
-  "author": "The Babel Team (https://babel.dev/team)",
-  "license": "MIT",
-  "description": "",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/babel/babel.git",
-    "directory": "packages/babel-compat-data"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "exports": {
-    "./plugins": "./plugins.js",
-    "./native-modules": "./native-modules.js",
-    "./corejs2-built-ins": "./corejs2-built-ins.js",
-    "./corejs3-shipped-proposals": "./corejs3-shipped-proposals.js",
-    "./overlapping-plugins": "./overlapping-plugins.js",
-    "./plugin-bugfixes": "./plugin-bugfixes.js"
-  },
-  "scripts": {
-    "build-data": "./scripts/download-compat-table.sh && node ./scripts/build-data.js && node ./scripts/build-modules-support.js && node ./scripts/build-bugfixes-targets.js"
-  },
-  "keywords": [
-    "babel",
-    "compat-table",
-    "compat-data"
-  ],
-  "devDependencies": {
-    "@mdn/browser-compat-data": "^3.3.4",
-    "core-js-compat": "^3.9.0",
-    "electron-to-chromium": "^1.3.738"
-  }
-}

node_modules/@babel/compat-data/plugin-bugfixes.js

@@ -1 +0,0 @@
-module.exports = require("./data/plugin-bugfixes.json");

node_modules/@babel/compat-data/plugins.js

@@ -1 +0,0 @@
-module.exports = require("./data/plugins.json");

node_modules/@babel/core/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2014-present Sebastian McKenzie and other contributors
-
-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.

node_modules/@babel/core/README.md

@@ -1,19 +0,0 @@
-# @babel/core
-
-> Babel compiler core.
-
-See our website [@babel/core](https://babeljs.io/docs/en/babel-core) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20core%22+is%3Aopen) associated with this package.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/core
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/core --dev
-```

node_modules/@babel/core/lib/config/caching.js

@@ -1,325 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeWeakCache = makeWeakCache;
-exports.makeWeakCacheSync = makeWeakCacheSync;
-exports.makeStrongCache = makeStrongCache;
-exports.makeStrongCacheSync = makeStrongCacheSync;
-exports.assertSimpleType = assertSimpleType;
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _async = require("../gensync-utils/async");
-
-var _util = require("./util");
-
-const synchronize = gen => {
-  return _gensync()(gen).sync;
-};
-
-function* genTrue() {
-  return true;
-}
-
-function makeWeakCache(handler) {
-  return makeCachedFunction(WeakMap, handler);
-}
-
-function makeWeakCacheSync(handler) {
-  return synchronize(makeWeakCache(handler));
-}
-
-function makeStrongCache(handler) {
-  return makeCachedFunction(Map, handler);
-}
-
-function makeStrongCacheSync(handler) {
-  return synchronize(makeStrongCache(handler));
-}
-
-function makeCachedFunction(CallCache, handler) {
-  const callCacheSync = new CallCache();
-  const callCacheAsync = new CallCache();
-  const futureCache = new CallCache();
-  return function* cachedFunction(arg, data) {
-    const asyncContext = yield* (0, _async.isAsync)();
-    const callCache = asyncContext ? callCacheAsync : callCacheSync;
-    const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data);
-    if (cached.valid) return cached.value;
-    const cache = new CacheConfigurator(data);
-    const handlerResult = handler(arg, cache);
-    let finishLock;
-    let value;
-
-    if ((0, _util.isIterableIterator)(handlerResult)) {
-      const gen = handlerResult;
-      value = yield* (0, _async.onFirstPause)(gen, () => {
-        finishLock = setupAsyncLocks(cache, futureCache, arg);
-      });
-    } else {
-      value = handlerResult;
-    }
-
-    updateFunctionCache(callCache, cache, arg, value);
-
-    if (finishLock) {
-      futureCache.delete(arg);
-      finishLock.release(value);
-    }
-
-    return value;
-  };
-}
-
-function* getCachedValue(cache, arg, data) {
-  const cachedValue = cache.get(arg);
-
-  if (cachedValue) {
-    for (const {
-      value,
-      valid
-    } of cachedValue) {
-      if (yield* valid(data)) return {
-        valid: true,
-        value
-      };
-    }
-  }
-
-  return {
-    valid: false,
-    value: null
-  };
-}
-
-function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data) {
-  const cached = yield* getCachedValue(callCache, arg, data);
-
-  if (cached.valid) {
-    return cached;
-  }
-
-  if (asyncContext) {
-    const cached = yield* getCachedValue(futureCache, arg, data);
-
-    if (cached.valid) {
-      const value = yield* (0, _async.waitFor)(cached.value.promise);
-      return {
-        valid: true,
-        value
-      };
-    }
-  }
-
-  return {
-    valid: false,
-    value: null
-  };
-}
-
-function setupAsyncLocks(config, futureCache, arg) {
-  const finishLock = new Lock();
-  updateFunctionCache(futureCache, config, arg, finishLock);
-  return finishLock;
-}
-
-function updateFunctionCache(cache, config, arg, value) {
-  if (!config.configured()) config.forever();
-  let cachedValue = cache.get(arg);
-  config.deactivate();
-
-  switch (config.mode()) {
-    case "forever":
-      cachedValue = [{
-        value,
-        valid: genTrue
-      }];
-      cache.set(arg, cachedValue);
-      break;
-
-    case "invalidate":
-      cachedValue = [{
-        value,
-        valid: config.validator()
-      }];
-      cache.set(arg, cachedValue);
-      break;
-
-    case "valid":
-      if (cachedValue) {
-        cachedValue.push({
-          value,
-          valid: config.validator()
-        });
-      } else {
-        cachedValue = [{
-          value,
-          valid: config.validator()
-        }];
-        cache.set(arg, cachedValue);
-      }
-
-  }
-}
-
-class CacheConfigurator {
-  constructor(data) {
-    this._active = true;
-    this._never = false;
-    this._forever = false;
-    this._invalidate = false;
-    this._configured = false;
-    this._pairs = [];
-    this._data = void 0;
-    this._data = data;
-  }
-
-  simple() {
-    return makeSimpleConfigurator(this);
-  }
-
-  mode() {
-    if (this._never) return "never";
-    if (this._forever) return "forever";
-    if (this._invalidate) return "invalidate";
-    return "valid";
-  }
-
-  forever() {
-    if (!this._active) {
-      throw new Error("Cannot change caching after evaluation has completed.");
-    }
-
-    if (this._never) {
-      throw new Error("Caching has already been configured with .never()");
-    }
-
-    this._forever = true;
-    this._configured = true;
-  }
-
-  never() {
-    if (!this._active) {
-      throw new Error("Cannot change caching after evaluation has completed.");
-    }
-
-    if (this._forever) {
-      throw new Error("Caching has already been configured with .forever()");
-    }
-
-    this._never = true;
-    this._configured = true;
-  }
-
-  using(handler) {
-    if (!this._active) {
-      throw new Error("Cannot change caching after evaluation has completed.");
-    }
-
-    if (this._never || this._forever) {
-      throw new Error("Caching has already been configured with .never or .forever()");
-    }
-
-    this._configured = true;
-    const key = handler(this._data);
-    const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
-
-    if ((0, _async.isThenable)(key)) {
-      return key.then(key => {
-        this._pairs.push([key, fn]);
-
-        return key;
-      });
-    }
-
-    this._pairs.push([key, fn]);
-
-    return key;
-  }
-
-  invalidate(handler) {
-    this._invalidate = true;
-    return this.using(handler);
-  }
-
-  validator() {
-    const pairs = this._pairs;
-    return function* (data) {
-      for (const [key, fn] of pairs) {
-        if (key !== (yield* fn(data))) return false;
-      }
-
-      return true;
-    };
-  }
-
-  deactivate() {
-    this._active = false;
-  }
-
-  configured() {
-    return this._configured;
-  }
-
-}
-
-function makeSimpleConfigurator(cache) {
-  function cacheFn(val) {
-    if (typeof val === "boolean") {
-      if (val) cache.forever();else cache.never();
-      return;
-    }
-
-    return cache.using(() => assertSimpleType(val()));
-  }
-
-  cacheFn.forever = () => cache.forever();
-
-  cacheFn.never = () => cache.never();
-
-  cacheFn.using = cb => cache.using(() => assertSimpleType(cb()));
-
-  cacheFn.invalidate = cb => cache.invalidate(() => assertSimpleType(cb()));
-
-  return cacheFn;
-}
-
-function assertSimpleType(value) {
-  if ((0, _async.isThenable)(value)) {
-    throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`);
-  }
-
-  if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") {
-    throw new Error("Cache keys must be either string, boolean, number, null, or undefined.");
-  }
-
-  return value;
-}
-
-class Lock {
-  constructor() {
-    this.released = false;
-    this.promise = void 0;
-    this._resolve = void 0;
-    this.promise = new Promise(resolve => {
-      this._resolve = resolve;
-    });
-  }
-
-  release(value) {
-    this.released = true;
-
-    this._resolve(value);
-  }
-
-}

node_modules/@babel/core/lib/config/config-chain.js

@@ -1,556 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.buildPresetChain = buildPresetChain;
-exports.buildRootChain = buildRootChain;
-exports.buildPresetChainWalker = void 0;
-
-function _path() {
-  const data = require("path");
-
-  _path = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _debug() {
-  const data = require("debug");
-
-  _debug = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _options = require("./validation/options");
-
-var _patternToRegex = require("./pattern-to-regex");
-
-var _printer = require("./printer");
-
-var _files = require("./files");
-
-var _caching = require("./caching");
-
-var _configDescriptors = require("./config-descriptors");
-
-const debug = _debug()("babel:config:config-chain");
-
-function* buildPresetChain(arg, context) {
-  const chain = yield* buildPresetChainWalker(arg, context);
-  if (!chain) return null;
-  return {
-    plugins: dedupDescriptors(chain.plugins),
-    presets: dedupDescriptors(chain.presets),
-    options: chain.options.map(o => normalizeOptions(o)),
-    files: new Set()
-  };
-}
-
-const buildPresetChainWalker = makeChainWalker({
-  root: preset => loadPresetDescriptors(preset),
-  env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),
-  overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index),
-  overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName),
-  createLogger: () => () => {}
-});
-exports.buildPresetChainWalker = buildPresetChainWalker;
-const loadPresetDescriptors = (0, _caching.makeWeakCacheSync)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
-const loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
-const loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
-const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
-
-function* buildRootChain(opts, context) {
-  let configReport, babelRcReport;
-  const programmaticLogger = new _printer.ConfigPrinter();
-  const programmaticChain = yield* loadProgrammaticChain({
-    options: opts,
-    dirname: context.cwd
-  }, context, undefined, programmaticLogger);
-  if (!programmaticChain) return null;
-  const programmaticReport = yield* programmaticLogger.output();
-  let configFile;
-
-  if (typeof opts.configFile === "string") {
-    configFile = yield* (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
-  } else if (opts.configFile !== false) {
-    configFile = yield* (0, _files.findRootConfig)(context.root, context.envName, context.caller);
-  }
-
-  let {
-    babelrc,
-    babelrcRoots
-  } = opts;
-  let babelrcRootsDirectory = context.cwd;
-  const configFileChain = emptyChain();
-  const configFileLogger = new _printer.ConfigPrinter();
-
-  if (configFile) {
-    const validatedFile = validateConfigFile(configFile);
-    const result = yield* loadFileChain(validatedFile, context, undefined, configFileLogger);
-    if (!result) return null;
-    configReport = yield* configFileLogger.output();
-
-    if (babelrc === undefined) {
-      babelrc = validatedFile.options.babelrc;
-    }
-
-    if (babelrcRoots === undefined) {
-      babelrcRootsDirectory = validatedFile.dirname;
-      babelrcRoots = validatedFile.options.babelrcRoots;
-    }
-
-    mergeChain(configFileChain, result);
-  }
-
-  let ignoreFile, babelrcFile;
-  let isIgnored = false;
-  const fileChain = emptyChain();
-
-  if ((babelrc === true || babelrc === undefined) && typeof context.filename === "string") {
-    const pkgData = yield* (0, _files.findPackageData)(context.filename);
-
-    if (pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)) {
-      ({
-        ignore: ignoreFile,
-        config: babelrcFile
-      } = yield* (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller));
-
-      if (ignoreFile) {
-        fileChain.files.add(ignoreFile.filepath);
-      }
-
-      if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
-        isIgnored = true;
-      }
-
-      if (babelrcFile && !isIgnored) {
-        const validatedFile = validateBabelrcFile(babelrcFile);
-        const babelrcLogger = new _printer.ConfigPrinter();
-        const result = yield* loadFileChain(validatedFile, context, undefined, babelrcLogger);
-
-        if (!result) {
-          isIgnored = true;
-        } else {
-          babelRcReport = yield* babelrcLogger.output();
-          mergeChain(fileChain, result);
-        }
-      }
-
-      if (babelrcFile && isIgnored) {
-        fileChain.files.add(babelrcFile.filepath);
-      }
-    }
-  }
-
-  if (context.showConfig) {
-    console.log(`Babel configs on "${context.filename}" (ascending priority):\n` + [configReport, babelRcReport, programmaticReport].filter(x => !!x).join("\n\n") + "\n-----End Babel configs-----");
-  }
-
-  const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
-  return {
-    plugins: isIgnored ? [] : dedupDescriptors(chain.plugins),
-    presets: isIgnored ? [] : dedupDescriptors(chain.presets),
-    options: isIgnored ? [] : chain.options.map(o => normalizeOptions(o)),
-    fileHandling: isIgnored ? "ignored" : "transpile",
-    ignore: ignoreFile || undefined,
-    babelrc: babelrcFile || undefined,
-    config: configFile || undefined,
-    files: chain.files
-  };
-}
-
-function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory) {
-  if (typeof babelrcRoots === "boolean") return babelrcRoots;
-  const absoluteRoot = context.root;
-
-  if (babelrcRoots === undefined) {
-    return pkgData.directories.indexOf(absoluteRoot) !== -1;
-  }
-
-  let babelrcPatterns = babelrcRoots;
-
-  if (!Array.isArray(babelrcPatterns)) {
-    babelrcPatterns = [babelrcPatterns];
-  }
-
-  babelrcPatterns = babelrcPatterns.map(pat => {
-    return typeof pat === "string" ? _path().resolve(babelrcRootsDirectory, pat) : pat;
-  });
-
-  if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {
-    return pkgData.directories.indexOf(absoluteRoot) !== -1;
-  }
-
-  return babelrcPatterns.some(pat => {
-    if (typeof pat === "string") {
-      pat = (0, _patternToRegex.default)(pat, babelrcRootsDirectory);
-    }
-
-    return pkgData.directories.some(directory => {
-      return matchPattern(pat, babelrcRootsDirectory, directory, context);
-    });
-  });
-}
-
-const validateConfigFile = (0, _caching.makeWeakCacheSync)(file => ({
-  filepath: file.filepath,
-  dirname: file.dirname,
-  options: (0, _options.validate)("configfile", file.options)
-}));
-const validateBabelrcFile = (0, _caching.makeWeakCacheSync)(file => ({
-  filepath: file.filepath,
-  dirname: file.dirname,
-  options: (0, _options.validate)("babelrcfile", file.options)
-}));
-const validateExtendFile = (0, _caching.makeWeakCacheSync)(file => ({
-  filepath: file.filepath,
-  dirname: file.dirname,
-  options: (0, _options.validate)("extendsfile", file.options)
-}));
-const loadProgrammaticChain = makeChainWalker({
-  root: input => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors),
-  env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName),
-  overrides: (input, index) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index),
-  overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName),
-  createLogger: (input, context, baseLogger) => buildProgrammaticLogger(input, context, baseLogger)
-});
-const loadFileChainWalker = makeChainWalker({
-  root: file => loadFileDescriptors(file),
-  env: (file, envName) => loadFileEnvDescriptors(file)(envName),
-  overrides: (file, index) => loadFileOverridesDescriptors(file)(index),
-  overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName),
-  createLogger: (file, context, baseLogger) => buildFileLogger(file.filepath, context, baseLogger)
-});
-
-function* loadFileChain(input, context, files, baseLogger) {
-  const chain = yield* loadFileChainWalker(input, context, files, baseLogger);
-
-  if (chain) {
-    chain.files.add(input.filepath);
-  }
-
-  return chain;
-}
-
-const loadFileDescriptors = (0, _caching.makeWeakCacheSync)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
-const loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
-const loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
-const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
-
-function buildFileLogger(filepath, context, baseLogger) {
-  if (!baseLogger) {
-    return () => {};
-  }
-
-  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Config, {
-    filepath
-  });
-}
-
-function buildRootDescriptors({
-  dirname,
-  options
-}, alias, descriptors) {
-  return descriptors(dirname, options, alias);
-}
-
-function buildProgrammaticLogger(_, context, baseLogger) {
-  var _context$caller;
-
-  if (!baseLogger) {
-    return () => {};
-  }
-
-  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Programmatic, {
-    callerName: (_context$caller = context.caller) == null ? void 0 : _context$caller.name
-  });
-}
-
-function buildEnvDescriptors({
-  dirname,
-  options
-}, alias, descriptors, envName) {
-  const opts = options.env && options.env[envName];
-  return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null;
-}
-
-function buildOverrideDescriptors({
-  dirname,
-  options
-}, alias, descriptors, index) {
-  const opts = options.overrides && options.overrides[index];
-  if (!opts) throw new Error("Assertion failure - missing override");
-  return descriptors(dirname, opts, `${alias}.overrides[${index}]`);
-}
-
-function buildOverrideEnvDescriptors({
-  dirname,
-  options
-}, alias, descriptors, index, envName) {
-  const override = options.overrides && options.overrides[index];
-  if (!override) throw new Error("Assertion failure - missing override");
-  const opts = override.env && override.env[envName];
-  return opts ? descriptors(dirname, opts, `${alias}.overrides[${index}].env["${envName}"]`) : null;
-}
-
-function makeChainWalker({
-  root,
-  env,
-  overrides,
-  overridesEnv,
-  createLogger
-}) {
-  return function* (input, context, files = new Set(), baseLogger) {
-    const {
-      dirname
-    } = input;
-    const flattenedConfigs = [];
-    const rootOpts = root(input);
-
-    if (configIsApplicable(rootOpts, dirname, context)) {
-      flattenedConfigs.push({
-        config: rootOpts,
-        envName: undefined,
-        index: undefined
-      });
-      const envOpts = env(input, context.envName);
-
-      if (envOpts && configIsApplicable(envOpts, dirname, context)) {
-        flattenedConfigs.push({
-          config: envOpts,
-          envName: context.envName,
-          index: undefined
-        });
-      }
-
-      (rootOpts.options.overrides || []).forEach((_, index) => {
-        const overrideOps = overrides(input, index);
-
-        if (configIsApplicable(overrideOps, dirname, context)) {
-          flattenedConfigs.push({
-            config: overrideOps,
-            index,
-            envName: undefined
-          });
-          const overrideEnvOpts = overridesEnv(input, index, context.envName);
-
-          if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context)) {
-            flattenedConfigs.push({
-              config: overrideEnvOpts,
-              index,
-              envName: context.envName
-            });
-          }
-        }
-      });
-    }
-
-    if (flattenedConfigs.some(({
-      config: {
-        options: {
-          ignore,
-          only
-        }
-      }
-    }) => shouldIgnore(context, ignore, only, dirname))) {
-      return null;
-    }
-
-    const chain = emptyChain();
-    const logger = createLogger(input, context, baseLogger);
-
-    for (const {
-      config,
-      index,
-      envName
-    } of flattenedConfigs) {
-      if (!(yield* mergeExtendsChain(chain, config.options, dirname, context, files, baseLogger))) {
-        return null;
-      }
-
-      logger(config, index, envName);
-      yield* mergeChainOpts(chain, config);
-    }
-
-    return chain;
-  };
-}
-
-function* mergeExtendsChain(chain, opts, dirname, context, files, baseLogger) {
-  if (opts.extends === undefined) return true;
-  const file = yield* (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller);
-
-  if (files.has(file)) {
-    throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n"));
-  }
-
-  files.add(file);
-  const fileChain = yield* loadFileChain(validateExtendFile(file), context, files, baseLogger);
-  files.delete(file);
-  if (!fileChain) return false;
-  mergeChain(chain, fileChain);
-  return true;
-}
-
-function mergeChain(target, source) {
-  target.options.push(...source.options);
-  target.plugins.push(...source.plugins);
-  target.presets.push(...source.presets);
-
-  for (const file of source.files) {
-    target.files.add(file);
-  }
-
-  return target;
-}
-
-function* mergeChainOpts(target, {
-  options,
-  plugins,
-  presets
-}) {
-  target.options.push(options);
-  target.plugins.push(...(yield* plugins()));
-  target.presets.push(...(yield* presets()));
-  return target;
-}
-
-function emptyChain() {
-  return {
-    options: [],
-    presets: [],
-    plugins: [],
-    files: new Set()
-  };
-}
-
-function normalizeOptions(opts) {
-  const options = Object.assign({}, opts);
-  delete options.extends;
-  delete options.env;
-  delete options.overrides;
-  delete options.plugins;
-  delete options.presets;
-  delete options.passPerPreset;
-  delete options.ignore;
-  delete options.only;
-  delete options.test;
-  delete options.include;
-  delete options.exclude;
-
-  if (Object.prototype.hasOwnProperty.call(options, "sourceMap")) {
-    options.sourceMaps = options.sourceMap;
-    delete options.sourceMap;
-  }
-
-  return options;
-}
-
-function dedupDescriptors(items) {
-  const map = new Map();
-  const descriptors = [];
-
-  for (const item of items) {
-    if (typeof item.value === "function") {
-      const fnKey = item.value;
-      let nameMap = map.get(fnKey);
-
-      if (!nameMap) {
-        nameMap = new Map();
-        map.set(fnKey, nameMap);
-      }
-
-      let desc = nameMap.get(item.name);
-
-      if (!desc) {
-        desc = {
-          value: item
-        };
-        descriptors.push(desc);
-        if (!item.ownPass) nameMap.set(item.name, desc);
-      } else {
-        desc.value = item;
-      }
-    } else {
-      descriptors.push({
-        value: item
-      });
-    }
-  }
-
-  return descriptors.reduce((acc, desc) => {
-    acc.push(desc.value);
-    return acc;
-  }, []);
-}
-
-function configIsApplicable({
-  options
-}, dirname, context) {
-  return (options.test === undefined || configFieldIsApplicable(context, options.test, dirname)) && (options.include === undefined || configFieldIsApplicable(context, options.include, dirname)) && (options.exclude === undefined || !configFieldIsApplicable(context, options.exclude, dirname));
-}
-
-function configFieldIsApplicable(context, test, dirname) {
-  const patterns = Array.isArray(test) ? test : [test];
-  return matchesPatterns(context, patterns, dirname);
-}
-
-function shouldIgnore(context, ignore, only, dirname) {
-  if (ignore && matchesPatterns(context, ignore, dirname)) {
-    var _context$filename;
-
-    const message = `No config is applied to "${(_context$filename = context.filename) != null ? _context$filename : "(unknown)"}" because it matches one of \`ignore: ${JSON.stringify(ignore)}\` from "${dirname}"`;
-    debug(message);
-
-    if (context.showConfig) {
-      console.log(message);
-    }
-
-    return true;
-  }
-
-  if (only && !matchesPatterns(context, only, dirname)) {
-    var _context$filename2;
-
-    const message = `No config is applied to "${(_context$filename2 = context.filename) != null ? _context$filename2 : "(unknown)"}" because it fails to match one of \`only: ${JSON.stringify(only)}\` from "${dirname}"`;
-    debug(message);
-
-    if (context.showConfig) {
-      console.log(message);
-    }
-
-    return true;
-  }
-
-  return false;
-}
-
-function matchesPatterns(context, patterns, dirname) {
-  return patterns.some(pattern => matchPattern(pattern, dirname, context.filename, context));
-}
-
-function matchPattern(pattern, dirname, pathToTest, context) {
-  if (typeof pattern === "function") {
-    return !!pattern(pathToTest, {
-      dirname,
-      envName: context.envName,
-      caller: context.caller
-    });
-  }
-
-  if (typeof pathToTest !== "string") {
-    throw new Error(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`);
-  }
-
-  if (typeof pattern === "string") {
-    pattern = (0, _patternToRegex.default)(pattern, dirname);
-  }
-
-  return pattern.test(pathToTest);
-}

node_modules/@babel/core/lib/config/config-descriptors.js

@@ -1,244 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createCachedDescriptors = createCachedDescriptors;
-exports.createUncachedDescriptors = createUncachedDescriptors;
-exports.createDescriptor = createDescriptor;
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _files = require("./files");
-
-var _item = require("./item");
-
-var _caching = require("./caching");
-
-var _resolveTargets = require("./resolve-targets");
-
-function isEqualDescriptor(a, b) {
-  return a.name === b.name && a.value === b.value && a.options === b.options && a.dirname === b.dirname && a.alias === b.alias && a.ownPass === b.ownPass && (a.file && a.file.request) === (b.file && b.file.request) && (a.file && a.file.resolved) === (b.file && b.file.resolved);
-}
-
-function* handlerOf(value) {
-  return value;
-}
-
-function optionsWithResolvedBrowserslistConfigFile(options, dirname) {
-  if (typeof options.browserslistConfigFile === "string") {
-    options.browserslistConfigFile = (0, _resolveTargets.resolveBrowserslistConfigFile)(options.browserslistConfigFile, dirname);
-  }
-
-  return options;
-}
-
-function createCachedDescriptors(dirname, options, alias) {
-  const {
-    plugins,
-    presets,
-    passPerPreset
-  } = options;
-  return {
-    options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
-    plugins: plugins ? () => createCachedPluginDescriptors(plugins, dirname)(alias) : () => handlerOf([]),
-    presets: presets ? () => createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset) : () => handlerOf([])
-  };
-}
-
-function createUncachedDescriptors(dirname, options, alias) {
-  let plugins;
-  let presets;
-  return {
-    options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
-
-    *plugins() {
-      if (!plugins) {
-        plugins = yield* createPluginDescriptors(options.plugins || [], dirname, alias);
-      }
-
-      return plugins;
-    },
-
-    *presets() {
-      if (!presets) {
-        presets = yield* createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset);
-      }
-
-      return presets;
-    }
-
-  };
-}
-
-const PRESET_DESCRIPTOR_CACHE = new WeakMap();
-const createCachedPresetDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
-  const dirname = cache.using(dir => dir);
-  return (0, _caching.makeStrongCacheSync)(alias => (0, _caching.makeStrongCache)(function* (passPerPreset) {
-    const descriptors = yield* createPresetDescriptors(items, dirname, alias, passPerPreset);
-    return descriptors.map(desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc));
-  }));
-});
-const PLUGIN_DESCRIPTOR_CACHE = new WeakMap();
-const createCachedPluginDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
-  const dirname = cache.using(dir => dir);
-  return (0, _caching.makeStrongCache)(function* (alias) {
-    const descriptors = yield* createPluginDescriptors(items, dirname, alias);
-    return descriptors.map(desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc));
-  });
-});
-const DEFAULT_OPTIONS = {};
-
-function loadCachedDescriptor(cache, desc) {
-  const {
-    value,
-    options = DEFAULT_OPTIONS
-  } = desc;
-  if (options === false) return desc;
-  let cacheByOptions = cache.get(value);
-
-  if (!cacheByOptions) {
-    cacheByOptions = new WeakMap();
-    cache.set(value, cacheByOptions);
-  }
-
-  let possibilities = cacheByOptions.get(options);
-
-  if (!possibilities) {
-    possibilities = [];
-    cacheByOptions.set(options, possibilities);
-  }
-
-  if (possibilities.indexOf(desc) === -1) {
-    const matches = possibilities.filter(possibility => isEqualDescriptor(possibility, desc));
-
-    if (matches.length > 0) {
-      return matches[0];
-    }
-
-    possibilities.push(desc);
-  }
-
-  return desc;
-}
-
-function* createPresetDescriptors(items, dirname, alias, passPerPreset) {
-  return yield* createDescriptors("preset", items, dirname, alias, passPerPreset);
-}
-
-function* createPluginDescriptors(items, dirname, alias) {
-  return yield* createDescriptors("plugin", items, dirname, alias);
-}
-
-function* createDescriptors(type, items, dirname, alias, ownPass) {
-  const descriptors = yield* _gensync().all(items.map((item, index) => createDescriptor(item, dirname, {
-    type,
-    alias: `${alias}$${index}`,
-    ownPass: !!ownPass
-  })));
-  assertNoDuplicates(descriptors);
-  return descriptors;
-}
-
-function* createDescriptor(pair, dirname, {
-  type,
-  alias,
-  ownPass
-}) {
-  const desc = (0, _item.getItemDescriptor)(pair);
-
-  if (desc) {
-    return desc;
-  }
-
-  let name;
-  let options;
-  let value = pair;
-
-  if (Array.isArray(value)) {
-    if (value.length === 3) {
-      [value, options, name] = value;
-    } else {
-      [value, options] = value;
-    }
-  }
-
-  let file = undefined;
-  let filepath = null;
-
-  if (typeof value === "string") {
-    if (typeof type !== "string") {
-      throw new Error("To resolve a string-based item, the type of item must be given");
-    }
-
-    const resolver = type === "plugin" ? _files.loadPlugin : _files.loadPreset;
-    const request = value;
-    ({
-      filepath,
-      value
-    } = yield* resolver(value, dirname));
-    file = {
-      request,
-      resolved: filepath
-    };
-  }
-
-  if (!value) {
-    throw new Error(`Unexpected falsy value: ${String(value)}`);
-  }
-
-  if (typeof value === "object" && value.__esModule) {
-    if (value.default) {
-      value = value.default;
-    } else {
-      throw new Error("Must export a default export when using ES6 modules.");
-    }
-  }
-
-  if (typeof value !== "object" && typeof value !== "function") {
-    throw new Error(`Unsupported format: ${typeof value}. Expected an object or a function.`);
-  }
-
-  if (filepath !== null && typeof value === "object" && value) {
-    throw new Error(`Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`);
-  }
-
-  return {
-    name,
-    alias: filepath || alias,
-    value,
-    options,
-    dirname,
-    ownPass,
-    file
-  };
-}
-
-function assertNoDuplicates(items) {
-  const map = new Map();
-
-  for (const item of items) {
-    if (typeof item.value !== "function") continue;
-    let nameMap = map.get(item.value);
-
-    if (!nameMap) {
-      nameMap = new Set();
-      map.set(item.value, nameMap);
-    }
-
-    if (nameMap.has(item.name)) {
-      const conflicts = items.filter(i => i.value === item.value);
-      throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they need separate names, e.g.`, ``, `  plugins: [`, `    ['some-plugin', {}],`, `    ['some-plugin', {}, 'some unique name'],`, `  ]`, ``, `Duplicates detected are:`, `${JSON.stringify(conflicts, null, 2)}`].join("\n"));
-    }
-
-    nameMap.add(item.name);
-  }
-}

node_modules/@babel/core/lib/config/files/configuration.js

@@ -1,357 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.findConfigUpwards = findConfigUpwards;
-exports.findRelativeConfig = findRelativeConfig;
-exports.findRootConfig = findRootConfig;
-exports.loadConfig = loadConfig;
-exports.resolveShowConfigPath = resolveShowConfigPath;
-exports.ROOT_CONFIG_FILENAMES = void 0;
-
-function _debug() {
-  const data = require("debug");
-
-  _debug = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _fs() {
-  const data = require("fs");
-
-  _fs = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _path() {
-  const data = require("path");
-
-  _path = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _json() {
-  const data = require("json5");
-
-  _json = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _caching = require("../caching");
-
-var _configApi = require("../helpers/config-api");
-
-var _utils = require("./utils");
-
-var _moduleTypes = require("./module-types");
-
-var _patternToRegex = require("../pattern-to-regex");
-
-var fs = require("../../gensync-utils/fs");
-
-function _module() {
-  const data = require("module");
-
-  _module = function () {
-    return data;
-  };
-
-  return data;
-}
-
-const debug = _debug()("babel:config:loading:files:configuration");
-
-const ROOT_CONFIG_FILENAMES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json"];
-exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES;
-const RELATIVE_CONFIG_FILENAMES = [".babelrc", ".babelrc.js", ".babelrc.cjs", ".babelrc.mjs", ".babelrc.json"];
-const BABELIGNORE_FILENAME = ".babelignore";
-
-function findConfigUpwards(rootDir) {
-  let dirname = rootDir;
-
-  for (;;) {
-    for (const filename of ROOT_CONFIG_FILENAMES) {
-      if (_fs().existsSync(_path().join(dirname, filename))) {
-        return dirname;
-      }
-    }
-
-    const nextDir = _path().dirname(dirname);
-
-    if (dirname === nextDir) break;
-    dirname = nextDir;
-  }
-
-  return null;
-}
-
-function* findRelativeConfig(packageData, envName, caller) {
-  let config = null;
-  let ignore = null;
-
-  const dirname = _path().dirname(packageData.filepath);
-
-  for (const loc of packageData.directories) {
-    if (!config) {
-      var _packageData$pkg;
-
-      config = yield* loadOneConfig(RELATIVE_CONFIG_FILENAMES, loc, envName, caller, ((_packageData$pkg = packageData.pkg) == null ? void 0 : _packageData$pkg.dirname) === loc ? packageToBabelConfig(packageData.pkg) : null);
-    }
-
-    if (!ignore) {
-      const ignoreLoc = _path().join(loc, BABELIGNORE_FILENAME);
-
-      ignore = yield* readIgnoreConfig(ignoreLoc);
-
-      if (ignore) {
-        debug("Found ignore %o from %o.", ignore.filepath, dirname);
-      }
-    }
-  }
-
-  return {
-    config,
-    ignore
-  };
-}
-
-function findRootConfig(dirname, envName, caller) {
-  return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);
-}
-
-function* loadOneConfig(names, dirname, envName, caller, previousConfig = null) {
-  const configs = yield* _gensync().all(names.map(filename => readConfig(_path().join(dirname, filename), envName, caller)));
-  const config = configs.reduce((previousConfig, config) => {
-    if (config && previousConfig) {
-      throw new Error(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().basename(previousConfig.filepath)}\n` + ` - ${config.filepath}\n` + `from ${dirname}`);
-    }
-
-    return config || previousConfig;
-  }, previousConfig);
-
-  if (config) {
-    debug("Found configuration %o from %o.", config.filepath, dirname);
-  }
-
-  return config;
-}
-
-function* loadConfig(name, dirname, envName, caller) {
-  const filepath = (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
-    paths: [b]
-  }, M = require("module")) => {
-    let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
-
-    if (f) return f;
-    f = new Error(`Cannot resolve module '${r}'`);
-    f.code = "MODULE_NOT_FOUND";
-    throw f;
-  })(name, {
-    paths: [dirname]
-  });
-  const conf = yield* readConfig(filepath, envName, caller);
-
-  if (!conf) {
-    throw new Error(`Config file ${filepath} contains no configuration data`);
-  }
-
-  debug("Loaded config %o from %o.", name, dirname);
-  return conf;
-}
-
-function readConfig(filepath, envName, caller) {
-  const ext = _path().extname(filepath);
-
-  return ext === ".js" || ext === ".cjs" || ext === ".mjs" ? readConfigJS(filepath, {
-    envName,
-    caller
-  }) : readConfigJSON5(filepath);
-}
-
-const LOADING_CONFIGS = new Set();
-const readConfigJS = (0, _caching.makeStrongCache)(function* readConfigJS(filepath, cache) {
-  if (!_fs().existsSync(filepath)) {
-    cache.never();
-    return null;
-  }
-
-  if (LOADING_CONFIGS.has(filepath)) {
-    cache.never();
-    debug("Auto-ignoring usage of config %o.", filepath);
-    return {
-      filepath,
-      dirname: _path().dirname(filepath),
-      options: {}
-    };
-  }
-
-  let options;
-
-  try {
-    LOADING_CONFIGS.add(filepath);
-    options = yield* (0, _moduleTypes.default)(filepath, "You appear to be using a native ECMAScript module configuration " + "file, which is only supported when running Babel asynchronously.");
-  } catch (err) {
-    err.message = `${filepath}: Error while loading config - ${err.message}`;
-    throw err;
-  } finally {
-    LOADING_CONFIGS.delete(filepath);
-  }
-
-  let assertCache = false;
-
-  if (typeof options === "function") {
-    yield* [];
-    options = options((0, _configApi.makeConfigAPI)(cache));
-    assertCache = true;
-  }
-
-  if (!options || typeof options !== "object" || Array.isArray(options)) {
-    throw new Error(`${filepath}: Configuration should be an exported JavaScript object.`);
-  }
-
-  if (typeof options.then === "function") {
-    throw new Error(`You appear to be using an async configuration, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously return your config.`);
-  }
-
-  if (assertCache && !cache.configured()) throwConfigError();
-  return {
-    filepath,
-    dirname: _path().dirname(filepath),
-    options
-  };
-});
-const packageToBabelConfig = (0, _caching.makeWeakCacheSync)(file => {
-  const babel = file.options["babel"];
-  if (typeof babel === "undefined") return null;
-
-  if (typeof babel !== "object" || Array.isArray(babel) || babel === null) {
-    throw new Error(`${file.filepath}: .babel property must be an object`);
-  }
-
-  return {
-    filepath: file.filepath,
-    dirname: file.dirname,
-    options: babel
-  };
-});
-const readConfigJSON5 = (0, _utils.makeStaticFileCache)((filepath, content) => {
-  let options;
-
-  try {
-    options = _json().parse(content);
-  } catch (err) {
-    err.message = `${filepath}: Error while parsing config - ${err.message}`;
-    throw err;
-  }
-
-  if (!options) throw new Error(`${filepath}: No config detected`);
-
-  if (typeof options !== "object") {
-    throw new Error(`${filepath}: Config returned typeof ${typeof options}`);
-  }
-
-  if (Array.isArray(options)) {
-    throw new Error(`${filepath}: Expected config object but found array`);
-  }
-
-  return {
-    filepath,
-    dirname: _path().dirname(filepath),
-    options
-  };
-});
-const readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content) => {
-  const ignoreDir = _path().dirname(filepath);
-
-  const ignorePatterns = content.split("\n").map(line => line.replace(/#(.*?)$/, "").trim()).filter(line => !!line);
-
-  for (const pattern of ignorePatterns) {
-    if (pattern[0] === "!") {
-      throw new Error(`Negation of file paths is not supported.`);
-    }
-  }
-
-  return {
-    filepath,
-    dirname: _path().dirname(filepath),
-    ignore: ignorePatterns.map(pattern => (0, _patternToRegex.default)(pattern, ignoreDir))
-  };
-});
-
-function* resolveShowConfigPath(dirname) {
-  const targetPath = process.env.BABEL_SHOW_CONFIG_FOR;
-
-  if (targetPath != null) {
-    const absolutePath = _path().resolve(dirname, targetPath);
-
-    const stats = yield* fs.stat(absolutePath);
-
-    if (!stats.isFile()) {
-      throw new Error(`${absolutePath}: BABEL_SHOW_CONFIG_FOR must refer to a regular file, directories are not supported.`);
-    }
-
-    return absolutePath;
-  }
-
-  return null;
-}
-
-function throwConfigError() {
-  throw new Error(`\
-Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured
-for various types of caching, using the first param of their handler functions:
-
-module.exports = function(api) {
-  // The API exposes the following:
-
-  // Cache the returned value forever and don't call this function again.
-  api.cache(true);
-
-  // Don't cache at all. Not recommended because it will be very slow.
-  api.cache(false);
-
-  // Cached based on the value of some function. If this function returns a value different from
-  // a previously-encountered value, the plugins will re-evaluate.
-  var env = api.cache(() => process.env.NODE_ENV);
-
-  // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for
-  // any possible NODE_ENV value that might come up during plugin execution.
-  var isProd = api.cache(() => process.env.NODE_ENV === "production");
-
-  // .cache(fn) will perform a linear search though instances to find the matching plugin based
-  // based on previous instantiated plugins. If you want to recreate the plugin and discard the
-  // previous instance whenever something changes, you may use:
-  var isProd = api.cache.invalidate(() => process.env.NODE_ENV === "production");
-
-  // Note, we also expose the following more-verbose versions of the above examples:
-  api.cache.forever(); // api.cache(true)
-  api.cache.never();   // api.cache(false)
-  api.cache.using(fn); // api.cache(fn)
-
-  // Return the value that will be cached.
-  return { };
-};`);
-}

node_modules/@babel/core/lib/config/files/import.js

@@ -1,10 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = import_;
-
-function import_(filepath) {
-  return import(filepath);
-}

node_modules/@babel/core/lib/config/files/index-browser.js

@@ -1,67 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.findConfigUpwards = findConfigUpwards;
-exports.findPackageData = findPackageData;
-exports.findRelativeConfig = findRelativeConfig;
-exports.findRootConfig = findRootConfig;
-exports.loadConfig = loadConfig;
-exports.resolveShowConfigPath = resolveShowConfigPath;
-exports.resolvePlugin = resolvePlugin;
-exports.resolvePreset = resolvePreset;
-exports.loadPlugin = loadPlugin;
-exports.loadPreset = loadPreset;
-exports.ROOT_CONFIG_FILENAMES = void 0;
-
-function findConfigUpwards(rootDir) {
-  return null;
-}
-
-function* findPackageData(filepath) {
-  return {
-    filepath,
-    directories: [],
-    pkg: null,
-    isPackage: false
-  };
-}
-
-function* findRelativeConfig(pkgData, envName, caller) {
-  return {
-    config: null,
-    ignore: null
-  };
-}
-
-function* findRootConfig(dirname, envName, caller) {
-  return null;
-}
-
-function* loadConfig(name, dirname, envName, caller) {
-  throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);
-}
-
-function* resolveShowConfigPath(dirname) {
-  return null;
-}
-
-const ROOT_CONFIG_FILENAMES = [];
-exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES;
-
-function resolvePlugin(name, dirname) {
-  return null;
-}
-
-function resolvePreset(name, dirname) {
-  return null;
-}
-
-function loadPlugin(name, dirname) {
-  throw new Error(`Cannot load plugin ${name} relative to ${dirname} in a browser`);
-}
-
-function loadPreset(name, dirname) {
-  throw new Error(`Cannot load preset ${name} relative to ${dirname} in a browser`);
-}

node_modules/@babel/core/lib/config/files/index.js

@@ -1,79 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "findPackageData", {
-  enumerable: true,
-  get: function () {
-    return _package.findPackageData;
-  }
-});
-Object.defineProperty(exports, "findConfigUpwards", {
-  enumerable: true,
-  get: function () {
-    return _configuration.findConfigUpwards;
-  }
-});
-Object.defineProperty(exports, "findRelativeConfig", {
-  enumerable: true,
-  get: function () {
-    return _configuration.findRelativeConfig;
-  }
-});
-Object.defineProperty(exports, "findRootConfig", {
-  enumerable: true,
-  get: function () {
-    return _configuration.findRootConfig;
-  }
-});
-Object.defineProperty(exports, "loadConfig", {
-  enumerable: true,
-  get: function () {
-    return _configuration.loadConfig;
-  }
-});
-Object.defineProperty(exports, "resolveShowConfigPath", {
-  enumerable: true,
-  get: function () {
-    return _configuration.resolveShowConfigPath;
-  }
-});
-Object.defineProperty(exports, "ROOT_CONFIG_FILENAMES", {
-  enumerable: true,
-  get: function () {
-    return _configuration.ROOT_CONFIG_FILENAMES;
-  }
-});
-Object.defineProperty(exports, "resolvePlugin", {
-  enumerable: true,
-  get: function () {
-    return _plugins.resolvePlugin;
-  }
-});
-Object.defineProperty(exports, "resolvePreset", {
-  enumerable: true,
-  get: function () {
-    return _plugins.resolvePreset;
-  }
-});
-Object.defineProperty(exports, "loadPlugin", {
-  enumerable: true,
-  get: function () {
-    return _plugins.loadPlugin;
-  }
-});
-Object.defineProperty(exports, "loadPreset", {
-  enumerable: true,
-  get: function () {
-    return _plugins.loadPreset;
-  }
-});
-
-var _package = require("./package");
-
-var _configuration = require("./configuration");
-
-var _plugins = require("./plugins");
-
-({});

node_modules/@babel/core/lib/config/files/module-types.js

@@ -1,104 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = loadCjsOrMjsDefault;
-
-var _async = require("../../gensync-utils/async");
-
-function _path() {
-  const data = require("path");
-
-  _path = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _url() {
-  const data = require("url");
-
-  _url = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _module() {
-  const data = require("module");
-
-  _module = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-let import_;
-
-try {
-  import_ = require("./import").default;
-} catch (_unused) {}
-
-function* loadCjsOrMjsDefault(filepath, asyncError, fallbackToTranspiledModule = false) {
-  switch (guessJSModuleType(filepath)) {
-    case "cjs":
-      return loadCjsDefault(filepath, fallbackToTranspiledModule);
-
-    case "unknown":
-      try {
-        return loadCjsDefault(filepath, fallbackToTranspiledModule);
-      } catch (e) {
-        if (e.code !== "ERR_REQUIRE_ESM") throw e;
-      }
-
-    case "mjs":
-      if (yield* (0, _async.isAsync)()) {
-        return yield* (0, _async.waitFor)(loadMjsDefault(filepath));
-      }
-
-      throw new Error(asyncError);
-  }
-}
-
-function guessJSModuleType(filename) {
-  switch (_path().extname(filename)) {
-    case ".cjs":
-      return "cjs";
-
-    case ".mjs":
-      return "mjs";
-
-    default:
-      return "unknown";
-  }
-}
-
-function loadCjsDefault(filepath, fallbackToTranspiledModule) {
-  const module = require(filepath);
-
-  return module != null && module.__esModule ? module.default || (fallbackToTranspiledModule ? module : undefined) : module;
-}
-
-function loadMjsDefault(_x) {
-  return _loadMjsDefault.apply(this, arguments);
-}
-
-function _loadMjsDefault() {
-  _loadMjsDefault = _asyncToGenerator(function* (filepath) {
-    if (!import_) {
-      throw new Error("Internal error: Native ECMAScript modules aren't supported" + " by this platform.\n");
-    }
-
-    const module = yield import_((0, _url().pathToFileURL)(filepath));
-    return module.default;
-  });
-  return _loadMjsDefault.apply(this, arguments);
-}

node_modules/@babel/core/lib/config/files/package.js

@@ -1,76 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.findPackageData = findPackageData;
-
-function _path() {
-  const data = require("path");
-
-  _path = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _utils = require("./utils");
-
-const PACKAGE_FILENAME = "package.json";
-
-function* findPackageData(filepath) {
-  let pkg = null;
-  const directories = [];
-  let isPackage = true;
-
-  let dirname = _path().dirname(filepath);
-
-  while (!pkg && _path().basename(dirname) !== "node_modules") {
-    directories.push(dirname);
-    pkg = yield* readConfigPackage(_path().join(dirname, PACKAGE_FILENAME));
-
-    const nextLoc = _path().dirname(dirname);
-
-    if (dirname === nextLoc) {
-      isPackage = false;
-      break;
-    }
-
-    dirname = nextLoc;
-  }
-
-  return {
-    filepath,
-    directories,
-    pkg,
-    isPackage
-  };
-}
-
-const readConfigPackage = (0, _utils.makeStaticFileCache)((filepath, content) => {
-  let options;
-
-  try {
-    options = JSON.parse(content);
-  } catch (err) {
-    err.message = `${filepath}: Error while parsing JSON - ${err.message}`;
-    throw err;
-  }
-
-  if (!options) throw new Error(`${filepath}: No config detected`);
-
-  if (typeof options !== "object") {
-    throw new Error(`${filepath}: Config returned typeof ${typeof options}`);
-  }
-
-  if (Array.isArray(options)) {
-    throw new Error(`${filepath}: Expected config object but found array`);
-  }
-
-  return {
-    filepath,
-    dirname: _path().dirname(filepath),
-    options
-  };
-});

node_modules/@babel/core/lib/config/files/plugins.js

@@ -1,206 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.resolvePlugin = resolvePlugin;
-exports.resolvePreset = resolvePreset;
-exports.loadPlugin = loadPlugin;
-exports.loadPreset = loadPreset;
-
-function _debug() {
-  const data = require("debug");
-
-  _debug = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _path() {
-  const data = require("path");
-
-  _path = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _moduleTypes = require("./module-types");
-
-function _module() {
-  const data = require("module");
-
-  _module = function () {
-    return data;
-  };
-
-  return data;
-}
-
-const debug = _debug()("babel:config:loading:files:plugins");
-
-const EXACT_RE = /^module:/;
-const BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
-const BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
-const BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
-const BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
-const OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-plugin(?:-|\/|$)|[^/]+\/)/;
-const OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-preset(?:-|\/|$)|[^/]+\/)/;
-const OTHER_ORG_DEFAULT_RE = /^(@(?!babel$)[^/]+)$/;
-
-function resolvePlugin(name, dirname) {
-  return resolveStandardizedName("plugin", name, dirname);
-}
-
-function resolvePreset(name, dirname) {
-  return resolveStandardizedName("preset", name, dirname);
-}
-
-function* loadPlugin(name, dirname) {
-  const filepath = resolvePlugin(name, dirname);
-
-  if (!filepath) {
-    throw new Error(`Plugin ${name} not found relative to ${dirname}`);
-  }
-
-  const value = yield* requireModule("plugin", filepath);
-  debug("Loaded plugin %o from %o.", name, dirname);
-  return {
-    filepath,
-    value
-  };
-}
-
-function* loadPreset(name, dirname) {
-  const filepath = resolvePreset(name, dirname);
-
-  if (!filepath) {
-    throw new Error(`Preset ${name} not found relative to ${dirname}`);
-  }
-
-  const value = yield* requireModule("preset", filepath);
-  debug("Loaded preset %o from %o.", name, dirname);
-  return {
-    filepath,
-    value
-  };
-}
-
-function standardizeName(type, name) {
-  if (_path().isAbsolute(name)) return name;
-  const isPreset = type === "preset";
-  return name.replace(isPreset ? BABEL_PRESET_PREFIX_RE : BABEL_PLUGIN_PREFIX_RE, `babel-${type}-`).replace(isPreset ? BABEL_PRESET_ORG_RE : BABEL_PLUGIN_ORG_RE, `$1${type}-`).replace(isPreset ? OTHER_PRESET_ORG_RE : OTHER_PLUGIN_ORG_RE, `$1babel-${type}-`).replace(OTHER_ORG_DEFAULT_RE, `$1/babel-${type}`).replace(EXACT_RE, "");
-}
-
-function resolveStandardizedName(type, name, dirname = process.cwd()) {
-  const standardizedName = standardizeName(type, name);
-
-  try {
-    return (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
-      paths: [b]
-    }, M = require("module")) => {
-      let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
-
-      if (f) return f;
-      f = new Error(`Cannot resolve module '${r}'`);
-      f.code = "MODULE_NOT_FOUND";
-      throw f;
-    })(standardizedName, {
-      paths: [dirname]
-    });
-  } catch (e) {
-    if (e.code !== "MODULE_NOT_FOUND") throw e;
-
-    if (standardizedName !== name) {
-      let resolvedOriginal = false;
-
-      try {
-        (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
-          paths: [b]
-        }, M = require("module")) => {
-          let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
-
-          if (f) return f;
-          f = new Error(`Cannot resolve module '${r}'`);
-          f.code = "MODULE_NOT_FOUND";
-          throw f;
-        })(name, {
-          paths: [dirname]
-        });
-        resolvedOriginal = true;
-      } catch (_unused) {}
-
-      if (resolvedOriginal) {
-        e.message += `\n- If you want to resolve "${name}", use "module:${name}"`;
-      }
-    }
-
-    let resolvedBabel = false;
-
-    try {
-      (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
-        paths: [b]
-      }, M = require("module")) => {
-        let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
-
-        if (f) return f;
-        f = new Error(`Cannot resolve module '${r}'`);
-        f.code = "MODULE_NOT_FOUND";
-        throw f;
-      })(standardizeName(type, "@babel/" + name), {
-        paths: [dirname]
-      });
-      resolvedBabel = true;
-    } catch (_unused2) {}
-
-    if (resolvedBabel) {
-      e.message += `\n- Did you mean "@babel/${name}"?`;
-    }
-
-    let resolvedOppositeType = false;
-    const oppositeType = type === "preset" ? "plugin" : "preset";
-
-    try {
-      (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
-        paths: [b]
-      }, M = require("module")) => {
-        let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
-
-        if (f) return f;
-        f = new Error(`Cannot resolve module '${r}'`);
-        f.code = "MODULE_NOT_FOUND";
-        throw f;
-      })(standardizeName(oppositeType, name), {
-        paths: [dirname]
-      });
-      resolvedOppositeType = true;
-    } catch (_unused3) {}
-
-    if (resolvedOppositeType) {
-      e.message += `\n- Did you accidentally pass a ${oppositeType} as a ${type}?`;
-    }
-
-    throw e;
-  }
-}
-
-const LOADING_MODULES = new Set();
-
-function* requireModule(type, name) {
-  if (LOADING_MODULES.has(name)) {
-    throw new Error(`Reentrant ${type} detected trying to load "${name}". This module is not ignored ` + "and is trying to load itself while compiling itself, leading to a dependency cycle. " + 'We recommend adding it to your "ignore" list in your babelrc, or to a .babelignore.');
-  }
-
-  try {
-    LOADING_MODULES.add(name);
-    return yield* (0, _moduleTypes.default)(name, `You appear to be using a native ECMAScript module ${type}, ` + "which is only supported when running Babel asynchronously.", true);
-  } catch (err) {
-    err.message = `[BABEL]: ${err.message} (While processing: ${name})`;
-    throw err;
-  } finally {
-    LOADING_MODULES.delete(name);
-  }
-}

node_modules/@babel/core/lib/config/files/utils.js

@@ -1,44 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeStaticFileCache = makeStaticFileCache;
-
-var _caching = require("../caching");
-
-var fs = require("../../gensync-utils/fs");
-
-function _fs2() {
-  const data = require("fs");
-
-  _fs2 = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function makeStaticFileCache(fn) {
-  return (0, _caching.makeStrongCache)(function* (filepath, cache) {
-    const cached = cache.invalidate(() => fileMtime(filepath));
-
-    if (cached === null) {
-      return null;
-    }
-
-    return fn(filepath, yield* fs.readFile(filepath, "utf8"));
-  });
-}
-
-function fileMtime(filepath) {
-  if (!_fs2().existsSync(filepath)) return null;
-
-  try {
-    return +_fs2().statSync(filepath).mtime;
-  } catch (e) {
-    if (e.code !== "ENOENT" && e.code !== "ENOTDIR") throw e;
-  }
-
-  return null;
-}

node_modules/@babel/core/lib/config/full.js

@@ -1,338 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _async = require("../gensync-utils/async");
-
-var _util = require("./util");
-
-var context = require("../index");
-
-var _plugin = require("./plugin");
-
-var _item = require("./item");
-
-var _configChain = require("./config-chain");
-
-function _traverse() {
-  const data = require("@babel/traverse");
-
-  _traverse = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _caching = require("./caching");
-
-var _options = require("./validation/options");
-
-var _plugins = require("./validation/plugins");
-
-var _configApi = require("./helpers/config-api");
-
-var _partial = require("./partial");
-
-var Context = require("./cache-contexts");
-
-var _default = _gensync()(function* loadFullConfig(inputOpts) {
-  var _opts$assumptions;
-
-  const result = yield* (0, _partial.default)(inputOpts);
-
-  if (!result) {
-    return null;
-  }
-
-  const {
-    options,
-    context,
-    fileHandling
-  } = result;
-
-  if (fileHandling === "ignored") {
-    return null;
-  }
-
-  const optionDefaults = {};
-  const {
-    plugins,
-    presets
-  } = options;
-
-  if (!plugins || !presets) {
-    throw new Error("Assertion failure - plugins and presets exist");
-  }
-
-  const presetContext = Object.assign({}, context, {
-    targets: options.targets
-  });
-
-  const toDescriptor = item => {
-    const desc = (0, _item.getItemDescriptor)(item);
-
-    if (!desc) {
-      throw new Error("Assertion failure - must be config item");
-    }
-
-    return desc;
-  };
-
-  const presetsDescriptors = presets.map(toDescriptor);
-  const initialPluginsDescriptors = plugins.map(toDescriptor);
-  const pluginDescriptorsByPass = [[]];
-  const passes = [];
-  const ignored = yield* enhanceError(context, function* recursePresetDescriptors(rawPresets, pluginDescriptorsPass) {
-    const presets = [];
-
-    for (let i = 0; i < rawPresets.length; i++) {
-      const descriptor = rawPresets[i];
-
-      if (descriptor.options !== false) {
-        try {
-          if (descriptor.ownPass) {
-            presets.push({
-              preset: yield* loadPresetDescriptor(descriptor, presetContext),
-              pass: []
-            });
-          } else {
-            presets.unshift({
-              preset: yield* loadPresetDescriptor(descriptor, presetContext),
-              pass: pluginDescriptorsPass
-            });
-          }
-        } catch (e) {
-          if (e.code === "BABEL_UNKNOWN_OPTION") {
-            (0, _options.checkNoUnwrappedItemOptionPairs)(rawPresets, i, "preset", e);
-          }
-
-          throw e;
-        }
-      }
-    }
-
-    if (presets.length > 0) {
-      pluginDescriptorsByPass.splice(1, 0, ...presets.map(o => o.pass).filter(p => p !== pluginDescriptorsPass));
-
-      for (const {
-        preset,
-        pass
-      } of presets) {
-        if (!preset) return true;
-        pass.push(...preset.plugins);
-        const ignored = yield* recursePresetDescriptors(preset.presets, pass);
-        if (ignored) return true;
-        preset.options.forEach(opts => {
-          (0, _util.mergeOptions)(optionDefaults, opts);
-        });
-      }
-    }
-  })(presetsDescriptors, pluginDescriptorsByPass[0]);
-  if (ignored) return null;
-  const opts = optionDefaults;
-  (0, _util.mergeOptions)(opts, options);
-  const pluginContext = Object.assign({}, presetContext, {
-    assumptions: (_opts$assumptions = opts.assumptions) != null ? _opts$assumptions : {}
-  });
-  yield* enhanceError(context, function* loadPluginDescriptors() {
-    pluginDescriptorsByPass[0].unshift(...initialPluginsDescriptors);
-
-    for (const descs of pluginDescriptorsByPass) {
-      const pass = [];
-      passes.push(pass);
-
-      for (let i = 0; i < descs.length; i++) {
-        const descriptor = descs[i];
-
-        if (descriptor.options !== false) {
-          try {
-            pass.push(yield* loadPluginDescriptor(descriptor, pluginContext));
-          } catch (e) {
-            if (e.code === "BABEL_UNKNOWN_PLUGIN_PROPERTY") {
-              (0, _options.checkNoUnwrappedItemOptionPairs)(descs, i, "plugin", e);
-            }
-
-            throw e;
-          }
-        }
-      }
-    }
-  })();
-  opts.plugins = passes[0];
-  opts.presets = passes.slice(1).filter(plugins => plugins.length > 0).map(plugins => ({
-    plugins
-  }));
-  opts.passPerPreset = opts.presets.length > 0;
-  return {
-    options: opts,
-    passes: passes
-  };
-});
-
-exports.default = _default;
-
-function enhanceError(context, fn) {
-  return function* (arg1, arg2) {
-    try {
-      return yield* fn(arg1, arg2);
-    } catch (e) {
-      if (!/^\[BABEL\]/.test(e.message)) {
-        e.message = `[BABEL] ${context.filename || "unknown"}: ${e.message}`;
-      }
-
-      throw e;
-    }
-  };
-}
-
-const makeDescriptorLoader = apiFactory => (0, _caching.makeWeakCache)(function* ({
-  value,
-  options,
-  dirname,
-  alias
-}, cache) {
-  if (options === false) throw new Error("Assertion failure");
-  options = options || {};
-  let item = value;
-
-  if (typeof value === "function") {
-    const factory = (0, _async.maybeAsync)(value, `You appear to be using an async plugin/preset, but Babel has been called synchronously`);
-    const api = Object.assign({}, context, apiFactory(cache));
-
-    try {
-      item = yield* factory(api, options, dirname);
-    } catch (e) {
-      if (alias) {
-        e.message += ` (While processing: ${JSON.stringify(alias)})`;
-      }
-
-      throw e;
-    }
-  }
-
-  if (!item || typeof item !== "object") {
-    throw new Error("Plugin/Preset did not return an object.");
-  }
-
-  if ((0, _async.isThenable)(item)) {
-    yield* [];
-    throw new Error(`You appear to be using a promise as a plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version. ` + `As an alternative, you can prefix the promise with "await". ` + `(While processing: ${JSON.stringify(alias)})`);
-  }
-
-  return {
-    value: item,
-    options,
-    dirname,
-    alias
-  };
-});
-
-const pluginDescriptorLoader = makeDescriptorLoader(_configApi.makePluginAPI);
-const presetDescriptorLoader = makeDescriptorLoader(_configApi.makePresetAPI);
-
-function* loadPluginDescriptor(descriptor, context) {
-  if (descriptor.value instanceof _plugin.default) {
-    if (descriptor.options) {
-      throw new Error("Passed options to an existing Plugin instance will not work.");
-    }
-
-    return descriptor.value;
-  }
-
-  return yield* instantiatePlugin(yield* pluginDescriptorLoader(descriptor, context), context);
-}
-
-const instantiatePlugin = (0, _caching.makeWeakCache)(function* ({
-  value,
-  options,
-  dirname,
-  alias
-}, cache) {
-  const pluginObj = (0, _plugins.validatePluginObject)(value);
-  const plugin = Object.assign({}, pluginObj);
-
-  if (plugin.visitor) {
-    plugin.visitor = _traverse().default.explode(Object.assign({}, plugin.visitor));
-  }
-
-  if (plugin.inherits) {
-    const inheritsDescriptor = {
-      name: undefined,
-      alias: `${alias}$inherits`,
-      value: plugin.inherits,
-      options,
-      dirname
-    };
-    const inherits = yield* (0, _async.forwardAsync)(loadPluginDescriptor, run => {
-      return cache.invalidate(data => run(inheritsDescriptor, data));
-    });
-    plugin.pre = chain(inherits.pre, plugin.pre);
-    plugin.post = chain(inherits.post, plugin.post);
-    plugin.manipulateOptions = chain(inherits.manipulateOptions, plugin.manipulateOptions);
-    plugin.visitor = _traverse().default.visitors.merge([inherits.visitor || {}, plugin.visitor || {}]);
-  }
-
-  return new _plugin.default(plugin, options, alias);
-});
-
-const validateIfOptionNeedsFilename = (options, descriptor) => {
-  if (options.test || options.include || options.exclude) {
-    const formattedPresetName = descriptor.name ? `"${descriptor.name}"` : "/* your preset */";
-    throw new Error([`Preset ${formattedPresetName} requires a filename to be set when babel is called directly,`, `\`\`\``, `babel.transform(code, { filename: 'file.ts', presets: [${formattedPresetName}] });`, `\`\`\``, `See https://babeljs.io/docs/en/options#filename for more information.`].join("\n"));
-  }
-};
-
-const validatePreset = (preset, context, descriptor) => {
-  if (!context.filename) {
-    const {
-      options
-    } = preset;
-    validateIfOptionNeedsFilename(options, descriptor);
-
-    if (options.overrides) {
-      options.overrides.forEach(overrideOptions => validateIfOptionNeedsFilename(overrideOptions, descriptor));
-    }
-  }
-};
-
-function* loadPresetDescriptor(descriptor, context) {
-  const preset = instantiatePreset(yield* presetDescriptorLoader(descriptor, context));
-  validatePreset(preset, context, descriptor);
-  return yield* (0, _configChain.buildPresetChain)(preset, context);
-}
-
-const instantiatePreset = (0, _caching.makeWeakCacheSync)(({
-  value,
-  dirname,
-  alias
-}) => {
-  return {
-    options: (0, _options.validate)("preset", value),
-    alias,
-    dirname
-  };
-});
-
-function chain(a, b) {
-  const fns = [a, b].filter(Boolean);
-  if (fns.length <= 1) return fns[0];
-  return function (...args) {
-    for (const fn of fns) {
-      fn.apply(this, args);
-    }
-  };
-}

node_modules/@babel/core/lib/config/helpers/config-api.js

@@ -1,103 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeConfigAPI = makeConfigAPI;
-exports.makePresetAPI = makePresetAPI;
-exports.makePluginAPI = makePluginAPI;
-
-function _semver() {
-  const data = require("semver");
-
-  _semver = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _ = require("../../");
-
-var _caching = require("../caching");
-
-var Context = require("../cache-contexts");
-
-function makeConfigAPI(cache) {
-  const env = value => cache.using(data => {
-    if (typeof value === "undefined") return data.envName;
-
-    if (typeof value === "function") {
-      return (0, _caching.assertSimpleType)(value(data.envName));
-    }
-
-    if (!Array.isArray(value)) value = [value];
-    return value.some(entry => {
-      if (typeof entry !== "string") {
-        throw new Error("Unexpected non-string value");
-      }
-
-      return entry === data.envName;
-    });
-  });
-
-  const caller = cb => cache.using(data => (0, _caching.assertSimpleType)(cb(data.caller)));
-
-  return {
-    version: _.version,
-    cache: cache.simple(),
-    env,
-    async: () => false,
-    caller,
-    assertVersion
-  };
-}
-
-function makePresetAPI(cache) {
-  const targets = () => JSON.parse(cache.using(data => JSON.stringify(data.targets)));
-
-  return Object.assign({}, makeConfigAPI(cache), {
-    targets
-  });
-}
-
-function makePluginAPI(cache) {
-  const assumption = name => cache.using(data => data.assumptions[name]);
-
-  return Object.assign({}, makePresetAPI(cache), {
-    assumption
-  });
-}
-
-function assertVersion(range) {
-  if (typeof range === "number") {
-    if (!Number.isInteger(range)) {
-      throw new Error("Expected string or integer value.");
-    }
-
-    range = `^${range}.0.0-0`;
-  }
-
-  if (typeof range !== "string") {
-    throw new Error("Expected string or integer value.");
-  }
-
-  if (_semver().satisfies(_.version, range)) return;
-  const limit = Error.stackTraceLimit;
-
-  if (typeof limit === "number" && limit < 25) {
-    Error.stackTraceLimit = 25;
-  }
-
-  const err = new Error(`Requires Babel "${range}", but was loaded with "${_.version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`);
-
-  if (typeof limit === "number") {
-    Error.stackTraceLimit = limit;
-  }
-
-  throw Object.assign(err, {
-    code: "BABEL_VERSION_UNSUPPORTED",
-    version: _.version,
-    range
-  });
-}

node_modules/@babel/core/lib/config/helpers/environment.js

@@ -1,10 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getEnv = getEnv;
-
-function getEnv(defaultValue = "development") {
-  return process.env.BABEL_ENV || process.env.NODE_ENV || defaultValue;
-}

node_modules/@babel/core/lib/config/index.js

@@ -1,74 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createConfigItem = createConfigItem;
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function () {
-    return _full.default;
-  }
-});
-exports.createConfigItemAsync = exports.createConfigItemSync = exports.loadOptionsAsync = exports.loadOptionsSync = exports.loadOptions = exports.loadPartialConfigAsync = exports.loadPartialConfigSync = exports.loadPartialConfig = void 0;
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _full = require("./full");
-
-var _partial = require("./partial");
-
-var _item = require("./item");
-
-const loadOptionsRunner = _gensync()(function* (opts) {
-  var _config$options;
-
-  const config = yield* (0, _full.default)(opts);
-  return (_config$options = config == null ? void 0 : config.options) != null ? _config$options : null;
-});
-
-const createConfigItemRunner = _gensync()(_item.createConfigItem);
-
-const maybeErrback = runner => (opts, callback) => {
-  if (callback === undefined && typeof opts === "function") {
-    callback = opts;
-    opts = undefined;
-  }
-
-  return callback ? runner.errback(opts, callback) : runner.sync(opts);
-};
-
-const loadPartialConfig = maybeErrback(_partial.loadPartialConfig);
-exports.loadPartialConfig = loadPartialConfig;
-const loadPartialConfigSync = _partial.loadPartialConfig.sync;
-exports.loadPartialConfigSync = loadPartialConfigSync;
-const loadPartialConfigAsync = _partial.loadPartialConfig.async;
-exports.loadPartialConfigAsync = loadPartialConfigAsync;
-const loadOptions = maybeErrback(loadOptionsRunner);
-exports.loadOptions = loadOptions;
-const loadOptionsSync = loadOptionsRunner.sync;
-exports.loadOptionsSync = loadOptionsSync;
-const loadOptionsAsync = loadOptionsRunner.async;
-exports.loadOptionsAsync = loadOptionsAsync;
-const createConfigItemSync = createConfigItemRunner.sync;
-exports.createConfigItemSync = createConfigItemSync;
-const createConfigItemAsync = createConfigItemRunner.async;
-exports.createConfigItemAsync = createConfigItemAsync;
-
-function createConfigItem(target, options, callback) {
-  if (callback !== undefined) {
-    return createConfigItemRunner.errback(target, options, callback);
-  } else if (typeof options === "function") {
-    return createConfigItemRunner.errback(target, undefined, callback);
-  } else {
-    return createConfigItemRunner.sync(target, options);
-  }
-}

node_modules/@babel/core/lib/config/item.js

@@ -1,76 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createItemFromDescriptor = createItemFromDescriptor;
-exports.createConfigItem = createConfigItem;
-exports.getItemDescriptor = getItemDescriptor;
-
-function _path() {
-  const data = require("path");
-
-  _path = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _configDescriptors = require("./config-descriptors");
-
-function createItemFromDescriptor(desc) {
-  return new ConfigItem(desc);
-}
-
-function* createConfigItem(value, {
-  dirname = ".",
-  type
-} = {}) {
-  const descriptor = yield* (0, _configDescriptors.createDescriptor)(value, _path().resolve(dirname), {
-    type,
-    alias: "programmatic item"
-  });
-  return createItemFromDescriptor(descriptor);
-}
-
-function getItemDescriptor(item) {
-  if (item != null && item[CONFIG_ITEM_BRAND]) {
-    return item._descriptor;
-  }
-
-  return undefined;
-}
-
-const CONFIG_ITEM_BRAND = Symbol.for("@babel/core@7 - ConfigItem");
-
-class ConfigItem {
-  constructor(descriptor) {
-    this._descriptor = void 0;
-    this[CONFIG_ITEM_BRAND] = true;
-    this.value = void 0;
-    this.options = void 0;
-    this.dirname = void 0;
-    this.name = void 0;
-    this.file = void 0;
-    this._descriptor = descriptor;
-    Object.defineProperty(this, "_descriptor", {
-      enumerable: false
-    });
-    Object.defineProperty(this, CONFIG_ITEM_BRAND, {
-      enumerable: false
-    });
-    this.value = this._descriptor.value;
-    this.options = this._descriptor.options;
-    this.dirname = this._descriptor.dirname;
-    this.name = this._descriptor.name;
-    this.file = this._descriptor.file ? {
-      request: this._descriptor.file.request,
-      resolved: this._descriptor.file.resolved
-    } : undefined;
-    Object.freeze(this);
-  }
-
-}
-
-Object.freeze(ConfigItem.prototype);

node_modules/@babel/core/lib/config/partial.js

@@ -1,195 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = loadPrivatePartialConfig;
-exports.loadPartialConfig = void 0;
-
-function _path() {
-  const data = require("path");
-
-  _path = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _plugin = require("./plugin");
-
-var _util = require("./util");
-
-var _item = require("./item");
-
-var _configChain = require("./config-chain");
-
-var _environment = require("./helpers/environment");
-
-var _options = require("./validation/options");
-
-var _files = require("./files");
-
-var _resolveTargets = require("./resolve-targets");
-
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-
-function resolveRootMode(rootDir, rootMode) {
-  switch (rootMode) {
-    case "root":
-      return rootDir;
-
-    case "upward-optional":
-      {
-        const upwardRootDir = (0, _files.findConfigUpwards)(rootDir);
-        return upwardRootDir === null ? rootDir : upwardRootDir;
-      }
-
-    case "upward":
-      {
-        const upwardRootDir = (0, _files.findConfigUpwards)(rootDir);
-        if (upwardRootDir !== null) return upwardRootDir;
-        throw Object.assign(new Error(`Babel was run with rootMode:"upward" but a root could not ` + `be found when searching upward from "${rootDir}".\n` + `One of the following config files must be in the directory tree: ` + `"${_files.ROOT_CONFIG_FILENAMES.join(", ")}".`), {
-          code: "BABEL_ROOT_NOT_FOUND",
-          dirname: rootDir
-        });
-      }
-
-    default:
-      throw new Error(`Assertion failure - unknown rootMode value.`);
-  }
-}
-
-function* loadPrivatePartialConfig(inputOpts) {
-  if (inputOpts != null && (typeof inputOpts !== "object" || Array.isArray(inputOpts))) {
-    throw new Error("Babel options must be an object, null, or undefined");
-  }
-
-  const args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {};
-  const {
-    envName = (0, _environment.getEnv)(),
-    cwd = ".",
-    root: rootDir = ".",
-    rootMode = "root",
-    caller,
-    cloneInputAst = true
-  } = args;
-
-  const absoluteCwd = _path().resolve(cwd);
-
-  const absoluteRootDir = resolveRootMode(_path().resolve(absoluteCwd, rootDir), rootMode);
-  const filename = typeof args.filename === "string" ? _path().resolve(cwd, args.filename) : undefined;
-  const showConfigPath = yield* (0, _files.resolveShowConfigPath)(absoluteCwd);
-  const context = {
-    filename,
-    cwd: absoluteCwd,
-    root: absoluteRootDir,
-    envName,
-    caller,
-    showConfig: showConfigPath === filename
-  };
-  const configChain = yield* (0, _configChain.buildRootChain)(args, context);
-  if (!configChain) return null;
-  const merged = {
-    assumptions: {}
-  };
-  configChain.options.forEach(opts => {
-    (0, _util.mergeOptions)(merged, opts);
-  });
-  const options = Object.assign({}, merged, {
-    targets: (0, _resolveTargets.resolveTargets)(merged, absoluteRootDir),
-    cloneInputAst,
-    babelrc: false,
-    configFile: false,
-    browserslistConfigFile: false,
-    passPerPreset: false,
-    envName: context.envName,
-    cwd: context.cwd,
-    root: context.root,
-    rootMode: "root",
-    filename: typeof context.filename === "string" ? context.filename : undefined,
-    plugins: configChain.plugins.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor)),
-    presets: configChain.presets.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor))
-  });
-  return {
-    options,
-    context,
-    fileHandling: configChain.fileHandling,
-    ignore: configChain.ignore,
-    babelrc: configChain.babelrc,
-    config: configChain.config,
-    files: configChain.files
-  };
-}
-
-const loadPartialConfig = _gensync()(function* (opts) {
-  let showIgnoredFiles = false;
-
-  if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {
-    var _opts = opts;
-    ({
-      showIgnoredFiles
-    } = _opts);
-    opts = _objectWithoutPropertiesLoose(_opts, ["showIgnoredFiles"]);
-    _opts;
-  }
-
-  const result = yield* loadPrivatePartialConfig(opts);
-  if (!result) return null;
-  const {
-    options,
-    babelrc,
-    ignore,
-    config,
-    fileHandling,
-    files
-  } = result;
-
-  if (fileHandling === "ignored" && !showIgnoredFiles) {
-    return null;
-  }
-
-  (options.plugins || []).forEach(item => {
-    if (item.value instanceof _plugin.default) {
-      throw new Error("Passing cached plugin instances is not supported in " + "babel.loadPartialConfig()");
-    }
-  });
-  return new PartialConfig(options, babelrc ? babelrc.filepath : undefined, ignore ? ignore.filepath : undefined, config ? config.filepath : undefined, fileHandling, files);
-});
-
-exports.loadPartialConfig = loadPartialConfig;
-
-class PartialConfig {
-  constructor(options, babelrc, ignore, config, fileHandling, files) {
-    this.options = void 0;
-    this.babelrc = void 0;
-    this.babelignore = void 0;
-    this.config = void 0;
-    this.fileHandling = void 0;
-    this.files = void 0;
-    this.options = options;
-    this.babelignore = ignore;
-    this.babelrc = babelrc;
-    this.config = config;
-    this.fileHandling = fileHandling;
-    this.files = files;
-    Object.freeze(this);
-  }
-
-  hasFilesystemConfig() {
-    return this.babelrc !== undefined || this.config !== undefined;
-  }
-
-}
-
-Object.freeze(PartialConfig.prototype);

node_modules/@babel/core/lib/config/pattern-to-regex.js

@@ -1,44 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = pathToPattern;
-
-function _path() {
-  const data = require("path");
-
-  _path = function () {
-    return data;
-  };
-
-  return data;
-}
-
-const sep = `\\${_path().sep}`;
-const endSep = `(?:${sep}|$)`;
-const substitution = `[^${sep}]+`;
-const starPat = `(?:${substitution}${sep})`;
-const starPatLast = `(?:${substitution}${endSep})`;
-const starStarPat = `${starPat}*?`;
-const starStarPatLast = `${starPat}*?${starPatLast}?`;
-
-function escapeRegExp(string) {
-  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
-}
-
-function pathToPattern(pattern, dirname) {
-  const parts = _path().resolve(dirname, pattern).split(_path().sep);
-
-  return new RegExp(["^", ...parts.map((part, i) => {
-    const last = i === parts.length - 1;
-    if (part === "**") return last ? starStarPatLast : starStarPat;
-    if (part === "*") return last ? starPatLast : starPat;
-
-    if (part.indexOf("*.") === 0) {
-      return substitution + escapeRegExp(part.slice(1)) + (last ? endSep : sep);
-    }
-
-    return escapeRegExp(part) + (last ? endSep : sep);
-  })].join(""));
-}

node_modules/@babel/core/lib/config/plugin.js

@@ -1,30 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-class Plugin {
-  constructor(plugin, options, key) {
-    this.key = void 0;
-    this.manipulateOptions = void 0;
-    this.post = void 0;
-    this.pre = void 0;
-    this.visitor = void 0;
-    this.parserOverride = void 0;
-    this.generatorOverride = void 0;
-    this.options = void 0;
-    this.key = plugin.name || key;
-    this.manipulateOptions = plugin.manipulateOptions;
-    this.post = plugin.post;
-    this.pre = plugin.pre;
-    this.visitor = plugin.visitor || {};
-    this.parserOverride = plugin.parserOverride;
-    this.generatorOverride = plugin.generatorOverride;
-    this.options = options;
-  }
-
-}
-
-exports.default = Plugin;

node_modules/@babel/core/lib/config/printer.js

@@ -1,139 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ConfigPrinter = exports.ChainFormatter = void 0;
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-const ChainFormatter = {
-  Programmatic: 0,
-  Config: 1
-};
-exports.ChainFormatter = ChainFormatter;
-const Formatter = {
-  title(type, callerName, filepath) {
-    let title = "";
-
-    if (type === ChainFormatter.Programmatic) {
-      title = "programmatic options";
-
-      if (callerName) {
-        title += " from " + callerName;
-      }
-    } else {
-      title = "config " + filepath;
-    }
-
-    return title;
-  },
-
-  loc(index, envName) {
-    let loc = "";
-
-    if (index != null) {
-      loc += `.overrides[${index}]`;
-    }
-
-    if (envName != null) {
-      loc += `.env["${envName}"]`;
-    }
-
-    return loc;
-  },
-
-  *optionsAndDescriptors(opt) {
-    const content = Object.assign({}, opt.options);
-    delete content.overrides;
-    delete content.env;
-    const pluginDescriptors = [...(yield* opt.plugins())];
-
-    if (pluginDescriptors.length) {
-      content.plugins = pluginDescriptors.map(d => descriptorToConfig(d));
-    }
-
-    const presetDescriptors = [...(yield* opt.presets())];
-
-    if (presetDescriptors.length) {
-      content.presets = [...presetDescriptors].map(d => descriptorToConfig(d));
-    }
-
-    return JSON.stringify(content, undefined, 2);
-  }
-
-};
-
-function descriptorToConfig(d) {
-  var _d$file;
-
-  let name = (_d$file = d.file) == null ? void 0 : _d$file.request;
-
-  if (name == null) {
-    if (typeof d.value === "object") {
-      name = d.value;
-    } else if (typeof d.value === "function") {
-      name = `[Function: ${d.value.toString().substr(0, 50)} ... ]`;
-    }
-  }
-
-  if (name == null) {
-    name = "[Unknown]";
-  }
-
-  if (d.options === undefined) {
-    return name;
-  } else if (d.name == null) {
-    return [name, d.options];
-  } else {
-    return [name, d.options, d.name];
-  }
-}
-
-class ConfigPrinter {
-  constructor() {
-    this._stack = [];
-  }
-
-  configure(enabled, type, {
-    callerName,
-    filepath
-  }) {
-    if (!enabled) return () => {};
-    return (content, index, envName) => {
-      this._stack.push({
-        type,
-        callerName,
-        filepath,
-        content,
-        index,
-        envName
-      });
-    };
-  }
-
-  static *format(config) {
-    let title = Formatter.title(config.type, config.callerName, config.filepath);
-    const loc = Formatter.loc(config.index, config.envName);
-    if (loc) title += ` ${loc}`;
-    const content = yield* Formatter.optionsAndDescriptors(config.content);
-    return `${title}\n${content}`;
-  }
-
-  *output() {
-    if (this._stack.length === 0) return "";
-    const configs = yield* _gensync().all(this._stack.map(s => ConfigPrinter.format(s)));
-    return configs.join("\n\n");
-  }
-
-}
-
-exports.ConfigPrinter = ConfigPrinter;

node_modules/@babel/core/lib/config/resolve-targets-browser.js

@@ -1,42 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.resolveBrowserslistConfigFile = resolveBrowserslistConfigFile;
-exports.resolveTargets = resolveTargets;
-
-function _helperCompilationTargets() {
-  const data = require("@babel/helper-compilation-targets");
-
-  _helperCompilationTargets = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function resolveBrowserslistConfigFile(browserslistConfigFile, configFilePath) {
-  return undefined;
-}
-
-function resolveTargets(options, root) {
-  let targets = options.targets;
-
-  if (typeof targets === "string" || Array.isArray(targets)) {
-    targets = {
-      browsers: targets
-    };
-  }
-
-  if (targets && targets.esmodules) {
-    targets = Object.assign({}, targets, {
-      esmodules: "intersect"
-    });
-  }
-
-  return (0, _helperCompilationTargets().default)(targets, {
-    ignoreBrowserslistConfig: true,
-    browserslistEnv: options.browserslistEnv
-  });
-}

node_modules/@babel/core/lib/config/resolve-targets.js

@@ -1,68 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.resolveBrowserslistConfigFile = resolveBrowserslistConfigFile;
-exports.resolveTargets = resolveTargets;
-
-function _path() {
-  const data = require("path");
-
-  _path = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _helperCompilationTargets() {
-  const data = require("@babel/helper-compilation-targets");
-
-  _helperCompilationTargets = function () {
-    return data;
-  };
-
-  return data;
-}
-
-({});
-
-function resolveBrowserslistConfigFile(browserslistConfigFile, configFileDir) {
-  return _path().resolve(configFileDir, browserslistConfigFile);
-}
-
-function resolveTargets(options, root) {
-  let targets = options.targets;
-
-  if (typeof targets === "string" || Array.isArray(targets)) {
-    targets = {
-      browsers: targets
-    };
-  }
-
-  if (targets && targets.esmodules) {
-    targets = Object.assign({}, targets, {
-      esmodules: "intersect"
-    });
-  }
-
-  const {
-    browserslistConfigFile
-  } = options;
-  let configFile;
-  let ignoreBrowserslistConfig = false;
-
-  if (typeof browserslistConfigFile === "string") {
-    configFile = browserslistConfigFile;
-  } else {
-    ignoreBrowserslistConfig = browserslistConfigFile === false;
-  }
-
-  return (0, _helperCompilationTargets().default)(targets, {
-    ignoreBrowserslistConfig,
-    configFile,
-    configPath: root,
-    browserslistEnv: options.browserslistEnv
-  });
-}

node_modules/@babel/core/lib/config/util.js

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.mergeOptions = mergeOptions;
-exports.isIterableIterator = isIterableIterator;
-
-function mergeOptions(target, source) {
-  for (const k of Object.keys(source)) {
-    if ((k === "parserOpts" || k === "generatorOpts" || k === "assumptions") && source[k]) {
-      const parserOpts = source[k];
-      const targetObj = target[k] || (target[k] = {});
-      mergeDefaultFields(targetObj, parserOpts);
-    } else {
-      const val = source[k];
-      if (val !== undefined) target[k] = val;
-    }
-  }
-}
-
-function mergeDefaultFields(target, source) {
-  for (const k of Object.keys(source)) {
-    const val = source[k];
-    if (val !== undefined) target[k] = val;
-  }
-}
-
-function isIterableIterator(value) {
-  return !!value && typeof value.next === "function" && typeof value[Symbol.iterator] === "function";
-}

node_modules/@babel/core/lib/config/validation/option-assertions.js

@@ -1,352 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.msg = msg;
-exports.access = access;
-exports.assertRootMode = assertRootMode;
-exports.assertSourceMaps = assertSourceMaps;
-exports.assertCompact = assertCompact;
-exports.assertSourceType = assertSourceType;
-exports.assertCallerMetadata = assertCallerMetadata;
-exports.assertInputSourceMap = assertInputSourceMap;
-exports.assertString = assertString;
-exports.assertFunction = assertFunction;
-exports.assertBoolean = assertBoolean;
-exports.assertObject = assertObject;
-exports.assertArray = assertArray;
-exports.assertIgnoreList = assertIgnoreList;
-exports.assertConfigApplicableTest = assertConfigApplicableTest;
-exports.assertConfigFileSearch = assertConfigFileSearch;
-exports.assertBabelrcSearch = assertBabelrcSearch;
-exports.assertPluginList = assertPluginList;
-exports.assertTargets = assertTargets;
-exports.assertAssumptions = assertAssumptions;
-
-function _helperCompilationTargets() {
-  const data = require("@babel/helper-compilation-targets");
-
-  _helperCompilationTargets = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _options = require("./options");
-
-function msg(loc) {
-  switch (loc.type) {
-    case "root":
-      return ``;
-
-    case "env":
-      return `${msg(loc.parent)}.env["${loc.name}"]`;
-
-    case "overrides":
-      return `${msg(loc.parent)}.overrides[${loc.index}]`;
-
-    case "option":
-      return `${msg(loc.parent)}.${loc.name}`;
-
-    case "access":
-      return `${msg(loc.parent)}[${JSON.stringify(loc.name)}]`;
-
-    default:
-      throw new Error(`Assertion failure: Unknown type ${loc.type}`);
-  }
-}
-
-function access(loc, name) {
-  return {
-    type: "access",
-    name,
-    parent: loc
-  };
-}
-
-function assertRootMode(loc, value) {
-  if (value !== undefined && value !== "root" && value !== "upward" && value !== "upward-optional") {
-    throw new Error(`${msg(loc)} must be a "root", "upward", "upward-optional" or undefined`);
-  }
-
-  return value;
-}
-
-function assertSourceMaps(loc, value) {
-  if (value !== undefined && typeof value !== "boolean" && value !== "inline" && value !== "both") {
-    throw new Error(`${msg(loc)} must be a boolean, "inline", "both", or undefined`);
-  }
-
-  return value;
-}
-
-function assertCompact(loc, value) {
-  if (value !== undefined && typeof value !== "boolean" && value !== "auto") {
-    throw new Error(`${msg(loc)} must be a boolean, "auto", or undefined`);
-  }
-
-  return value;
-}
-
-function assertSourceType(loc, value) {
-  if (value !== undefined && value !== "module" && value !== "script" && value !== "unambiguous") {
-    throw new Error(`${msg(loc)} must be "module", "script", "unambiguous", or undefined`);
-  }
-
-  return value;
-}
-
-function assertCallerMetadata(loc, value) {
-  const obj = assertObject(loc, value);
-
-  if (obj) {
-    if (typeof obj.name !== "string") {
-      throw new Error(`${msg(loc)} set but does not contain "name" property string`);
-    }
-
-    for (const prop of Object.keys(obj)) {
-      const propLoc = access(loc, prop);
-      const value = obj[prop];
-
-      if (value != null && typeof value !== "boolean" && typeof value !== "string" && typeof value !== "number") {
-        throw new Error(`${msg(propLoc)} must be null, undefined, a boolean, a string, or a number.`);
-      }
-    }
-  }
-
-  return value;
-}
-
-function assertInputSourceMap(loc, value) {
-  if (value !== undefined && typeof value !== "boolean" && (typeof value !== "object" || !value)) {
-    throw new Error(`${msg(loc)} must be a boolean, object, or undefined`);
-  }
-
-  return value;
-}
-
-function assertString(loc, value) {
-  if (value !== undefined && typeof value !== "string") {
-    throw new Error(`${msg(loc)} must be a string, or undefined`);
-  }
-
-  return value;
-}
-
-function assertFunction(loc, value) {
-  if (value !== undefined && typeof value !== "function") {
-    throw new Error(`${msg(loc)} must be a function, or undefined`);
-  }
-
-  return value;
-}
-
-function assertBoolean(loc, value) {
-  if (value !== undefined && typeof value !== "boolean") {
-    throw new Error(`${msg(loc)} must be a boolean, or undefined`);
-  }
-
-  return value;
-}
-
-function assertObject(loc, value) {
-  if (value !== undefined && (typeof value !== "object" || Array.isArray(value) || !value)) {
-    throw new Error(`${msg(loc)} must be an object, or undefined`);
-  }
-
-  return value;
-}
-
-function assertArray(loc, value) {
-  if (value != null && !Array.isArray(value)) {
-    throw new Error(`${msg(loc)} must be an array, or undefined`);
-  }
-
-  return value;
-}
-
-function assertIgnoreList(loc, value) {
-  const arr = assertArray(loc, value);
-
-  if (arr) {
-    arr.forEach((item, i) => assertIgnoreItem(access(loc, i), item));
-  }
-
-  return arr;
-}
-
-function assertIgnoreItem(loc, value) {
-  if (typeof value !== "string" && typeof value !== "function" && !(value instanceof RegExp)) {
-    throw new Error(`${msg(loc)} must be an array of string/Function/RegExp values, or undefined`);
-  }
-
-  return value;
-}
-
-function assertConfigApplicableTest(loc, value) {
-  if (value === undefined) return value;
-
-  if (Array.isArray(value)) {
-    value.forEach((item, i) => {
-      if (!checkValidTest(item)) {
-        throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
-      }
-    });
-  } else if (!checkValidTest(value)) {
-    throw new Error(`${msg(loc)} must be a string/Function/RegExp, or an array of those`);
-  }
-
-  return value;
-}
-
-function checkValidTest(value) {
-  return typeof value === "string" || typeof value === "function" || value instanceof RegExp;
-}
-
-function assertConfigFileSearch(loc, value) {
-  if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") {
-    throw new Error(`${msg(loc)} must be a undefined, a boolean, a string, ` + `got ${JSON.stringify(value)}`);
-  }
-
-  return value;
-}
-
-function assertBabelrcSearch(loc, value) {
-  if (value === undefined || typeof value === "boolean") return value;
-
-  if (Array.isArray(value)) {
-    value.forEach((item, i) => {
-      if (!checkValidTest(item)) {
-        throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
-      }
-    });
-  } else if (!checkValidTest(value)) {
-    throw new Error(`${msg(loc)} must be a undefined, a boolean, a string/Function/RegExp ` + `or an array of those, got ${JSON.stringify(value)}`);
-  }
-
-  return value;
-}
-
-function assertPluginList(loc, value) {
-  const arr = assertArray(loc, value);
-
-  if (arr) {
-    arr.forEach((item, i) => assertPluginItem(access(loc, i), item));
-  }
-
-  return arr;
-}
-
-function assertPluginItem(loc, value) {
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      throw new Error(`${msg(loc)} must include an object`);
-    }
-
-    if (value.length > 3) {
-      throw new Error(`${msg(loc)} may only be a two-tuple or three-tuple`);
-    }
-
-    assertPluginTarget(access(loc, 0), value[0]);
-
-    if (value.length > 1) {
-      const opts = value[1];
-
-      if (opts !== undefined && opts !== false && (typeof opts !== "object" || Array.isArray(opts) || opts === null)) {
-        throw new Error(`${msg(access(loc, 1))} must be an object, false, or undefined`);
-      }
-    }
-
-    if (value.length === 3) {
-      const name = value[2];
-
-      if (name !== undefined && typeof name !== "string") {
-        throw new Error(`${msg(access(loc, 2))} must be a string, or undefined`);
-      }
-    }
-  } else {
-    assertPluginTarget(loc, value);
-  }
-
-  return value;
-}
-
-function assertPluginTarget(loc, value) {
-  if ((typeof value !== "object" || !value) && typeof value !== "string" && typeof value !== "function") {
-    throw new Error(`${msg(loc)} must be a string, object, function`);
-  }
-
-  return value;
-}
-
-function assertTargets(loc, value) {
-  if ((0, _helperCompilationTargets().isBrowsersQueryValid)(value)) return value;
-
-  if (typeof value !== "object" || !value || Array.isArray(value)) {
-    throw new Error(`${msg(loc)} must be a string, an array of strings or an object`);
-  }
-
-  const browsersLoc = access(loc, "browsers");
-  const esmodulesLoc = access(loc, "esmodules");
-  assertBrowsersList(browsersLoc, value.browsers);
-  assertBoolean(esmodulesLoc, value.esmodules);
-
-  for (const key of Object.keys(value)) {
-    const val = value[key];
-    const subLoc = access(loc, key);
-    if (key === "esmodules") assertBoolean(subLoc, val);else if (key === "browsers") assertBrowsersList(subLoc, val);else if (!Object.hasOwnProperty.call(_helperCompilationTargets().TargetNames, key)) {
-      const validTargets = Object.keys(_helperCompilationTargets().TargetNames).join(", ");
-      throw new Error(`${msg(subLoc)} is not a valid target. Supported targets are ${validTargets}`);
-    } else assertBrowserVersion(subLoc, val);
-  }
-
-  return value;
-}
-
-function assertBrowsersList(loc, value) {
-  if (value !== undefined && !(0, _helperCompilationTargets().isBrowsersQueryValid)(value)) {
-    throw new Error(`${msg(loc)} must be undefined, a string or an array of strings`);
-  }
-}
-
-function assertBrowserVersion(loc, value) {
-  if (typeof value === "number" && Math.round(value) === value) return;
-  if (typeof value === "string") return;
-  throw new Error(`${msg(loc)} must be a string or an integer number`);
-}
-
-function assertAssumptions(loc, value) {
-  if (value === undefined) return;
-
-  if (typeof value !== "object" || value === null) {
-    throw new Error(`${msg(loc)} must be an object or undefined.`);
-  }
-
-  let root = loc;
-
-  do {
-    root = root.parent;
-  } while (root.type !== "root");
-
-  const inPreset = root.source === "preset";
-
-  for (const name of Object.keys(value)) {
-    const subLoc = access(loc, name);
-
-    if (!_options.assumptionsNames.has(name)) {
-      throw new Error(`${msg(subLoc)} is not a supported assumption.`);
-    }
-
-    if (typeof value[name] !== "boolean") {
-      throw new Error(`${msg(subLoc)} must be a boolean.`);
-    }
-
-    if (inPreset && value[name] === false) {
-      throw new Error(`${msg(subLoc)} cannot be set to 'false' inside presets.`);
-    }
-  }
-
-  return value;
-}

node_modules/@babel/core/lib/config/validation/options.js

@@ -1,210 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validate = validate;
-exports.checkNoUnwrappedItemOptionPairs = checkNoUnwrappedItemOptionPairs;
-exports.assumptionsNames = void 0;
-
-var _plugin = require("../plugin");
-
-var _removed = require("./removed");
-
-var _optionAssertions = require("./option-assertions");
-
-const ROOT_VALIDATORS = {
-  cwd: _optionAssertions.assertString,
-  root: _optionAssertions.assertString,
-  rootMode: _optionAssertions.assertRootMode,
-  configFile: _optionAssertions.assertConfigFileSearch,
-  caller: _optionAssertions.assertCallerMetadata,
-  filename: _optionAssertions.assertString,
-  filenameRelative: _optionAssertions.assertString,
-  code: _optionAssertions.assertBoolean,
-  ast: _optionAssertions.assertBoolean,
-  cloneInputAst: _optionAssertions.assertBoolean,
-  envName: _optionAssertions.assertString
-};
-const BABELRC_VALIDATORS = {
-  babelrc: _optionAssertions.assertBoolean,
-  babelrcRoots: _optionAssertions.assertBabelrcSearch
-};
-const NONPRESET_VALIDATORS = {
-  extends: _optionAssertions.assertString,
-  ignore: _optionAssertions.assertIgnoreList,
-  only: _optionAssertions.assertIgnoreList,
-  targets: _optionAssertions.assertTargets,
-  browserslistConfigFile: _optionAssertions.assertConfigFileSearch,
-  browserslistEnv: _optionAssertions.assertString
-};
-const COMMON_VALIDATORS = {
-  inputSourceMap: _optionAssertions.assertInputSourceMap,
-  presets: _optionAssertions.assertPluginList,
-  plugins: _optionAssertions.assertPluginList,
-  passPerPreset: _optionAssertions.assertBoolean,
-  assumptions: _optionAssertions.assertAssumptions,
-  env: assertEnvSet,
-  overrides: assertOverridesList,
-  test: _optionAssertions.assertConfigApplicableTest,
-  include: _optionAssertions.assertConfigApplicableTest,
-  exclude: _optionAssertions.assertConfigApplicableTest,
-  retainLines: _optionAssertions.assertBoolean,
-  comments: _optionAssertions.assertBoolean,
-  shouldPrintComment: _optionAssertions.assertFunction,
-  compact: _optionAssertions.assertCompact,
-  minified: _optionAssertions.assertBoolean,
-  auxiliaryCommentBefore: _optionAssertions.assertString,
-  auxiliaryCommentAfter: _optionAssertions.assertString,
-  sourceType: _optionAssertions.assertSourceType,
-  wrapPluginVisitorMethod: _optionAssertions.assertFunction,
-  highlightCode: _optionAssertions.assertBoolean,
-  sourceMaps: _optionAssertions.assertSourceMaps,
-  sourceMap: _optionAssertions.assertSourceMaps,
-  sourceFileName: _optionAssertions.assertString,
-  sourceRoot: _optionAssertions.assertString,
-  parserOpts: _optionAssertions.assertObject,
-  generatorOpts: _optionAssertions.assertObject
-};
-{
-  Object.assign(COMMON_VALIDATORS, {
-    getModuleId: _optionAssertions.assertFunction,
-    moduleRoot: _optionAssertions.assertString,
-    moduleIds: _optionAssertions.assertBoolean,
-    moduleId: _optionAssertions.assertString
-  });
-}
-const assumptionsNames = new Set(["arrayLikeIsIterable", "constantReexports", "constantSuper", "enumerableModuleMeta", "ignoreFunctionLength", "ignoreToPrimitiveHint", "iterableIsArray", "mutableTemplateObject", "noClassCalls", "noDocumentAll", "noNewArrows", "objectRestNoSymbols", "privateFieldsAsProperties", "pureGetters", "setClassMethods", "setComputedProperties", "setPublicClassFields", "setSpreadProperties", "skipForOfIteratorClosing", "superIsCallableConstructor"]);
-exports.assumptionsNames = assumptionsNames;
-
-function getSource(loc) {
-  return loc.type === "root" ? loc.source : getSource(loc.parent);
-}
-
-function validate(type, opts) {
-  return validateNested({
-    type: "root",
-    source: type
-  }, opts);
-}
-
-function validateNested(loc, opts) {
-  const type = getSource(loc);
-  assertNoDuplicateSourcemap(opts);
-  Object.keys(opts).forEach(key => {
-    const optLoc = {
-      type: "option",
-      name: key,
-      parent: loc
-    };
-
-    if (type === "preset" && NONPRESET_VALIDATORS[key]) {
-      throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in preset options`);
-    }
-
-    if (type !== "arguments" && ROOT_VALIDATORS[key]) {
-      throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options`);
-    }
-
-    if (type !== "arguments" && type !== "configfile" && BABELRC_VALIDATORS[key]) {
-      if (type === "babelrcfile" || type === "extendsfile") {
-        throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in .babelrc or "extends"ed files, only in root programmatic options, ` + `or babel.config.js/config file options`);
-      }
-
-      throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options, or babel.config.js/config file options`);
-    }
-
-    const validator = COMMON_VALIDATORS[key] || NONPRESET_VALIDATORS[key] || BABELRC_VALIDATORS[key] || ROOT_VALIDATORS[key] || throwUnknownError;
-    validator(optLoc, opts[key]);
-  });
-  return opts;
-}
-
-function throwUnknownError(loc) {
-  const key = loc.name;
-
-  if (_removed.default[key]) {
-    const {
-      message,
-      version = 5
-    } = _removed.default[key];
-    throw new Error(`Using removed Babel ${version} option: ${(0, _optionAssertions.msg)(loc)} - ${message}`);
-  } else {
-    const unknownOptErr = new Error(`Unknown option: ${(0, _optionAssertions.msg)(loc)}. Check out https://babeljs.io/docs/en/babel-core/#options for more information about options.`);
-    unknownOptErr.code = "BABEL_UNKNOWN_OPTION";
-    throw unknownOptErr;
-  }
-}
-
-function has(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-}
-
-function assertNoDuplicateSourcemap(opts) {
-  if (has(opts, "sourceMap") && has(opts, "sourceMaps")) {
-    throw new Error(".sourceMap is an alias for .sourceMaps, cannot use both");
-  }
-}
-
-function assertEnvSet(loc, value) {
-  if (loc.parent.type === "env") {
-    throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside of another .env block`);
-  }
-
-  const parent = loc.parent;
-  const obj = (0, _optionAssertions.assertObject)(loc, value);
-
-  if (obj) {
-    for (const envName of Object.keys(obj)) {
-      const env = (0, _optionAssertions.assertObject)((0, _optionAssertions.access)(loc, envName), obj[envName]);
-      if (!env) continue;
-      const envLoc = {
-        type: "env",
-        name: envName,
-        parent
-      };
-      validateNested(envLoc, env);
-    }
-  }
-
-  return obj;
-}
-
-function assertOverridesList(loc, value) {
-  if (loc.parent.type === "env") {
-    throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .env block`);
-  }
-
-  if (loc.parent.type === "overrides") {
-    throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .overrides block`);
-  }
-
-  const parent = loc.parent;
-  const arr = (0, _optionAssertions.assertArray)(loc, value);
-
-  if (arr) {
-    for (const [index, item] of arr.entries()) {
-      const objLoc = (0, _optionAssertions.access)(loc, index);
-      const env = (0, _optionAssertions.assertObject)(objLoc, item);
-      if (!env) throw new Error(`${(0, _optionAssertions.msg)(objLoc)} must be an object`);
-      const overridesLoc = {
-        type: "overrides",
-        index,
-        parent
-      };
-      validateNested(overridesLoc, env);
-    }
-  }
-
-  return arr;
-}
-
-function checkNoUnwrappedItemOptionPairs(items, index, type, e) {
-  if (index === 0) return;
-  const lastItem = items[index - 1];
-  const thisItem = items[index];
-
-  if (lastItem.file && lastItem.options === undefined && typeof thisItem.value === "object") {
-    e.message += `\n- Maybe you meant to use\n` + `"${type}": [\n  ["${lastItem.file.request}", ${JSON.stringify(thisItem.value, undefined, 2)}]\n]\n` + `To be a valid ${type}, its name and options should be wrapped in a pair of brackets`;
-  }
-}

node_modules/@babel/core/lib/config/validation/plugins.js

@@ -1,71 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validatePluginObject = validatePluginObject;
-
-var _optionAssertions = require("./option-assertions");
-
-const VALIDATORS = {
-  name: _optionAssertions.assertString,
-  manipulateOptions: _optionAssertions.assertFunction,
-  pre: _optionAssertions.assertFunction,
-  post: _optionAssertions.assertFunction,
-  inherits: _optionAssertions.assertFunction,
-  visitor: assertVisitorMap,
-  parserOverride: _optionAssertions.assertFunction,
-  generatorOverride: _optionAssertions.assertFunction
-};
-
-function assertVisitorMap(loc, value) {
-  const obj = (0, _optionAssertions.assertObject)(loc, value);
-
-  if (obj) {
-    Object.keys(obj).forEach(prop => assertVisitorHandler(prop, obj[prop]));
-
-    if (obj.enter || obj.exit) {
-      throw new Error(`${(0, _optionAssertions.msg)(loc)} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`);
-    }
-  }
-
-  return obj;
-}
-
-function assertVisitorHandler(key, value) {
-  if (value && typeof value === "object") {
-    Object.keys(value).forEach(handler => {
-      if (handler !== "enter" && handler !== "exit") {
-        throw new Error(`.visitor["${key}"] may only have .enter and/or .exit handlers.`);
-      }
-    });
-  } else if (typeof value !== "function") {
-    throw new Error(`.visitor["${key}"] must be a function`);
-  }
-
-  return value;
-}
-
-function validatePluginObject(obj) {
-  const rootPath = {
-    type: "root",
-    source: "plugin"
-  };
-  Object.keys(obj).forEach(key => {
-    const validator = VALIDATORS[key];
-
-    if (validator) {
-      const optLoc = {
-        type: "option",
-        name: key,
-        parent: rootPath
-      };
-      validator(optLoc, obj[key]);
-    } else {
-      const invalidPluginPropertyError = new Error(`.${key} is not a valid Plugin property`);
-      invalidPluginPropertyError.code = "BABEL_UNKNOWN_PLUGIN_PROPERTY";
-      throw invalidPluginPropertyError;
-    }
-  });
-  return obj;
-}

node_modules/@babel/core/lib/config/validation/removed.js

@@ -1,66 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _default = {
-  auxiliaryComment: {
-    message: "Use `auxiliaryCommentBefore` or `auxiliaryCommentAfter`"
-  },
-  blacklist: {
-    message: "Put the specific transforms you want in the `plugins` option"
-  },
-  breakConfig: {
-    message: "This is not a necessary option in Babel 6"
-  },
-  experimental: {
-    message: "Put the specific transforms you want in the `plugins` option"
-  },
-  externalHelpers: {
-    message: "Use the `external-helpers` plugin instead. " + "Check out http://babeljs.io/docs/plugins/external-helpers/"
-  },
-  extra: {
-    message: ""
-  },
-  jsxPragma: {
-    message: "use the `pragma` option in the `react-jsx` plugin. " + "Check out http://babeljs.io/docs/plugins/transform-react-jsx/"
-  },
-  loose: {
-    message: "Specify the `loose` option for the relevant plugin you are using " + "or use a preset that sets the option."
-  },
-  metadataUsedHelpers: {
-    message: "Not required anymore as this is enabled by default"
-  },
-  modules: {
-    message: "Use the corresponding module transform plugin in the `plugins` option. " + "Check out http://babeljs.io/docs/plugins/#modules"
-  },
-  nonStandard: {
-    message: "Use the `react-jsx` and `flow-strip-types` plugins to support JSX and Flow. " + "Also check out the react preset http://babeljs.io/docs/plugins/preset-react/"
-  },
-  optional: {
-    message: "Put the specific transforms you want in the `plugins` option"
-  },
-  sourceMapName: {
-    message: "The `sourceMapName` option has been removed because it makes more sense for the " + "tooling that calls Babel to assign `map.file` themselves."
-  },
-  stage: {
-    message: "Check out the corresponding stage-x presets http://babeljs.io/docs/plugins/#presets"
-  },
-  whitelist: {
-    message: "Put the specific transforms you want in the `plugins` option"
-  },
-  resolveModuleSource: {
-    version: 6,
-    message: "Use `babel-plugin-module-resolver@3`'s 'resolvePath' options"
-  },
-  metadata: {
-    version: 6,
-    message: "Generated plugin metadata is always included in the output result"
-  },
-  sourceMapTarget: {
-    version: 6,
-    message: "The `sourceMapTarget` option has been removed because it makes more sense for the tooling " + "that calls Babel to assign `map.file` themselves."
-  }
-};
-exports.default = _default;

node_modules/@babel/core/lib/gensync-utils/async.js

@@ -1,93 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.maybeAsync = maybeAsync;
-exports.forwardAsync = forwardAsync;
-exports.isThenable = isThenable;
-exports.waitFor = exports.onFirstPause = exports.isAsync = void 0;
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-const id = x => x;
-
-const runGenerator = _gensync()(function* (item) {
-  return yield* item;
-});
-
-const isAsync = _gensync()({
-  sync: () => false,
-  errback: cb => cb(null, true)
-});
-
-exports.isAsync = isAsync;
-
-function maybeAsync(fn, message) {
-  return _gensync()({
-    sync(...args) {
-      const result = fn.apply(this, args);
-      if (isThenable(result)) throw new Error(message);
-      return result;
-    },
-
-    async(...args) {
-      return Promise.resolve(fn.apply(this, args));
-    }
-
-  });
-}
-
-const withKind = _gensync()({
-  sync: cb => cb("sync"),
-  async: cb => cb("async")
-});
-
-function forwardAsync(action, cb) {
-  const g = _gensync()(action);
-
-  return withKind(kind => {
-    const adapted = g[kind];
-    return cb(adapted);
-  });
-}
-
-const onFirstPause = _gensync()({
-  name: "onFirstPause",
-  arity: 2,
-  sync: function (item) {
-    return runGenerator.sync(item);
-  },
-  errback: function (item, firstPause, cb) {
-    let completed = false;
-    runGenerator.errback(item, (err, value) => {
-      completed = true;
-      cb(err, value);
-    });
-
-    if (!completed) {
-      firstPause();
-    }
-  }
-});
-
-exports.onFirstPause = onFirstPause;
-
-const waitFor = _gensync()({
-  sync: id,
-  async: id
-});
-
-exports.waitFor = waitFor;
-
-function isThenable(val) {
-  return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
-}

node_modules/@babel/core/lib/gensync-utils/fs.js

@@ -1,40 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.stat = exports.readFile = void 0;
-
-function _fs() {
-  const data = require("fs");
-
-  _fs = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-const readFile = _gensync()({
-  sync: _fs().readFileSync,
-  errback: _fs().readFile
-});
-
-exports.readFile = readFile;
-
-const stat = _gensync()({
-  sync: _fs().statSync,
-  errback: _fs().stat
-});
-
-exports.stat = stat;

node_modules/@babel/core/lib/index.js

@@ -1,264 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Plugin = Plugin;
-Object.defineProperty(exports, "File", {
-  enumerable: true,
-  get: function () {
-    return _file.default;
-  }
-});
-Object.defineProperty(exports, "buildExternalHelpers", {
-  enumerable: true,
-  get: function () {
-    return _buildExternalHelpers.default;
-  }
-});
-Object.defineProperty(exports, "resolvePlugin", {
-  enumerable: true,
-  get: function () {
-    return _files.resolvePlugin;
-  }
-});
-Object.defineProperty(exports, "resolvePreset", {
-  enumerable: true,
-  get: function () {
-    return _files.resolvePreset;
-  }
-});
-Object.defineProperty(exports, "getEnv", {
-  enumerable: true,
-  get: function () {
-    return _environment.getEnv;
-  }
-});
-Object.defineProperty(exports, "tokTypes", {
-  enumerable: true,
-  get: function () {
-    return _parser().tokTypes;
-  }
-});
-Object.defineProperty(exports, "traverse", {
-  enumerable: true,
-  get: function () {
-    return _traverse().default;
-  }
-});
-Object.defineProperty(exports, "template", {
-  enumerable: true,
-  get: function () {
-    return _template().default;
-  }
-});
-Object.defineProperty(exports, "createConfigItem", {
-  enumerable: true,
-  get: function () {
-    return _config.createConfigItem;
-  }
-});
-Object.defineProperty(exports, "createConfigItemSync", {
-  enumerable: true,
-  get: function () {
-    return _config.createConfigItemSync;
-  }
-});
-Object.defineProperty(exports, "createConfigItemAsync", {
-  enumerable: true,
-  get: function () {
-    return _config.createConfigItemAsync;
-  }
-});
-Object.defineProperty(exports, "loadPartialConfig", {
-  enumerable: true,
-  get: function () {
-    return _config.loadPartialConfig;
-  }
-});
-Object.defineProperty(exports, "loadPartialConfigSync", {
-  enumerable: true,
-  get: function () {
-    return _config.loadPartialConfigSync;
-  }
-});
-Object.defineProperty(exports, "loadPartialConfigAsync", {
-  enumerable: true,
-  get: function () {
-    return _config.loadPartialConfigAsync;
-  }
-});
-Object.defineProperty(exports, "loadOptions", {
-  enumerable: true,
-  get: function () {
-    return _config.loadOptions;
-  }
-});
-Object.defineProperty(exports, "loadOptionsSync", {
-  enumerable: true,
-  get: function () {
-    return _config.loadOptionsSync;
-  }
-});
-Object.defineProperty(exports, "loadOptionsAsync", {
-  enumerable: true,
-  get: function () {
-    return _config.loadOptionsAsync;
-  }
-});
-Object.defineProperty(exports, "transform", {
-  enumerable: true,
-  get: function () {
-    return _transform.transform;
-  }
-});
-Object.defineProperty(exports, "transformSync", {
-  enumerable: true,
-  get: function () {
-    return _transform.transformSync;
-  }
-});
-Object.defineProperty(exports, "transformAsync", {
-  enumerable: true,
-  get: function () {
-    return _transform.transformAsync;
-  }
-});
-Object.defineProperty(exports, "transformFile", {
-  enumerable: true,
-  get: function () {
-    return _transformFile.transformFile;
-  }
-});
-Object.defineProperty(exports, "transformFileSync", {
-  enumerable: true,
-  get: function () {
-    return _transformFile.transformFileSync;
-  }
-});
-Object.defineProperty(exports, "transformFileAsync", {
-  enumerable: true,
-  get: function () {
-    return _transformFile.transformFileAsync;
-  }
-});
-Object.defineProperty(exports, "transformFromAst", {
-  enumerable: true,
-  get: function () {
-    return _transformAst.transformFromAst;
-  }
-});
-Object.defineProperty(exports, "transformFromAstSync", {
-  enumerable: true,
-  get: function () {
-    return _transformAst.transformFromAstSync;
-  }
-});
-Object.defineProperty(exports, "transformFromAstAsync", {
-  enumerable: true,
-  get: function () {
-    return _transformAst.transformFromAstAsync;
-  }
-});
-Object.defineProperty(exports, "parse", {
-  enumerable: true,
-  get: function () {
-    return _parse.parse;
-  }
-});
-Object.defineProperty(exports, "parseSync", {
-  enumerable: true,
-  get: function () {
-    return _parse.parseSync;
-  }
-});
-Object.defineProperty(exports, "parseAsync", {
-  enumerable: true,
-  get: function () {
-    return _parse.parseAsync;
-  }
-});
-exports.types = exports.OptionManager = exports.DEFAULT_EXTENSIONS = exports.version = void 0;
-
-var _file = require("./transformation/file/file");
-
-var _buildExternalHelpers = require("./tools/build-external-helpers");
-
-var _files = require("./config/files");
-
-var _environment = require("./config/helpers/environment");
-
-function _types() {
-  const data = require("@babel/types");
-
-  _types = function () {
-    return data;
-  };
-
-  return data;
-}
-
-Object.defineProperty(exports, "types", {
-  enumerable: true,
-  get: function () {
-    return _types();
-  }
-});
-
-function _parser() {
-  const data = require("@babel/parser");
-
-  _parser = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _traverse() {
-  const data = require("@babel/traverse");
-
-  _traverse = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _template() {
-  const data = require("@babel/template");
-
-  _template = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _config = require("./config");
-
-var _transform = require("./transform");
-
-var _transformFile = require("./transform-file");
-
-var _transformAst = require("./transform-ast");
-
-var _parse = require("./parse");
-
-const version = "7.14.3";
-exports.version = version;
-const DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".es6", ".es", ".mjs", ".cjs"]);
-exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
-
-class OptionManager {
-  init(opts) {
-    return (0, _config.loadOptions)(opts);
-  }
-
-}
-
-exports.OptionManager = OptionManager;
-
-function Plugin(alias) {
-  throw new Error(`The (${alias}) Babel 5 plugin is being run with an unsupported Babel version.`);
-}

node_modules/@babel/core/lib/parse.js

@@ -1,48 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parseAsync = exports.parseSync = exports.parse = void 0;
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _config = require("./config");
-
-var _parser = require("./parser");
-
-var _normalizeOpts = require("./transformation/normalize-opts");
-
-const parseRunner = _gensync()(function* parse(code, opts) {
-  const config = yield* (0, _config.default)(opts);
-
-  if (config === null) {
-    return null;
-  }
-
-  return yield* (0, _parser.default)(config.passes, (0, _normalizeOpts.default)(config), code);
-});
-
-const parse = function parse(code, opts, callback) {
-  if (typeof opts === "function") {
-    callback = opts;
-    opts = undefined;
-  }
-
-  if (callback === undefined) return parseRunner.sync(code, opts);
-  parseRunner.errback(code, opts, callback);
-};
-
-exports.parse = parse;
-const parseSync = parseRunner.sync;
-exports.parseSync = parseSync;
-const parseAsync = parseRunner.async;
-exports.parseAsync = parseAsync;

node_modules/@babel/core/lib/parser/index.js

@@ -1,95 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = parser;
-
-function _parser() {
-  const data = require("@babel/parser");
-
-  _parser = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _codeFrame() {
-  const data = require("@babel/code-frame");
-
-  _codeFrame = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _missingPluginHelper = require("./util/missing-plugin-helper");
-
-function* parser(pluginPasses, {
-  parserOpts,
-  highlightCode = true,
-  filename = "unknown"
-}, code) {
-  try {
-    const results = [];
-
-    for (const plugins of pluginPasses) {
-      for (const plugin of plugins) {
-        const {
-          parserOverride
-        } = plugin;
-
-        if (parserOverride) {
-          const ast = parserOverride(code, parserOpts, _parser().parse);
-          if (ast !== undefined) results.push(ast);
-        }
-      }
-    }
-
-    if (results.length === 0) {
-      return (0, _parser().parse)(code, parserOpts);
-    } else if (results.length === 1) {
-      yield* [];
-
-      if (typeof results[0].then === "function") {
-        throw new Error(`You appear to be using an async parser plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
-      }
-
-      return results[0];
-    }
-
-    throw new Error("More than one plugin attempted to override parsing.");
-  } catch (err) {
-    if (err.code === "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED") {
-      err.message += "\nConsider renaming the file to '.mjs', or setting sourceType:module " + "or sourceType:unambiguous in your Babel config for this file.";
-    }
-
-    const {
-      loc,
-      missingPlugin
-    } = err;
-
-    if (loc) {
-      const codeFrame = (0, _codeFrame().codeFrameColumns)(code, {
-        start: {
-          line: loc.line,
-          column: loc.column + 1
-        }
-      }, {
-        highlightCode
-      });
-
-      if (missingPlugin) {
-        err.message = `${filename}: ` + (0, _missingPluginHelper.default)(missingPlugin[0], loc, codeFrame);
-      } else {
-        err.message = `${filename}: ${err.message}\n\n` + codeFrame;
-      }
-
-      err.code = "BABEL_PARSE_ERROR";
-    }
-
-    throw err;
-  }
-}

node_modules/@babel/core/lib/parser/util/missing-plugin-helper.js

@@ -1,313 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = generateMissingPluginMessage;
-const pluginNameMap = {
-  asyncDoExpressions: {
-    syntax: {
-      name: "@babel/plugin-syntax-async-do-expressions",
-      url: "https://git.io/JYer8"
-    }
-  },
-  classProperties: {
-    syntax: {
-      name: "@babel/plugin-syntax-class-properties",
-      url: "https://git.io/vb4yQ"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-class-properties",
-      url: "https://git.io/vb4SL"
-    }
-  },
-  classPrivateProperties: {
-    syntax: {
-      name: "@babel/plugin-syntax-class-properties",
-      url: "https://git.io/vb4yQ"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-class-properties",
-      url: "https://git.io/vb4SL"
-    }
-  },
-  classPrivateMethods: {
-    syntax: {
-      name: "@babel/plugin-syntax-class-properties",
-      url: "https://git.io/vb4yQ"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-private-methods",
-      url: "https://git.io/JvpRG"
-    }
-  },
-  classStaticBlock: {
-    syntax: {
-      name: "@babel/plugin-syntax-class-static-block",
-      url: "https://git.io/JTLB6"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-class-static-block",
-      url: "https://git.io/JTLBP"
-    }
-  },
-  decimal: {
-    syntax: {
-      name: "@babel/plugin-syntax-decimal",
-      url: "https://git.io/JfKOH"
-    }
-  },
-  decorators: {
-    syntax: {
-      name: "@babel/plugin-syntax-decorators",
-      url: "https://git.io/vb4y9"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-decorators",
-      url: "https://git.io/vb4ST"
-    }
-  },
-  doExpressions: {
-    syntax: {
-      name: "@babel/plugin-syntax-do-expressions",
-      url: "https://git.io/vb4yh"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-do-expressions",
-      url: "https://git.io/vb4S3"
-    }
-  },
-  dynamicImport: {
-    syntax: {
-      name: "@babel/plugin-syntax-dynamic-import",
-      url: "https://git.io/vb4Sv"
-    }
-  },
-  exportDefaultFrom: {
-    syntax: {
-      name: "@babel/plugin-syntax-export-default-from",
-      url: "https://git.io/vb4SO"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-export-default-from",
-      url: "https://git.io/vb4yH"
-    }
-  },
-  exportNamespaceFrom: {
-    syntax: {
-      name: "@babel/plugin-syntax-export-namespace-from",
-      url: "https://git.io/vb4Sf"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-export-namespace-from",
-      url: "https://git.io/vb4SG"
-    }
-  },
-  flow: {
-    syntax: {
-      name: "@babel/plugin-syntax-flow",
-      url: "https://git.io/vb4yb"
-    },
-    transform: {
-      name: "@babel/preset-flow",
-      url: "https://git.io/JfeDn"
-    }
-  },
-  functionBind: {
-    syntax: {
-      name: "@babel/plugin-syntax-function-bind",
-      url: "https://git.io/vb4y7"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-function-bind",
-      url: "https://git.io/vb4St"
-    }
-  },
-  functionSent: {
-    syntax: {
-      name: "@babel/plugin-syntax-function-sent",
-      url: "https://git.io/vb4yN"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-function-sent",
-      url: "https://git.io/vb4SZ"
-    }
-  },
-  importMeta: {
-    syntax: {
-      name: "@babel/plugin-syntax-import-meta",
-      url: "https://git.io/vbKK6"
-    }
-  },
-  jsx: {
-    syntax: {
-      name: "@babel/plugin-syntax-jsx",
-      url: "https://git.io/vb4yA"
-    },
-    transform: {
-      name: "@babel/preset-react",
-      url: "https://git.io/JfeDR"
-    }
-  },
-  importAssertions: {
-    syntax: {
-      name: "@babel/plugin-syntax-import-assertions",
-      url: "https://git.io/JUbkv"
-    }
-  },
-  moduleStringNames: {
-    syntax: {
-      name: "@babel/plugin-syntax-module-string-names",
-      url: "https://git.io/JTL8G"
-    }
-  },
-  numericSeparator: {
-    syntax: {
-      name: "@babel/plugin-syntax-numeric-separator",
-      url: "https://git.io/vb4Sq"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-numeric-separator",
-      url: "https://git.io/vb4yS"
-    }
-  },
-  optionalChaining: {
-    syntax: {
-      name: "@babel/plugin-syntax-optional-chaining",
-      url: "https://git.io/vb4Sc"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-optional-chaining",
-      url: "https://git.io/vb4Sk"
-    }
-  },
-  pipelineOperator: {
-    syntax: {
-      name: "@babel/plugin-syntax-pipeline-operator",
-      url: "https://git.io/vb4yj"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-pipeline-operator",
-      url: "https://git.io/vb4SU"
-    }
-  },
-  privateIn: {
-    syntax: {
-      name: "@babel/plugin-syntax-private-property-in-object",
-      url: "https://git.io/JfK3q"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-private-property-in-object",
-      url: "https://git.io/JfK3O"
-    }
-  },
-  recordAndTuple: {
-    syntax: {
-      name: "@babel/plugin-syntax-record-and-tuple",
-      url: "https://git.io/JvKp3"
-    }
-  },
-  throwExpressions: {
-    syntax: {
-      name: "@babel/plugin-syntax-throw-expressions",
-      url: "https://git.io/vb4SJ"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-throw-expressions",
-      url: "https://git.io/vb4yF"
-    }
-  },
-  typescript: {
-    syntax: {
-      name: "@babel/plugin-syntax-typescript",
-      url: "https://git.io/vb4SC"
-    },
-    transform: {
-      name: "@babel/preset-typescript",
-      url: "https://git.io/JfeDz"
-    }
-  },
-  asyncGenerators: {
-    syntax: {
-      name: "@babel/plugin-syntax-async-generators",
-      url: "https://git.io/vb4SY"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-async-generator-functions",
-      url: "https://git.io/vb4yp"
-    }
-  },
-  logicalAssignment: {
-    syntax: {
-      name: "@babel/plugin-syntax-logical-assignment-operators",
-      url: "https://git.io/vAlBp"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-logical-assignment-operators",
-      url: "https://git.io/vAlRe"
-    }
-  },
-  nullishCoalescingOperator: {
-    syntax: {
-      name: "@babel/plugin-syntax-nullish-coalescing-operator",
-      url: "https://git.io/vb4yx"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-nullish-coalescing-operator",
-      url: "https://git.io/vb4Se"
-    }
-  },
-  objectRestSpread: {
-    syntax: {
-      name: "@babel/plugin-syntax-object-rest-spread",
-      url: "https://git.io/vb4y5"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-object-rest-spread",
-      url: "https://git.io/vb4Ss"
-    }
-  },
-  optionalCatchBinding: {
-    syntax: {
-      name: "@babel/plugin-syntax-optional-catch-binding",
-      url: "https://git.io/vb4Sn"
-    },
-    transform: {
-      name: "@babel/plugin-proposal-optional-catch-binding",
-      url: "https://git.io/vb4SI"
-    }
-  }
-};
-pluginNameMap.privateIn.syntax = pluginNameMap.privateIn.transform;
-
-const getNameURLCombination = ({
-  name,
-  url
-}) => `${name} (${url})`;
-
-function generateMissingPluginMessage(missingPluginName, loc, codeFrame) {
-  let helpMessage = `Support for the experimental syntax '${missingPluginName}' isn't currently enabled ` + `(${loc.line}:${loc.column + 1}):\n\n` + codeFrame;
-  const pluginInfo = pluginNameMap[missingPluginName];
-
-  if (pluginInfo) {
-    const {
-      syntax: syntaxPlugin,
-      transform: transformPlugin
-    } = pluginInfo;
-
-    if (syntaxPlugin) {
-      const syntaxPluginInfo = getNameURLCombination(syntaxPlugin);
-
-      if (transformPlugin) {
-        const transformPluginInfo = getNameURLCombination(transformPlugin);
-        const sectionType = transformPlugin.name.startsWith("@babel/plugin") ? "plugins" : "presets";
-        helpMessage += `\n\nAdd ${transformPluginInfo} to the '${sectionType}' section of your Babel config to enable transformation.
-If you want to leave it as-is, add ${syntaxPluginInfo} to the 'plugins' section to enable parsing.`;
-      } else {
-        helpMessage += `\n\nAdd ${syntaxPluginInfo} to the 'plugins' section of your Babel config ` + `to enable parsing.`;
-      }
-    }
-  }
-
-  return helpMessage;
-}

node_modules/@babel/core/lib/tools/build-external-helpers.js

@@ -1,142 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = _default;
-
-function helpers() {
-  const data = require("@babel/helpers");
-
-  helpers = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _generator() {
-  const data = require("@babel/generator");
-
-  _generator = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _template() {
-  const data = require("@babel/template");
-
-  _template = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function t() {
-  const data = require("@babel/types");
-
-  t = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _file = require("../transformation/file/file");
-
-const buildUmdWrapper = replacements => (0, _template().default)`
-    (function (root, factory) {
-      if (typeof define === "function" && define.amd) {
-        define(AMD_ARGUMENTS, factory);
-      } else if (typeof exports === "object") {
-        factory(COMMON_ARGUMENTS);
-      } else {
-        factory(BROWSER_ARGUMENTS);
-      }
-    })(UMD_ROOT, function (FACTORY_PARAMETERS) {
-      FACTORY_BODY
-    });
-  `(replacements);
-
-function buildGlobal(allowlist) {
-  const namespace = t().identifier("babelHelpers");
-  const body = [];
-  const container = t().functionExpression(null, [t().identifier("global")], t().blockStatement(body));
-  const tree = t().program([t().expressionStatement(t().callExpression(container, [t().conditionalExpression(t().binaryExpression("===", t().unaryExpression("typeof", t().identifier("global")), t().stringLiteral("undefined")), t().identifier("self"), t().identifier("global"))]))]);
-  body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().assignmentExpression("=", t().memberExpression(t().identifier("global"), namespace), t().objectExpression([])))]));
-  buildHelpers(body, namespace, allowlist);
-  return tree;
-}
-
-function buildModule(allowlist) {
-  const body = [];
-  const refs = buildHelpers(body, null, allowlist);
-  body.unshift(t().exportNamedDeclaration(null, Object.keys(refs).map(name => {
-    return t().exportSpecifier(t().cloneNode(refs[name]), t().identifier(name));
-  })));
-  return t().program(body, [], "module");
-}
-
-function buildUmd(allowlist) {
-  const namespace = t().identifier("babelHelpers");
-  const body = [];
-  body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().identifier("global"))]));
-  buildHelpers(body, namespace, allowlist);
-  return t().program([buildUmdWrapper({
-    FACTORY_PARAMETERS: t().identifier("global"),
-    BROWSER_ARGUMENTS: t().assignmentExpression("=", t().memberExpression(t().identifier("root"), namespace), t().objectExpression([])),
-    COMMON_ARGUMENTS: t().identifier("exports"),
-    AMD_ARGUMENTS: t().arrayExpression([t().stringLiteral("exports")]),
-    FACTORY_BODY: body,
-    UMD_ROOT: t().identifier("this")
-  })]);
-}
-
-function buildVar(allowlist) {
-  const namespace = t().identifier("babelHelpers");
-  const body = [];
-  body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().objectExpression([]))]));
-  const tree = t().program(body);
-  buildHelpers(body, namespace, allowlist);
-  body.push(t().expressionStatement(namespace));
-  return tree;
-}
-
-function buildHelpers(body, namespace, allowlist) {
-  const getHelperReference = name => {
-    return namespace ? t().memberExpression(namespace, t().identifier(name)) : t().identifier(`_${name}`);
-  };
-
-  const refs = {};
-  helpers().list.forEach(function (name) {
-    if (allowlist && allowlist.indexOf(name) < 0) return;
-    const ref = refs[name] = getHelperReference(name);
-    helpers().ensure(name, _file.default);
-    const {
-      nodes
-    } = helpers().get(name, getHelperReference, ref);
-    body.push(...nodes);
-  });
-  return refs;
-}
-
-function _default(allowlist, outputType = "global") {
-  let tree;
-  const build = {
-    global: buildGlobal,
-    module: buildModule,
-    umd: buildUmd,
-    var: buildVar
-  }[outputType];
-
-  if (build) {
-    tree = build(allowlist);
-  } else {
-    throw new Error(`Unsupported output type ${outputType}`);
-  }
-
-  return (0, _generator().default)(tree).code;
-}

node_modules/@babel/core/lib/transform-ast.js

@@ -1,46 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformFromAstAsync = exports.transformFromAstSync = exports.transformFromAst = void 0;
-
-function _gensync() {
-  const data = require("gensync");
-
-  _gensync = function () {
-    return data;
-  };
-
-  return data;
-}
-
-var _config = require("./config");
-
-var _transformation = require("./transformation");
-
-const transformFromAstRunner = _gensync()(function* (ast, code, opts) {
-  const config = yield* (0, _config.default)(opts);
-  if (config === null) return null;
-  if (!ast) throw new Error("No AST given");
-  return yield* (0, _transformation.run)(config, code, ast);
-});
-
-const transformFromAst = function transformFromAst(ast, code, opts, callback) {
-  if (typeof opts === "function") {
-    callback = opts;
-    opts = undefined;
-  }
-
-  if (callback === undefined) {
-    return transformFromAstRunner.sync(ast, code, opts);
-  }
-
-  transformFromAstRunner.errback(ast, code, opts, callback);
-};
-
-exports.transformFromAst = transformFromAst;
-const transformFromAstSync = transformFromAstRunner.sync;
-exports.transformFromAstSync = transformFromAstSync;
-const transformFromAstAsync = transformFromAstRunner.async;
-exports.transformFromAstAsync = transformFromAstAsync;

node_modules/@babel/core/lib/transform-file-browser.js

@@ -1,26 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformFileSync = transformFileSync;
-exports.transformFileAsync = transformFileAsync;
-exports.transformFile = void 0;
-
-const transformFile = function transformFile(filename, opts, callback) {
-  if (typeof opts === "function") {
-    callback = opts;
-  }
-
-  callback(new Error("Transforming files is not supported in browsers"), null);
-};
-
-exports.transformFile = transformFile;
-
-function transformFileSync() {
-  throw new Error("Transforming files is not supported in browsers");
-}
-
-function transformFileAsync() {
-  return Promise.reject(new Error("Transforming files is not supported in browsers"));
-}