init

node_modules/@achrinza/node-ipc/README.md

@@ -0,0 +1,758 @@
+# @achrinza/node-ipc
+
+> **NOTE:** This is a maintenance fork of `node-ipc` This is intended for
+> packages that directly or indirectly depend on `node-ipc` where maintainers
+> need a drop-in replacement.
+>
+> See https://github.com/achrinza/node-ipc/issues/1 for more details.
+
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](code_of_conduct.md)
+[![Coverage Status](https://coveralls.io/repos/github/achrinza/node-ipc/badge.svg?branch=main)](https://coveralls.io/github/achrinza/node-ipc?branch=main)
+
+_a nodejs module for local and remote Inter Process Communication_ with full support for Linux, Mac and Windows. It also supports all forms of socket communication from low level unix and windows sockets to UDP and secure TLS and TCP sockets.
+
+A great solution for complex multiprocess **Neural Networking** in Node.JS
+
+**npm install @achrinza/node-ipc**
+
+#### Older versions of node
+
+the latest versions of `@achrinza/node-ipc` may work with the --harmony flag. Officially though, we support node v4 and newer with es5 and es6
+
+#### Testing
+
+`npm test` will run the jasmine tests with istanbul for @achrinza/node-ipc and generate a coverage report in the spec folder.
+
+You may want to install jasmine and istanbul globally with `sudo npm install -g jasmine istanbul`
+
+---
+
+#### Contents
+
+1. [Types of IPC Sockets and Supporting OS](#types-of-ipc-sockets)
+1. [IPC Config](#ipc-config)
+1. [IPC Methods](#ipc-methods)
+   1. [log](#log)
+   2. [connectTo](#connectto)
+   3. [connectToNet](#connecttonet)
+   4. [disconnect](#disconnect)
+   5. [serve](#serve)
+   6. [serveNet](#servenet)
+1. [IPC Stores and Default Variables](#ipc-stores-and-default-variables)
+1. [IPC Events](#ipc-events)
+1. [Multiple IPC instances](#multiple-ipc-instances)
+1. [Basic Examples](#basic-examples)
+   1. [Server for Unix||Windows Sockets & TCP Sockets](#server-for-unix-sockets-windows-sockets--tcp-sockets)
+   2. [Client for Unix||Windows Sockets & TCP Sockets](#client-for-unix-sockets--tcp-sockets)
+   3. [Server & Client for UDP Sockets](#server--client-for-udp-sockets)
+   4. [Raw Buffers, Real Time and / or Binary Sockets](#raw-buffer-or-binary-sockets)
+1. [Working with TLS/SSL Socket Servers & Clients](https://github.com/RIAEvangelist/@achrinza/node-ipc/tree/master/example/TLSSocket)
+1. [Node Code Examples](https://github.com/RIAEvangelist/@achrinza/node-ipc/tree/master/example)
+
+---
+
+#### Types of IPC Sockets
+
+| Type                          | Stability | Definition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| ----------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Unix Socket or Windows Socket | Stable    | Gives Linux, Mac, and Windows lightning fast communication and avoids the network card to reduce overhead and latency. [Local Unix and Windows Socket examples ](https://github.com/RIAEvangelist/@achrinza/node-ipc/tree/master/example/unixWindowsSocket/ "Unix and Windows Socket Node IPC examples")                                                                                                                                                                                                                                                                                                                                 |
+| TCP Socket                    | Stable    | Gives the most reliable communication across the network. Can be used for local IPC as well, but is slower than #1's Unix Socket Implementation because TCP sockets go through the network card while Unix Sockets and Windows Sockets do not. [Local or remote network TCP Socket examples ](https://github.com/RIAEvangelist/@achrinza/node-ipc/tree/master/example/TCPSocket/ "TCP Socket Node IPC examples")                                                                                                                                                                                                                         |
+| TLS Socket                    | Stable    | Configurable and secure network socket over SSL. Equivalent to https. [TLS/SSL documentation](https://github.com/RIAEvangelist/@achrinza/node-ipc/tree/master/example/TLSSocket)                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| UDP Sockets                   | Stable    | Gives the **fastest network communication**. UDP is less reliable but much faster than TCP. It is best used for streaming non critical data like sound, video, or multiplayer game data as it can drop packets depending on network connectivity and other factors. UDP can be used for local IPC as well, but is slower than #1's Unix Socket or Windows Socket Implementation because UDP sockets go through the network card while Unix and Windows Sockets do not. [Local or remote network UDP Socket examples ](https://github.com/RIAEvangelist/@achrinza/node-ipc/tree/master/example/UDPSocket/ "UDP Socket Node IPC examples") |
+
+| OS    | Supported Sockets          |
+| ----- | -------------------------- |
+| Linux | Unix, Posix, TCP, TLS, UDP |
+| Mac   | Unix, Posix, TCP, TLS, UDP |
+| Win   | Windows, TCP, TLS, UDP     |
+
+---
+
+#### IPC Config
+
+`ipc.config`
+
+Set these variables in the `ipc.config` scope to overwrite or set default values.
+
+```javascript
+
+    {
+        appspace        : 'app.',
+        socketRoot      : '/tmp/',
+        id              : os.hostname(),
+        networkHost     : 'localhost', //should resolve to 127.0.0.1 or ::1 see the table below related to this
+        networkPort     : 8000,
+        readableAll     : false,
+        writableAll     : false,
+        encoding        : 'utf8',
+        rawBuffer       : false,
+        delimiter       : '\f',
+        sync            : false,
+        silent          : false,
+        logInColor      : true,
+        logDepth        : 5,
+        logger          : console.log,
+        maxConnections  : 100,
+        retry           : 500,
+        maxRetries      : false,
+        stopRetrying    : false,
+        unlink          : true,
+        interfaces      : {
+            localAddress: false,
+            localPort   : false,
+            family      : false,
+            hints       : false,
+            lookup      : false
+        }
+    }
+
+```
+
+| variable       | documentation                                                                                                                                                                                                                                                                                                                                                                                                 |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| appspace       | used for Unix Socket (Unix Domain Socket) namespacing. If not set specifically, the Unix Domain Socket will combine the socketRoot, appspace, and id to form the Unix Socket Path for creation or binding. This is available in case you have many apps running on your system, you may have several sockets with the same id, but if you change the appspace, you will still have app specic unique sockets. |
+| socketRoot     | the directory in which to create or bind to a Unix Socket                                                                                                                                                                                                                                                                                                                                                     |
+| id             | the id of this socket or service                                                                                                                                                                                                                                                                                                                                                                              |
+| networkHost    | the local or remote host on which TCP, TLS or UDP Sockets should connect                                                                                                                                                                                                                                                                                                                                      |
+| networkPort    | the default port on which TCP, TLS, or UDP sockets should connect                                                                                                                                                                                                                                                                                                                                             |
+| readableAll    | makes the pipe readable for all users including windows services                                                                                                                                                                                                                                                                                                                                              |
+| writableAll    | makes the pipe writable for all users including windows services                                                                                                                                                                                                                                                                                                                                              |
+| encoding       | the default encoding for data sent on sockets. Mostly used if rawBuffer is set to true. Valid values are : ` ascii` `utf8` ` utf16le` ` ucs2` ` base64` `hex` .                                                                                                                                                                                                                                               |
+| rawBuffer      | if true, data will be sent and received as a raw node `Buffer` **NOT** an `Object` as JSON. This is great for Binary or hex IPC, and communicating with other processes in languages like C and C++                                                                                                                                                                                                           |
+| delimiter      | the delimiter at the end of each data packet.                                                                                                                                                                                                                                                                                                                                                                 |
+| sync           | synchronous requests. Clients will not send new requests until the server answers.                                                                                                                                                                                                                                                                                                                            |
+| silent         | turn on/off logging default is false which means logging is on                                                                                                                                                                                                                                                                                                                                                |
+| logInColor     | turn on/off util.inspect colors for ipc.log                                                                                                                                                                                                                                                                                                                                                                   |
+| logDepth       | set the depth for util.inspect during ipc.log                                                                                                                                                                                                                                                                                                                                                                 |
+| logger         | the function which receives the output from ipc.log; should take a single string argument                                                                                                                                                                                                                                                                                                                     |
+| maxConnections | this is the max number of connections allowed to a socket. It is currently only being set on Unix Sockets. Other Socket types are using the system defaults.                                                                                                                                                                                                                                                  |
+| retry          | this is the time in milliseconds a client will wait before trying to reconnect to a server if the connection is lost. This does not effect UDP sockets since they do not have a client server relationship like Unix Sockets and TCP Sockets.                                                                                                                                                                 |
+| maxRetries     | if set, it represents the maximum number of retries after each disconnect before giving up and completely killing a specific connection                                                                                                                                                                                                                                                                       |
+| stopRetrying   | Defaults to false meaning clients will continue to retry to connect to servers indefinitely at the retry interval. If set to any number the client will stop retrying when that number is exceeded after each disconnect. If set to true in real time it will immediately stop trying to connect regardless of maxRetries. If set to 0, the client will **_NOT_** try to reconnect.                           |
+| unlink         | Defaults to true meaning that the module will take care of deleting the IPC socket prior to startup. If you use `@achrinza/node-ipc` in a clustered environment where there will be multiple listeners on the same socket, you must set this to `false` and then take care of deleting the socket in your own code.                                                                                           |
+| interfaces     | primarily used when specifying which interface a client should connect through. see the [socket.connect documentation in the node.js api](https://nodejs.org/api/net.html#net_socket_connect_options_connectlistener)                                                                                                                                                                                         |
+
+---
+
+#### IPC Methods
+
+These methods are available in the IPC Scope.
+
+---
+
+##### log
+
+`ipc.log(a,b,c,d,e...);`
+
+ipc.log will accept any number of arguments and if `ipc.config.silent` is not set, it will concat them all with a single space ' ' between them and then log them to the console. This is fast because it prevents any concatenation from happening if the ipc.config.silent is set `true`. That way if you leave your logging in place it should have almost no effect on performance.
+
+The log also uses util.inspect You can control if it should log in color, the log depth, and the destination via `ipc.config`
+
+```javascript
+ipc.config.logInColor = true; //default
+ipc.config.logDepth = 5; //default
+ipc.config.logger = console.log.bind(console); // default
+```
+
+---
+
+##### connectTo
+
+`ipc.connectTo(id,path,callback);`
+
+Used for connecting as a client to local Unix Sockets and Windows Sockets. **_This is the fastest way for processes on the same machine to communicate_** because it bypasses the network card which TCP and UDP must both use.
+
+| variable | required | definition                                                                                                                                                                                                                                                                     |
+| -------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| id       | required | is the string id of the socket being connected to. The socket with this id is added to the ipc.of object when created.                                                                                                                                                         |
+| path     | optional | is the path of the Unix Domain Socket File, if the System is Windows, this will automatically be converted to an appropriate pipe with the same information as the Unix Domain Socket File. If not set this will default to `ipc.config.socketRoot`+`ipc.config.appspace`+`id` |
+| callback | optional | this is the function to execute when the socket has been created.                                                                                                                                                                                                              |
+
+**examples** arguments can be ommitted so long as they are still in order.
+
+```javascript
+ipc.connectTo("world");
+```
+
+or using just an id and a callback
+
+```javascript
+ipc.connectTo("world", function () {
+  ipc.of.world.on("hello", function (data) {
+    ipc.log(data.debug);
+    //if data was a string, it would have the color set to the debug style applied to it
+  });
+});
+```
+
+or explicitly setting the path
+
+```javascript
+ipc.connectTo("world", "myapp.world");
+```
+
+or explicitly setting the path with callback
+
+```javascript
+
+    ipc.connectTo(
+        'world',
+        'myapp.world',
+        function(){
+            ...
+        }
+    );
+
+```
+
+---
+
+##### connectToNet
+
+`ipc.connectToNet(id,host,port,callback)`
+
+Used to connect as a client to a TCP or [TLS socket](https://github.com/RIAEvangelist/@achrinza/node-ipc/tree/master/example/TLSSocket) via the network card. This can be local or remote, if local, it is recommended that you use the Unix and Windows Socket Implementaion of `connectTo` instead as it is much faster since it avoids the network card altogether.
+
+For TLS and SSL Sockets see the [@achrinza/node-ipc TLS and SSL docs](https://github.com/RIAEvangelist/@achrinza/node-ipc/tree/master/example/TLSSocket). They have a few additional requirements, and things to know about and so have their own doc.
+
+| variable | required | definition                                                                                                                                                                   |
+| -------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| id       | required | is the string id of the socket being connected to. For TCP & TLS sockets, this id is added to the `ipc.of` object when the socket is created with a reference to the socket. |
+| host     | optional | is the host on which the TCP or TLS socket resides. This will default to `ipc.config.networkHost` if not specified.                                                          |
+| port     | optional | the port on which the TCP or TLS socket resides.                                                                                                                             |
+| callback | optional | this is the function to execute when the socket has been created.                                                                                                            |
+
+**examples** arguments can be ommitted so long as they are still in order.  
+So while the default is : (id,host,port,callback), the following examples will still work because they are still in order (id,port,callback) or (id,host,callback) or (id,port) etc.
+
+```javascript
+ipc.connectToNet("world");
+```
+
+or using just an id and a callback
+
+```javascript
+
+    ipc.connectToNet(
+        'world',
+        function(){
+            ...
+        }
+    );
+
+```
+
+or explicitly setting the host and path
+
+```javascript
+
+    ipc.connectToNet(
+        'world',
+        'myapp.com',serve(path,callback)
+        3435
+    );
+
+```
+
+or only explicitly setting port and callback
+
+```javascript
+
+    ipc.connectToNet(
+        'world',
+        3435,
+        function(){
+            ...
+        }
+    );
+
+```
+
+---
+
+##### disconnect
+
+`ipc.disconnect(id)`
+
+Used to disconnect a client from a Unix, Windows, TCP or TLS socket. The socket and its refrence will be removed from memory and the `ipc.of` scope. This can be local or remote. UDP clients do not maintain connections and so there are no Clients and this method has no value to them.
+
+| variable | required | definition                                               |
+| -------- | -------- | -------------------------------------------------------- |
+| id       | required | is the string id of the socket from which to disconnect. |
+
+**examples**
+
+```javascript
+ipc.disconnect("world");
+```
+
+---
+
+##### serve
+
+`ipc.serve(path,callback);`
+
+Used to create local Unix Socket Server or Windows Socket Server to which Clients can bind. The server can `emit` events to specific Client Sockets, or `broadcast` events to all known Client Sockets.
+
+| variable | required | definition                                                                                                                                                                                                                                                                          |
+| -------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| path     | optional | This is the path of the Unix Domain Socket File, if the System is Windows, this will automatically be converted to an appropriate pipe with the same information as the Unix Domain Socket File. If not set this will default to `ipc.config.socketRoot`+`ipc.config.appspace`+`id` |
+| callback | optional | This is a function to be called after the Server has started. This can also be done by binding an event to the start event like `ipc.server.on('start',function(){});`                                                                                                              |
+
+**_examples_** arguments can be omitted so long as they are still in order.
+
+```javascript
+ipc.serve();
+```
+
+or specifying callback
+
+```javascript
+
+    ipc.serve(
+        function(){...}
+    );
+
+```
+
+or specify path
+
+```javascript
+ipc.serve("/tmp/myapp.myservice");
+```
+
+or specifying everything
+
+```javascript
+
+    ipc.serve(
+        '/tmp/myapp.myservice',
+        function(){...}
+    );
+
+```
+
+---
+
+##### serveNet
+
+`serveNet(host,port,UDPType,callback)`
+
+Used to create TCP, TLS or UDP Socket Server to which Clients can bind or other servers can send data to. The server can `emit` events to specific Client Sockets, or `broadcast` events to all known Client Sockets.
+
+| variable | required | definition                                                                                                                                                                                |
+| -------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| host     | optional | If not specified this defaults to the first address in os.networkInterfaces(). For TCP, TLS & UDP servers this is most likely going to be 127.0.0.1 or ::1                                |
+| port     | optional | The port on which the TCP, UDP, or TLS Socket server will be bound, this defaults to 8000 if not specified                                                                                |
+| UDPType  | optional | If set this will create the server as a UDP socket. 'udp4' or 'udp6' are valid values. This defaults to not being set. When using udp6 make sure to specify a valid IPv6 host, like `::1` |
+| callback | optional | Function to be called when the server is created                                                                                                                                          |
+
+**_examples_** arguments can be ommitted solong as they are still in order.
+
+default tcp server
+
+```javascript
+ipc.serveNet();
+```
+
+default udp server
+
+```javascript
+ipc.serveNet("udp4");
+```
+
+or specifying TCP server with callback
+
+```javascript
+
+    ipc.serveNet(
+        function(){...}
+    );
+
+```
+
+or specifying UDP server with callback
+
+```javascript
+
+    ipc.serveNet(
+        'udp4',
+        function(){...}
+    );
+
+```
+
+or specify port
+
+```javascript
+ipc.serveNet(3435);
+```
+
+or specifying everything TCP
+
+```javascript
+
+    ipc.serveNet(
+        'MyMostAwesomeApp.com',
+        3435,
+        function(){...}
+    );
+
+```
+
+or specifying everything UDP
+
+```javascript
+
+    ipc.serveNet(
+        'MyMostAwesomeApp.com',
+        3435,
+        'udp4',
+        function(){...}
+    );
+
+```
+
+---
+
+### IPC Stores and Default Variables
+
+| variable   | definition                                                                                                                                                                                                                 |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ipc.of     | This is where socket connection refrences will be stored when connecting to them as a client via the `ipc.connectTo` or `iupc.connectToNet`. They will be stored based on the ID used to create them, eg : ipc.of.mySocket |
+| ipc.server | This is a refrence to the server created by `ipc.serve` or `ipc.serveNet`                                                                                                                                                  |
+
+---
+
+### IPC Server Methods
+
+| method | definition                                                                  |
+| ------ | --------------------------------------------------------------------------- |
+| start  | start serving need to call `serve` or `serveNet` first to set up the server |
+| stop   | close the server and stop serving                                           |
+
+---
+
+### IPC Events
+
+| event name            | params                   | definition                                                                                                                                                                                      |
+| --------------------- | ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| error                 | err obj                  | triggered when an error has occured                                                                                                                                                             |
+| connect               |                          | triggered when socket connected                                                                                                                                                                 |
+| disconnect            |                          | triggered by client when socket has disconnected from server                                                                                                                                    |
+| socket.disconnected   | socket destroyedSocketID | triggered by server when a client socket has disconnected                                                                                                                                       |
+| destroy               |                          | triggered when socket has been totally destroyed, no further auto retries will happen and all references are gone.                                                                              |
+| data                  | buffer                   | triggered when ipc.config.rawBuffer is true and a message is received.                                                                                                                          |
+| **_your event type_** | **_your event data_**    | triggered when a JSON message is received. The event name will be the type string from your message and the param will be the data object from your message eg : `{ type:'myEvent',data:{a:1}}` |
+
+### Multiple IPC Instances
+
+Sometimes you might need explicit and independent instances of @achrinza/node-ipc. Just for such scenarios we have exposed the core IPC class on the IPC singleton.
+
+```javascript
+const RawIPC = require("@achrinza/node-ipc").IPC;
+const ipc = new RawIPC();
+const someOtherExplicitIPC = new RawIPC();
+
+//OR
+
+const ipc = require("@achrinza/node-ipc");
+const someOtherExplicitIPC = new ipc.IPC();
+
+//setting explicit configs
+
+//keep one silent and the other verbose
+ipc.config.silent = true;
+someOtherExplicitIPC.config.silent = true;
+
+//make one a raw binary and the other json based ipc
+ipc.config.rawBuffer = false;
+
+someOtherExplicitIPC.config.rawBuffer = true;
+someOtherExplicitIPC.config.encoding = "hex";
+```
+
+---
+
+### Basic Examples
+
+You can find [Advanced Examples](https://github.com/RIAEvangelist/@achrinza/node-ipc/tree/master/example) in the examples folder. In the examples you will find more complex demos including multi client examples.
+
+#### Server for Unix Sockets, Windows Sockets & TCP Sockets
+
+The server is the process keeping a socket for IPC open. Multiple sockets can connect to this server and talk to it. It can also broadcast to all clients or emit to a specific client. This is the most basic example which will work for local Unix and Windows Sockets as well as local or remote network TCP Sockets.
+
+```javascript
+var ipc = require("@achrinza/node-ipc");
+
+ipc.config.id = "world";
+ipc.config.retry = 1500;
+
+ipc.serve(function () {
+  ipc.server.on("message", function (data, socket) {
+    ipc.log("got a message : ".debug, data);
+    ipc.server.emit(
+      socket,
+      "message", //this can be anything you want so long as
+      //your client knows.
+      data + " world!"
+    );
+  });
+  ipc.server.on("socket.disconnected", function (socket, destroyedSocketID) {
+    ipc.log("client " + destroyedSocketID + " has disconnected!");
+  });
+});
+
+ipc.server.start();
+```
+
+#### Client for Unix Sockets & TCP Sockets
+
+The client connects to the servers socket for Inter Process Communication. The socket will receive events emitted to it specifically as well as events which are broadcast out on the socket by the server. This is the most basic example which will work for both local Unix Sockets and local or remote network TCP Sockets.
+
+```javascript
+var ipc = require("@achrinza/node-ipc");
+
+ipc.config.id = "hello";
+ipc.config.retry = 1500;
+
+ipc.connectTo("world", function () {
+  ipc.of.world.on("connect", function () {
+    ipc.log("## connected to world ##".rainbow, ipc.config.delay);
+    ipc.of.world.emit(
+      "message", //any event or message type your server listens for
+      "hello"
+    );
+  });
+  ipc.of.world.on("disconnect", function () {
+    ipc.log("disconnected from world".notice);
+  });
+  ipc.of.world.on(
+    "message", //any event or message type your server listens for
+    function (data) {
+      ipc.log("got a message from world : ".debug, data);
+    }
+  );
+});
+```
+
+#### Server & Client for UDP Sockets
+
+UDP Sockets are different than Unix, Windows & TCP Sockets because they must be bound to a unique port on their machine to receive messages. For example, A TCP, Unix, or Windows Socket client could just connect to a separate TCP, Unix, or Windows Socket sever. That client could then exchange, both send and receive, data on the servers port or location. UDP Sockets can not do this. They must bind to a port to receive or send data.
+
+This means a UDP Client and Server are the same thing because in order to receive data, a UDP Socket must have its own port to receive data on, and only one process can use this port at a time. It also means that in order to `emit` or `broadcast` data the UDP server will need to know the host and port of the Socket it intends to broadcast the data to.
+
+This is the most basic example which will work for both local and remote UDP Sockets.
+
+##### UDP Server 1 - "World"
+
+```javascript
+var ipc = require("../../../@achrinza/node-ipc");
+
+ipc.config.id = "world";
+ipc.config.retry = 1500;
+
+ipc.serveNet("udp4", function () {
+  console.log(123);
+  ipc.server.on("message", function (data, socket) {
+    ipc.log(
+      "got a message from ".debug,
+      data.from.variable,
+      " : ".debug,
+      data.message.variable
+    );
+    ipc.server.emit(socket, "message", {
+      from: ipc.config.id,
+      message: data.message + " world!",
+    });
+  });
+
+  console.log(ipc.server);
+});
+
+ipc.server.start();
+```
+
+##### UDP Server 2 - "Hello"
+
+_note_ we set the port here to 8001 because the world server is already using the default ipc.config.networkPort of 8000. So we can not bind to 8000 while world is using it.
+
+```javascript
+ipc.config.id = "hello";
+ipc.config.retry = 1500;
+
+ipc.serveNet(8001, "udp4", function () {
+  ipc.server.on("message", function (data) {
+    ipc.log("got Data");
+    ipc.log(
+      "got a message from ".debug,
+      data.from.variable,
+      " : ".debug,
+      data.message.variable
+    );
+  });
+  ipc.server.emit(
+    {
+      address: "127.0.0.1", //any hostname will work
+      port: ipc.config.networkPort,
+    },
+    "message",
+    {
+      from: ipc.config.id,
+      message: "Hello",
+    }
+  );
+});
+
+ipc.server.start();
+```
+
+#### Raw Buffer or Binary Sockets
+
+Binary or Buffer sockets can be used with any of the above socket types, however the way data events are emit is **_slightly_** different. These may come in handy if working with embedded systems or C / C++ processes. You can even make sure to match C or C++ string typing.
+
+When setting up a rawBuffer socket you must specify it as such :
+
+```javascript
+ipc.config.rawBuffer = true;
+```
+
+You can also specify its encoding type. The default is `utf8`
+
+```javascript
+ipc.config.encoding = "utf8";
+```
+
+emit string buffer :
+
+```javascript
+//server
+ipc.server.emit(socket, "hello");
+
+//client
+ipc.of.world.emit("hello");
+```
+
+emit byte array buffer :
+
+```javascript
+//hex encoding may work best for this.
+ipc.config.encoding = "hex";
+
+//server
+ipc.server.emit(socket, [10, 20, 30]);
+
+//client
+ipc.server.emit([10, 20, 30]);
+```
+
+emit binary or hex array buffer, this is best for real time data transfer, especially whan connecting to C or C++ processes, or embedded systems :
+
+```javascript
+ipc.config.encoding = "hex";
+
+//server
+ipc.server.emit(socket, [0x05, 0x6d, 0x5c]);
+
+//client
+ipc.server.emit([0x05, 0x6d, 0x5c]);
+```
+
+Writing explicit buffers, int types, doubles, floats etc. as well as big endian and little endian data to raw buffer nostly valuable when connecting to C or C++ processes, or embedded systems (see more detailed info on buffers as well as UInt, Int, double etc. here)[https://nodejs.org/api/buffer.html]:
+
+```javascript
+ipc.config.encoding = "hex";
+
+//make a 6 byte buffer for example
+const myBuffer = Buffer.alloc(6).fill(0);
+
+//fill the first 2 bytes with a 16 bit (2 byte) short unsigned int
+
+//write a UInt16 (2 byte or short) as Big Endian
+myBuffer.writeUInt16BE(
+  2, //value to write
+  0 //offset in bytes
+);
+//OR
+myBuffer.writeUInt16LE(0x2, 0);
+//OR
+myBuffer.writeUInt16LE(0x02, 0);
+
+//fill the remaining 4 bytes with a 32 bit (4 byte) long unsigned int
+
+//write a UInt32 (4 byte or long) as Big Endian
+myBuffer.writeUInt32BE(
+  16772812, //value to write
+  2 //offset in bytes
+);
+//OR
+myBuffer.writeUInt32BE(0xffeecc, 0);
+
+//server
+ipc.server.emit(socket, myBuffer);
+
+//client
+ipc.server.emit(myBuffer);
+```
+
+#### Server with the `cluster` Module
+
+`@achrinza/node-ipc` can be used with Node.js' [cluster module](https://nodejs.org/api/cluster.html) to provide the ability to have multiple readers for a single socket. Doing so simply requires you to set the `unlink` property in the config to `false` and take care of unlinking the socket path in the master process:
+
+##### Server
+
+```javascript
+const fs = require("fs");
+const ipc = require("../../../@achrinza/node-ipc");
+const cpuCount = require("os").cpus().length;
+const cluster = require("cluster");
+const socketPath = "/tmp/ipc.sock";
+
+ipc.config.unlink = false;
+
+if (cluster.isMaster) {
+  if (fs.existsSync(socketPath)) {
+    fs.unlinkSync(socketPath);
+  }
+
+  for (let i = 0; i < cpuCount; i++) {
+    cluster.fork();
+  }
+} else {
+  ipc.serve(socketPath, function () {
+    ipc.server.on("currentDate", function (data, socket) {
+      console.log(`pid ${process.pid} got: `, data);
+    });
+  });
+
+  ipc.server.start();
+  console.log(`pid ${process.pid} listening on ${socketPath}`);
+}
+```
+
+##### Client
+
+```javascript
+const fs = require("fs");
+const ipc = require("../../@achrinza/node-ipc");
+
+const socketPath = "/tmp/ipc.sock";
+
+//loop forever so you can see the pid of the cluster sever change in the logs
+setInterval(function () {
+  ipc.connectTo("world", socketPath, connecting);
+}, 2000);
+
+function connecting(socket) {
+  ipc.of.world.on("connect", function () {
+    ipc.of.world.emit("currentDate", {
+      message: new Date().toISOString(),
+    });
+    ipc.disconnect("world");
+  });
+}
+```
+
+#### Licensed under MIT license
+
+See the [MIT license](https://github.com/RIAEvangelist/@achrinza/node-ipc/blob/master/license) file.

node_modules/@achrinza/node-ipc/dao/client.js

@@ -0,0 +1,256 @@
+'use strict';
+
+const net = require('net'),
+    tls = require('tls'),
+    EventParser = require('../entities/EventParser.js'),
+    Message = require('js-message'),
+    fs = require('fs'),
+    Queue = require('@node-ipc/js-queue'),
+    Events = require('event-pubsub');
+
+let eventParser = new EventParser();
+
+class Client extends Events{
+    constructor(config,log){
+        super();
+        Object.assign(
+            this,
+            {
+                Client  : Client,
+                config  : config,
+                queue   : new Queue,
+                socket  : false,
+                connect : connect,
+                emit    : emit,
+                log     : log,
+                retriesRemaining:config.maxRetries||0,
+                explicitlyDisconnected: false
+            }
+        );
+
+        eventParser=new EventParser(this.config);
+    }
+}
+
+function emit(type,data){
+    this.log('dispatching event to ', this.id, this.path, ' : ', type, ',', data);
+
+    let message=new Message;
+    message.type=type;
+    message.data=data;
+
+    if(this.config.rawBuffer){
+        message=Buffer.from(type,this.config.encoding);
+    }else{
+        message=eventParser.format(message);
+    }
+
+    if(!this.config.sync){
+        this.socket.write(message);
+        return;
+    }
+
+    this.queue.add(
+        syncEmit.bind(this,message)
+    );
+}
+
+function syncEmit(message){
+    this.log('dispatching event to ', this.id, this.path, ' : ', message);
+    this.socket.write(message);
+}
+
+function connect(){
+    //init client object for scope persistance especially inside of socket events.
+    let client=this;
+
+    client.log('requested connection to ', client.id, client.path);
+    if(!this.path){
+        client.log('\n\n######\nerror: ', client.id ,' client has not specified socket path it wishes to connect to.');
+        return;
+    }
+
+    const options={};
+
+    if(!client.port){
+        client.log('Connecting client on Unix Socket :', client.path);
+
+        options.path=client.path;
+
+        if (process.platform ==='win32' && !client.path.startsWith('\\\\.\\pipe\\')){
+            options.path = options.path.replace(/^\//, '');
+            options.path = options.path.replace(/\//g, '-');
+            options.path= `\\\\.\\pipe\\${options.path}`;
+        }
+
+        client.socket = net.connect(options);
+    }else{
+        options.host=client.path;
+        options.port=client.port;
+
+        if(client.config.interface.localAddress){
+          options.localAddress=client.config.interface.localAddress;
+        }
+
+        if(client.config.interface.localPort){
+          options.localPort=client.config.interface.localPort;
+        }
+
+        if(client.config.interface.family){
+          options.family=client.config.interface.family;
+        }
+
+        if(client.config.interface.hints){
+          options.hints=client.config.interface.hints;
+        }
+
+        if(client.config.interface.lookup){
+          options.lookup=client.config.interface.lookup;
+        }
+
+        if(!client.config.tls){
+            client.log('Connecting client via TCP to', options);
+            client.socket = net.connect(options);
+        }else{
+            client.log('Connecting client via TLS to', client.path ,client.port,client.config.tls);
+            if(client.config.tls.private){
+                client.config.tls.key=fs.readFileSync(client.config.tls.private);
+            }
+            if(client.config.tls.public){
+                client.config.tls.cert=fs.readFileSync(client.config.tls.public);
+            }
+            if(client.config.tls.trustedConnections){
+                if(typeof client.config.tls.trustedConnections === 'string'){
+                    client.config.tls.trustedConnections=[client.config.tls.trustedConnections];
+                }
+                client.config.tls.ca=[];
+                for(let i=0; i<client.config.tls.trustedConnections.length; i++){
+                    client.config.tls.ca.push(
+                        fs.readFileSync(client.config.tls.trustedConnections[i])
+                    );
+                }
+            }
+
+            Object.assign(client.config.tls,options);
+
+            client.socket = tls.connect(
+                client.config.tls
+            );
+        }
+    }
+
+    client.socket.setEncoding(this.config.encoding);
+
+    client.socket.on(
+        'error',
+        function(err){
+            client.log('\n\n######\nerror: ', err);
+            client.publish('error', err);
+
+        }
+    );
+
+    client.socket.on(
+        'connect',
+        function connectionMade(){
+            client.publish('connect');
+            client.retriesRemaining=client.config.maxRetries;
+            client.log('retrying reset');
+        }
+    );
+
+    client.socket.on(
+        'close',
+        function connectionClosed(){
+            client.log('connection closed' ,client.id , client.path,
+            client.retriesRemaining, 'tries remaining of', client.config.maxRetries
+        );
+
+            if(
+                client.config.stopRetrying ||
+                client.retriesRemaining<1 ||
+                client.explicitlyDisconnected
+
+            ){
+                client.publish('disconnect');
+                client.log(
+                    (client.config.id),
+                    'exceeded connection rety amount of',
+                    ' or stopRetrying flag set.'
+                );
+
+                client.socket.destroy();
+                client.publish('destroy');
+                client=undefined;
+
+                return;
+            }
+
+            setTimeout(
+                function retryTimeout(){
+                    if (client.explicitlyDisconnected) {
+                        return;
+                    }
+                    client.retriesRemaining--;
+                    client.connect();
+                }.bind(null,client),
+                client.config.retry
+            );
+
+            client.publish('disconnect');
+        }
+    );
+
+    client.socket.on(
+        'data',
+        function(data) {
+            client.log('## received events ##');
+            if(client.config.rawBuffer){
+                client.publish(
+                   'data',
+                   Buffer.from(data,client.config.encoding)
+                );
+                if(!client.config.sync){
+                    return;
+                }
+
+                client.queue.next();
+                return;
+            }
+
+            if(!this.ipcBuffer){
+                this.ipcBuffer='';
+            }
+
+            data=(this.ipcBuffer+=data);
+
+            if(data.slice(-1)!=eventParser.delimiter || data.indexOf(eventParser.delimiter) == -1){
+                client.log('Messages are large, You may want to consider smaller messages.');
+                return;
+            }
+
+            this.ipcBuffer='';
+
+            const events = eventParser.parse(data);
+            const eCount = events.length;
+            for(let i=0; i<eCount; i++){
+                let message=new Message;
+                message.load(events[i]);
+
+                client.log('detected event', message.type, message.data);
+                client.publish(
+                   message.type,
+                   message.data
+                );
+            }
+
+            if(!client.config.sync){
+                return;
+            }
+
+            client.queue.next();
+        }
+    );
+}
+
+module.exports=Client;

node_modules/@achrinza/node-ipc/dao/socketServer.js

@@ -0,0 +1,399 @@
+'use strict';
+
+const net = require('net'),
+    tls = require('tls'),
+    fs = require('fs'),
+    dgram = require('dgram'),
+    EventParser = require('../entities/EventParser.js'),
+    Message = require('js-message'),
+    Events = require('event-pubsub');
+
+let eventParser = new EventParser();
+
+class Server extends Events{
+    constructor(path,config,log,port){
+        super();
+        Object.assign(
+            this,
+            {
+                config          : config,
+                path            : path,
+                port            : port,
+                udp4            : false,
+                udp6            : false,
+                log             : log,
+                server          : false,
+                sockets         : [],
+                emit            : emit,
+                broadcast       : broadcast
+            }
+        );
+
+        eventParser=new EventParser(this.config);
+
+        this.on(
+            'close',
+            serverClosed.bind(this)
+        );
+    }
+
+    onStart(socket){
+        this.trigger(
+            'start',
+            socket
+        );
+    }
+
+    stop(){
+        this.server.close();
+    }
+
+    start(){
+        if(!this.path){
+            this.log('Socket Server Path not specified, refusing to start');
+            return;
+        }
+
+        if(this.config.unlink){
+            fs.unlink(
+                this.path,
+                startServer.bind(this)
+            );
+        }else{
+            startServer.bind(this)();
+        }
+    }
+}
+
+function emit(socket, type, data){
+    this.log('dispatching event to socket', ' : ', type, data);
+
+    let message=new Message;
+    message.type=type;
+    message.data=data;
+
+    if(this.config.rawBuffer){
+        this.log(this.config.encoding)
+        message=Buffer.from(type,this.config.encoding);
+    }else{
+        message=eventParser.format(message);
+    }
+
+    if(this.udp4 || this.udp6){
+
+        if(!socket.address || !socket.port){
+            this.log('Attempting to emit to a single UDP socket without supplying socket address or port. Redispatching event as broadcast to all connected sockets');
+            this.broadcast(type,data);
+            return;
+        }
+
+        this.server.write(
+            message,
+            socket
+        );
+        return;
+    }
+
+    socket.write(message);
+}
+
+function broadcast(type,data){
+    this.log('broadcasting event to all known sockets listening to ', this.path,' : ', ((this.port)?this.port:''), type, data);
+    let message=new Message;
+    message.type=type;
+    message.data=data;
+
+    if(this.config.rawBuffer){
+        message=Buffer.from(type,this.config.encoding);
+    }else{
+        message=eventParser.format(message);
+    }
+
+    if(this.udp4 || this.udp6){
+        for(let i=1, count=this.sockets.length; i<count; i++){
+            this.server.write(message,this.sockets[i]);
+        }
+    }else{
+        for(let i=0, count=this.sockets.length; i<count; i++){
+            this.sockets[i].write(message);
+        }
+    }
+}
+
+function serverClosed(){
+    for(let i=0, count=this.sockets.length; i<count; i++){
+        let socket=this.sockets[i];
+        let destroyedSocketId=false;
+
+        if(socket){
+            if(socket.readable){
+                continue;
+            }
+        }
+
+        if(socket.id){
+            destroyedSocketId=socket.id;
+        }
+
+        this.log('socket disconnected',destroyedSocketId.toString());
+
+        if(socket && socket.destroy){
+            socket.destroy();
+        }
+
+        this.sockets.splice(i,1);
+
+        this.publish('socket.disconnected', socket, destroyedSocketId);
+
+        return;
+    }
+}
+
+function gotData(socket,data,UDPSocket){
+    let sock=((this.udp4 || this.udp6)? UDPSocket : socket);
+    if(this.config.rawBuffer){
+        data=Buffer.from(data,this.config.encoding);
+        this.publish(
+            'data',
+            data,
+            sock
+        );
+        return;
+    }
+
+    if(!sock.ipcBuffer){
+        sock.ipcBuffer='';
+    }
+
+    data=(sock.ipcBuffer+=data);
+
+    if(data.slice(-1)!=eventParser.delimiter || data.indexOf(eventParser.delimiter) == -1){
+        this.log('Messages are large, You may want to consider smaller messages.');
+        return;
+    }
+
+    sock.ipcBuffer='';
+
+    data=eventParser.parse(data);
+
+    while(data.length>0){
+        let message=new Message;
+        message.load(data.shift());
+
+        // Only set the sock id if it is specified.
+        if (message.data && message.data.id){
+            sock.id=message.data.id;
+        }
+
+        this.log('received event of : ',message.type,message.data);
+
+        this.publish(
+            message.type,
+            message.data,
+            sock
+        );
+    }
+}
+
+function socketClosed(socket){
+    this.publish(
+        'close',
+        socket
+    );
+}
+
+function serverCreated(socket) {
+    this.sockets.push(socket);
+
+    if(socket.setEncoding){
+        socket.setEncoding(this.config.encoding);
+    }
+
+    this.log('## socket connection to server detected ##');
+    socket.on(
+        'close',
+        socketClosed.bind(this)
+    );
+
+    socket.on(
+        'error',
+        function(err){
+            this.log('server socket error',err);
+
+            this.publish('error',err);
+        }.bind(this)
+    );
+
+    socket.on(
+        'data',
+        gotData.bind(this,socket)
+    );
+
+    socket.on(
+        'message',
+        function(msg,rinfo) {
+            if (!rinfo){
+                return;
+            }
+
+            this.log('Received UDP message from ', rinfo.address, rinfo.port);
+            let data;
+
+            if(this.config.rawSocket){
+                data=Buffer.from(msg,this.config.encoding);
+            }else{
+                data=msg.toString();
+            }
+            socket.emit('data',data,rinfo);
+        }.bind(this)
+    );
+
+    this.publish(
+        'connect',
+        socket
+    );
+
+    if(this.config.rawBuffer){
+        return;
+    }
+}
+
+function startServer() {
+    this.log(
+        'starting server on ',this.path,
+        ((this.port)?`:${this.port}`:'')
+    );
+
+    if(!this.udp4 && !this.udp6){
+        this.log('starting TLS server',this.config.tls);
+        if(!this.config.tls){
+            this.server=net.createServer(
+                serverCreated.bind(this)
+            );
+        }else{
+            startTLSServer.bind(this)();
+        }
+    }else{
+        this.server=dgram.createSocket(
+            ((this.udp4)? 'udp4':'udp6')
+        );
+        this.server.write=UDPWrite.bind(this);
+        this.server.on(
+            'listening',
+            function UDPServerStarted() {
+                serverCreated.bind(this)(this.server);
+            }.bind(this)
+        );
+    }
+
+    this.server.on(
+        'error',
+        function(err){
+            this.log('server error',err);
+
+            this.publish(
+                'error',
+                err
+            );
+        }.bind(this)
+    );
+
+    this.server.maxConnections=this.config.maxConnections;
+
+    if(!this.port){
+        this.log('starting server as', 'Unix || Windows Socket');
+        if (process.platform ==='win32'){
+            this.path = this.path.replace(/^\//, '');
+            this.path = this.path.replace(/\//g, '-');
+            this.path= `\\\\.\\pipe\\${this.path}`;
+        }
+
+        this.server.listen({
+            path: this.path,
+            readableAll: this.config.readableAll,
+            writableAll: this.config.writableAll
+        }, this.onStart.bind(this));
+
+        return;
+    }
+
+    if(!this.udp4 && !this.udp6){
+        this.log('starting server as', (this.config.tls?'TLS':'TCP'));
+        this.server.listen(
+            this.port,
+            this.path,
+            this.onStart.bind(this)
+        );
+        return;
+    }
+
+    this.log('starting server as',((this.udp4)? 'udp4':'udp6'));
+
+    this.server.bind(
+        this.port,
+        this.path
+    );
+
+    this.onStart(
+        {
+            address : this.path,
+            port    : this.port
+        }
+    );
+}
+
+function startTLSServer(){
+    this.log('starting TLS server',this.config.tls);
+    if(this.config.tls.private){
+        this.config.tls.key=fs.readFileSync(this.config.tls.private);
+    }else{
+        this.config.tls.key=fs.readFileSync(`${__dirname}/../local-node-ipc-certs/private/server.key`);
+    }
+    if(this.config.tls.public){
+        this.config.tls.cert=fs.readFileSync(this.config.tls.public);
+    }else{
+        this.config.tls.cert=fs.readFileSync(`${__dirname}/../local-node-ipc-certs/server.pub`);
+    }
+    if(this.config.tls.dhparam){
+        this.config.tls.dhparam=fs.readFileSync(this.config.tls.dhparam);
+    }
+    if(this.config.tls.trustedConnections){
+        if(typeof this.config.tls.trustedConnections === 'string'){
+            this.config.tls.trustedConnections=[this.config.tls.trustedConnections];
+        }
+        this.config.tls.ca=[];
+        for(let i=0; i<this.config.tls.trustedConnections.length; i++){
+            this.config.tls.ca.push(
+                fs.readFileSync(this.config.tls.trustedConnections[i])
+            );
+        }
+    }
+    this.server=tls.createServer(
+        this.config.tls,
+        serverCreated.bind(this)
+    );
+}
+
+function UDPWrite(message,socket){
+    let data=Buffer.from(message, this.config.encoding);
+    this.server.send(
+        data,
+        0,
+        data.length,
+        socket.port,
+        socket.address,
+        function(err, bytes) {
+            if(err){
+                this.log('error writing data to socket',err);
+                this.publish(
+                    'error',
+                    function(err){
+                        this.publish('error',err);
+                    }
+                );
+            }
+        }
+    );
+}
+
+module.exports=Server;

node_modules/@achrinza/node-ipc/entities/Defaults.js

@@ -0,0 +1,83 @@
+'use strict';
+
+/*eslint no-magic-numbers: ["error", { "ignore": [ 0] }]*/
+
+/**
+ * @module entities
+ */
+
+const os = require('os');
+
+/**
+ * @class Defaults
+ * @description Defaults Entity
+ */
+class Defaults{
+
+    /**
+     * @constructor
+     * @method constructor
+     * @return {void}
+     */
+    constructor(){
+
+        this.appspace='app.';
+        this.socketRoot='/tmp/';
+        this.id=os.hostname();
+
+        this.encoding='utf8';
+        this.rawBuffer=false;
+        this.sync=false;
+        this.unlink=true;
+
+        this.delimiter='\f';
+
+        this.silent=false;
+        this.logDepth=5;
+        this.logInColor=true;
+        this.logger=console.log.bind(console);
+
+        this.maxConnections=100;
+        this.retry=500;
+        this.maxRetries=Infinity;
+        this.stopRetrying=false;
+
+        this.IPType=getIPType();
+        this.tls=false;
+        this.networkHost = (this.IPType == 'IPv6') ? '::1' : '127.0.0.1';
+        this.networkPort = 8000;
+
+        this.readableAll = false;
+        this.writableAll = false;
+
+        this.interface={
+            localAddress:false,
+            localPort:false,
+            family:false,
+            hints:false,
+            lookup:false
+        }
+    }
+}
+
+/**
+ * method to get ip type
+ *
+ * @method getIPType
+ * @return {string} ip type
+ */
+function getIPType() {
+    const networkInterfaces = os.networkInterfaces();
+    let IPType = '';
+    if (networkInterfaces
+        && Array.isArray(networkInterfaces)
+        && networkInterfaces.length > 0) {
+        // getting the family of first network interface available
+        IPType = networkInterfaces [
+            Object.keys( networkInterfaces )[0]
+        ][0].family;
+    }
+    return IPType;
+}
+
+module.exports=Defaults;

node_modules/@achrinza/node-ipc/entities/EventParser.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Defaults = require('./Defaults.js');
+
+class Parser{
+  constructor(config){
+    if(!config){
+      config=new Defaults;
+    }
+    this.delimiter=config.delimiter;
+  }
+
+  format(message){
+    if(!message.data && message.data!==false && message.data!==0){
+        message.data={};
+    }
+    if(message.data['_maxListeners']){
+        message.data={};
+    }
+
+    message=message.JSON+this.delimiter;
+    return message;
+  }
+
+  parse(data){
+    let events=data.split(this.delimiter);
+    events.pop();
+    return events;
+  }
+}
+
+module.exports=Parser;

node_modules/@achrinza/node-ipc/licence

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Brandon Nozaki Miller
+
+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/@achrinza/node-ipc/local-node-ipc-certs/client.pub

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIID+zCCAuOgAwIBAgIJAKUVVihb00q/MA0GCSqGSIb3DQEBCwUAMIGTMQswCQYD
+VQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNVGhvdXNhbmQg
+T2FrczEUMBIGA1UECgwLRGlnaU5vdyBpbmMxDDAKBgNVBAsMA1JuRDEQMA4GA1UE
+AwwHRGlnaU5vdzEhMB8GCSqGSIb3DQEJARYSYnJhbmRvbkBkaWdpbm93Lml0MB4X
+DTE2MDkxMDIxNTk0NloXDTE3MDkxMDIxNTk0NlowgZMxCzAJBgNVBAYTAlVTMRMw
+EQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1UaG91c2FuZCBPYWtzMRQwEgYD
+VQQKDAtEaWdpTm93IGluYzEMMAoGA1UECwwDUm5EMRAwDgYDVQQDDAdEaWdpTm93
+MSEwHwYJKoZIhvcNAQkBFhJicmFuZG9uQGRpZ2lub3cuaXQwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQCrNHWbbaMvlyK3ENevYeb+y5gWtOf5T8HS5k0E
+7fub8jU4f4j7poxhvAYgaMeuUUigR3YZOSGc3N8yXFLFrrU8WQyK7KAwWcyUvqWK
+7mvj6dQANtnGvnkt+q2pjMO1nxVPuXgov0GIaWHc7gL4rfuohBct6lbxOXaUxWHe
+FbQoWlqxs+lYaNMIMn7PgNwPDINoJeADKkVFXlNG9/YnT5j7TQegmzFxBBdko8EN
+W8Y91RG+/YHhtEPyKeQGrm3Ntl85JokT/GUsUUfUjXkuKrJsrLhwMVLPD23ucy7J
+zBcec0Vgpu99Bks51w/do6f80rIlAhI+iesZlPJjpDIYhmEXAgMBAAGjUDBOMB0G
+A1UdDgQWBBSOFk2HqjDTBqUuxOZvW0npEVRxCjAfBgNVHSMEGDAWgBSOFk2HqjDT
+BqUuxOZvW0npEVRxCjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQAz
+FYxwSSbJ6wOX4yRNUU3XW0iGzoHwMtJhbYe3WRNLHRzHaRC+hg5VgBDEBcC9aYNB
++dfNXfrQ+2uooe082twGqSyGVFYEytsTrhlzxvftunF0rMLXfI8wHkiqxWSupPYM
+nn2gFEVrJIpvyBnL6tAQpVRpn5aCBdQnmSApZVvDhogac0tQMH9GrjizrmDWtMoH
+V4zRA0UGzHfQoj+YKex7e9rPdDEx+mah0Ol1fzlmkZlOFInXJQ+t4F11bNNdHWje
+7lyi0pFB9egtDUxwoHkzniMvef94cCIRsph+Vjisf7OQxnx65s+aPYcjrba+Kks3
+58ANS3VkbXXzB3MeNGoB
+-----END CERTIFICATE-----

node_modules/@achrinza/node-ipc/local-node-ipc-certs/openssl.cnf

@@ -0,0 +1,352 @@
+#
+# OpenSSL example configuration file.
+# This is mostly being used for generation of certificate requests.
+#
+
+# This definition stops the following lines choking if HOME isn't
+# defined.
+HOME			= .
+RANDFILE		= $ENV::HOME/.rnd
+
+# Extra OBJECT IDENTIFIER info:
+#oid_file		= $ENV::HOME/.oid
+oid_section		= new_oids
+
+# To use this configuration file with the "-extfile" option of the
+# "openssl x509" utility, name here the section containing the
+# X.509v3 extensions to use:
+# extensions		=
+# (Alternatively, use a configuration file that has only
+# X.509v3 extensions in its main [= default] section.)
+
+[ new_oids ]
+
+# We can add new OIDs in here for use by 'ca', 'req' and 'ts'.
+# Add a simple OID like this:
+# testoid1=1.2.3.4
+# Or use config file substitution like this:
+# testoid2=${testoid1}.5.6
+
+# Policies used by the TSA examples.
+tsa_policy1 = 1.2.3.4.1
+tsa_policy2 = 1.2.3.4.5.6
+tsa_policy3 = 1.2.3.4.5.7
+
+####################################################################
+[ ca ]
+default_ca	= CA_default		# The default ca section
+
+####################################################################
+[ CA_default ]
+
+dir		= ./demoCA		# Where everything is kept
+certs		= $dir/certs		# Where the issued certs are kept
+crl_dir		= $dir/crl		# Where the issued crl are kept
+database	= $dir/index.txt	# database index file.
+#unique_subject	= no			# Set to 'no' to allow creation of
+					# several ctificates with same subject.
+new_certs_dir	= $dir/newcerts		# default place for new certs.
+
+certificate	= $dir/cacert.pem 	# The CA certificate
+serial		= $dir/serial 		# The current serial number
+crlnumber	= $dir/crlnumber	# the current crl number
+					# must be commented out to leave a V1 CRL
+crl		= $dir/crl.pem 		# The current CRL
+private_key	= $dir/private/cakey.pem# The private key
+RANDFILE	= $dir/private/.rand	# private random number file
+
+x509_extensions	= usr_cert		# The extentions to add to the cert
+
+# Comment out the following two lines for the "traditional"
+# (and highly broken) format.
+name_opt 	= ca_default		# Subject Name options
+cert_opt 	= ca_default		# Certificate field options
+
+# Extension copying option: use with caution.
+# copy_extensions = copy
+
+# Extensions to add to a CRL. Note: Netscape communicator chokes on V2 CRLs
+# so this is commented out by default to leave a V1 CRL.
+# crlnumber must also be commented out to leave a V1 CRL.
+# crl_extensions	= crl_ext
+
+default_days	= 365			# how long to certify for
+default_crl_days= 30			# how long before next CRL
+default_md	= default		# use public key default MD
+preserve	= no			# keep passed DN ordering
+
+# A few difference way of specifying how similar the request should look
+# For type CA, the listed attributes must be the same, and the optional
+# and supplied fields are just that :-)
+policy		= policy_match
+
+# For the CA policy
+[ policy_match ]
+countryName		= match
+stateOrProvinceName	= match
+organizationName	= match
+organizationalUnitName	= optional
+commonName		= supplied
+emailAddress		= optional
+
+# For the 'anything' policy
+# At this point in time, you must list all acceptable 'object'
+# types.
+[ policy_anything ]
+countryName		= optional
+stateOrProvinceName	= optional
+localityName		= optional
+organizationName	= optional
+organizationalUnitName	= optional
+commonName		= supplied
+emailAddress		= optional
+
+####################################################################
+[ req ]
+default_bits		= 2048
+default_keyfile 	= privkey.pem
+distinguished_name	= req_distinguished_name
+attributes		= req_attributes
+x509_extensions	= v3_ca	# The extentions to add to the self signed cert
+
+# Passwords for private keys if not present they will be prompted for
+# input_password = secret
+# output_password = secret
+
+# This sets a mask for permitted string types. There are several options.
+# default: PrintableString, T61String, BMPString.
+# pkix	 : PrintableString, BMPString (PKIX recommendation before 2004)
+# utf8only: only UTF8Strings (PKIX recommendation after 2004).
+# nombstr : PrintableString, T61String (no BMPStrings or UTF8Strings).
+# MASK:XXXX a literal mask value.
+# WARNING: ancient versions of Netscape crash on BMPStrings or UTF8Strings.
+string_mask = utf8only
+
+req_extensions = v3_req # The extensions to add to a certificate request
+
+[ req_distinguished_name ]
+countryName			= Country Name (2 letter code)
+countryName_default		= AU
+countryName_min			= 2
+countryName_max			= 2
+
+stateOrProvinceName		= State or Province Name (full name)
+stateOrProvinceName_default	= Some-State
+
+localityName			= Locality Name (eg, city)
+
+0.organizationName		= Organization Name (eg, company)
+0.organizationName_default	= Internet Widgits Pty Ltd
+
+# we can do this but it is not needed normally :-)
+#1.organizationName		= Second Organization Name (eg, company)
+#1.organizationName_default	= World Wide Web Pty Ltd
+
+organizationalUnitName		= Organizational Unit Name (eg, section)
+#organizationalUnitName_default	=
+
+commonName			= Common Name (e.g. server FQDN or YOUR name)
+commonName_max			= 64
+
+emailAddress			= Email Address
+emailAddress_max		= 64
+
+# SET-ex3			= SET extension number 3
+
+[ req_attributes ]
+challengePassword		= A challenge password
+challengePassword_min		= 4
+challengePassword_max		= 20
+
+unstructuredName		= An optional company name
+
+[ usr_cert ]
+
+# These extensions are added when 'ca' signs a request.
+
+# This goes against PKIX guidelines but some CAs do it and some software
+# requires this to avoid interpreting an end user certificate as a CA.
+
+basicConstraints=CA:FALSE
+
+# Here are some examples of the usage of nsCertType. If it is omitted
+# the certificate can be used for anything *except* object signing.
+
+# This is OK for an SSL server.
+# nsCertType			= server
+
+# For an object signing certificate this would be used.
+# nsCertType = objsign
+
+# For normal client use this is typical
+# nsCertType = client, email
+
+# and for everything including object signing:
+# nsCertType = client, email, objsign
+
+# This is typical in keyUsage for a client certificate.
+# keyUsage = nonRepudiation, digitalSignature, keyEncipherment
+
+# This will be displayed in Netscape's comment listbox.
+nsComment			= "OpenSSL Generated Certificate"
+
+# PKIX recommendations harmless if included in all certificates.
+subjectKeyIdentifier=hash
+authorityKeyIdentifier=keyid,issuer
+
+# This stuff is for subjectAltName and issuerAltname.
+# Import the email address.
+# subjectAltName=email:copy
+# An alternative to produce certificates that aren't
+# deprecated according to PKIX.
+# subjectAltName=email:move
+
+# Copy subject details
+# issuerAltName=issuer:copy
+
+#nsCaRevocationUrl		= http://www.domain.dom/ca-crl.pem
+#nsBaseUrl
+#nsRevocationUrl
+#nsRenewalUrl
+#nsCaPolicyUrl
+#nsSslServerName
+
+# This is required for TSA certificates.
+# extendedKeyUsage = critical,timeStamping
+
+[ v3_req ]
+
+subjectAltName="DNS:localhost,IP:127.0.0.1"
+
+# Extensions to add to a certificate request
+
+basicConstraints = CA:FALSE
+keyUsage = nonRepudiation, digitalSignature, keyEncipherment
+
+[ v3_ca ]
+
+
+# Extensions for a typical CA
+
+
+# PKIX recommendation.
+
+subjectKeyIdentifier=hash
+
+authorityKeyIdentifier=keyid:always,issuer
+
+# This is what PKIX recommends but some broken software chokes on critical
+# extensions.
+#basicConstraints = critical,CA:true
+# So we do this instead.
+basicConstraints = CA:true
+
+# Key usage: this is typical for a CA certificate. However since it will
+# prevent it being used as an test self-signed certificate it is best
+# left out by default.
+# keyUsage = cRLSign, keyCertSign
+
+# Some might want this also
+# nsCertType = sslCA, emailCA
+
+# Include email address in subject alt name: another PKIX recommendation
+# subjectAltName=email:copy
+# Copy issuer details
+# issuerAltName=issuer:copy
+
+# DER hex encoding of an extension: beware experts only!
+# obj=DER:02:03
+# Where 'obj' is a standard or added object
+# You can even override a supported extension:
+# basicConstraints= critical, DER:30:03:01:01:FF
+
+[ crl_ext ]
+
+# CRL extensions.
+# Only issuerAltName and authorityKeyIdentifier make any sense in a CRL.
+
+# issuerAltName=issuer:copy
+authorityKeyIdentifier=keyid:always
+
+[ proxy_cert_ext ]
+# These extensions should be added when creating a proxy certificate
+
+# This goes against PKIX guidelines but some CAs do it and some software
+# requires this to avoid interpreting an end user certificate as a CA.
+
+basicConstraints=CA:FALSE
+
+# Here are some examples of the usage of nsCertType. If it is omitted
+# the certificate can be used for anything *except* object signing.
+
+# This is OK for an SSL server.
+# nsCertType			= server
+
+# For an object signing certificate this would be used.
+# nsCertType = objsign
+
+# For normal client use this is typical
+# nsCertType = client, email
+
+# and for everything including object signing:
+# nsCertType = client, email, objsign
+
+# This is typical in keyUsage for a client certificate.
+# keyUsage = nonRepudiation, digitalSignature, keyEncipherment
+
+# This will be displayed in Netscape's comment listbox.
+nsComment			= "OpenSSL Generated Certificate"
+
+# PKIX recommendations harmless if included in all certificates.
+subjectKeyIdentifier=hash
+authorityKeyIdentifier=keyid,issuer
+
+# This stuff is for subjectAltName and issuerAltname.
+# Import the email address.
+# subjectAltName=email:copy
+# An alternative to produce certificates that aren't
+# deprecated according to PKIX.
+# subjectAltName=email:move
+
+# Copy subject details
+# issuerAltName=issuer:copy
+
+#nsCaRevocationUrl		= http://www.domain.dom/ca-crl.pem
+#nsBaseUrl
+#nsRevocationUrl
+#nsRenewalUrl
+#nsCaPolicyUrl
+#nsSslServerName
+
+# This really needs to be in place for it to be a proxy certificate.
+proxyCertInfo=critical,language:id-ppl-anyLanguage,pathlen:3,policy:foo
+
+####################################################################
+[ tsa ]
+
+default_tsa = tsa_config1	# the default TSA section
+
+[ tsa_config1 ]
+
+# These are used by the TSA reply generation only.
+dir		= ./demoCA		# TSA root directory
+serial		= $dir/tsaserial	# The current serial number (mandatory)
+crypto_device	= builtin		# OpenSSL engine to use for signing
+signer_cert	= $dir/tsacert.pem 	# The TSA signing certificate
+					# (optional)
+certs		= $dir/cacert.pem	# Certificate chain to include in reply
+					# (optional)
+signer_key	= $dir/private/tsakey.pem # The TSA private key (optional)
+
+default_policy	= tsa_policy1		# Policy if request did not specify it
+					# (optional)
+other_policies	= tsa_policy2, tsa_policy3	# acceptable policies (optional)
+digests		= md5, sha1		# Acceptable message digests (mandatory)
+accuracy	= secs:1, millisecs:500, microsecs:100	# (optional)
+clock_precision_digits  = 0	# number of digits after dot. (optional)
+ordering		= yes	# Is ordering defined for timestamps?
+				# (optional, default: no)
+tsa_name		= yes	# Must the TSA name be included in the reply?
+				# (optional, default: no)
+ess_cert_id_chain	= no	# Must the ESS cert id chain be included?
+				# (optional, default: no)

node_modules/@achrinza/node-ipc/local-node-ipc-certs/private/client.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAqzR1m22jL5citxDXr2Hm/suYFrTn+U/B0uZNBO37m/I1OH+I
++6aMYbwGIGjHrlFIoEd2GTkhnNzfMlxSxa61PFkMiuygMFnMlL6liu5r4+nUADbZ
+xr55LfqtqYzDtZ8VT7l4KL9BiGlh3O4C+K37qIQXLepW8Tl2lMVh3hW0KFpasbPp
+WGjTCDJ+z4DcDwyDaCXgAypFRV5TRvf2J0+Y+00HoJsxcQQXZKPBDVvGPdURvv2B
+4bRD8inkBq5tzbZfOSaJE/xlLFFH1I15LiqybKy4cDFSzw9t7nMuycwXHnNFYKbv
+fQZLOdcP3aOn/NKyJQISPonrGZTyY6QyGIZhFwIDAQABAoIBAHpxZ1dE/zuvFLXm
+xsr48vLxexFqSqnEv/NsoFLRPWzXufZxR+/qumW/yoXtSjpCifWPhkgd0wtT8BEd
+dFlLTPUfHthQyXQrFSSggNavE9yJxARvNits2E/pA8DKGsJPRzeghu5lcqHz9HjE
+hL2D+QMZjVZaTdnx5fwaepcR4KomYTUupci0HoMWyoKPhIfItVueiHVo4d60dIRz
+OpkSGCAZ/Czv5CJrmK/5e+roKti4ChF/n28hUu7OGzvkG+qYep08tf48MyZCPHgO
+Vj+kuxMRkjIP0iXLmiF32lZXzpOFvjtXovI46dYiINCE9tNyKqDWYUJf9qNqwAsm
+OuOfXtkCgYEA18Ywabu/Z4vYUhWtTFrP6iSLVcXd0rZuWud7kwv/G4DMrNh7oi1s
+0AVvphaEqEn8OsgcuyIlyjtJl60aQzvYwdu2KEcTjcqvUX7p/41t5O/LzaYwZ3hh
+9oFIWXXFpskg7Kh0EGCGG/yvAdTai5M0lO9XQ1DUK0MWc1KQ5yKd0mUCgYEAyx80
+dgIZTyHl0ZgF712mRda5KfQlmgWoo0zu/IFSFuINEMC/3laYEJCowOnUb8VZ8mbJ
+Wd/FhOTadv7joY0eAhfSNAItaubuZWo91bbD2vwpi/U2OEfy0LzF7BNXHCpH69wk
+vujKBxmRTGvBLbabcWA97UPFM2K33rsM72DAL8sCgYB03SOFcKk3BLfRpWnpy9mF
+/+rzNqpwoFveojb8qmet1rGD/+/eI2omtHsG4nVQzFlu4Mkm1VTQVhICsz9hIL3C
+KSRcZjqB9j/EDM/hmBDoCLRCGntm3v13zAeKZE37ij1pz8akxBJ+f/mtLUJ8i+rT
+q1mA3Ps8vyYeqZ5PgSEnPQKBgD6szEU1dJXEQeOgYwRvAyU9kjjtysRxxo1M6dkk
+Fi5VZe6rawix84349PlBrXknjg+Lw8llkM7mxro9AAQTRRUkQIonudfoldrZI2dU
+U664bCFxcl9/Y98gwHmNpi1cpoCSlwwJTH1QWFMaVKtEU0ZyiekyJiEq7s1dLiqW
+0fZtAoGABvAOikMmOn6ewt+NyYd6HkwgcvI0R0aHxOQz8aldW4gwrkuvuOOHdfah
+RAcc8LiZFqhNFN7DMkRt1crtP5v3vh2Nbyf9Zg2ZizsIupsNlvSlh/aTueVozVuM
+hc/wEVlrqeJInf4jkxYna6G6CoTfPVyQCjNcvlI3kMfIoyXS+vc=
+-----END RSA PRIVATE KEY-----

node_modules/@achrinza/node-ipc/local-node-ipc-certs/private/dhparam.pem

@@ -0,0 +1,8 @@
+-----BEGIN DH PARAMETERS-----
+MIIBCAKCAQEAhDA93df5Qa7pMWiqJ8IeCDw4fCIJCNbzRklS2saOeQRkUY/kPy07
+EByFWUDNtgtWRx7YndJKwyFepHXxI3P0DDuSPYKq/bfiWDr/cUmTBJcpPmg6w/SU
+ReOB6vORXyF9iytyLCKk1Pyo2nXOdpADcTflhi+zxTSpGLtPAU2XIYENtmC4HKJm
+y6nbSIbe4BA74bxyqzp6RVuMvyHAgCjPDwvHlp5UV1Mjtr1aNqgzpLQSjK4VwiJ+
+DZ48/1D9IYksDl8NWJopFpudyPD1WFou/CZ6PYsjprFrTKVPqoFD5Zj6zPey9C70
+Go0uHRNPr9UrhwCqDEKNszulME8heSVSQwIBAg==
+-----END DH PARAMETERS-----

node_modules/@achrinza/node-ipc/local-node-ipc-certs/private/oldclient.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAvmw4yTAd5EdNxksnKEx+ky8XgEqTJVAvcrgF1jaPrC0QNr94
+EfEHouiEyqWlf4kDzksIA9HcuGhVPZ9gsjjgLvi1pwT+e2vfyOHOWOf96NDlfW02
+Fx6d92k1zEfhfVmTJU0j6ANG2eNMfF5rhK+xKzH3FC0Vm5e7np9wVuRD4CjggJJL
+fBm6xJPSBWeY1gum3m5sH4Ec3X0zacZXeBOdjMx1a5I2gfTHJe5fizDfw1vgsYhh
+I3z6OEXEg5kFtOiz34y4SVCDRZGDVXiAdx8uVXXPdryFybjiZGWGEeTFDZfCAuZp
+h0I04cqfniD5FbSPIdVVAImH9Nm1sbpLafyuXwIDAQABAoIBADTd8OoSXMoq7bHW
+3Zk3m5Cba2fnzHB4kaPE6YHuhfbkT/MTN2+rvlYBPhTQ5mDBFnhopmIBGslr1faU
+0BDK75q63BvxrAFyEqA/6L0QM5M2o/AtqO3ER1EQOapsbnMRsmORxh09A6esjmid
+AjbFXGfEqHdGiRA4kRNZ6qOFHj8WP4FZ3/elIerl4W86FtMeuza6PUMYm1ePFG/h
+vTGROXibW2/qrfzgsocKgdjc06Szi95hjloHlpPo3OVLywSNYuJ6dxOj11tKBIjr
+U126cdza/2OeyWasY4tl4WVeG1Mojtya2ObvMNMOyESPzKaVzb2LIN6feH7toxdK
+5CEbzfkCgYEA5kZzFWLvUAkK/Oi0bK9b1WhmNUOcfZmPOBJenurfKSQo2R4ugvAM
+zMupVs/Mum0Hl1+cvTPZDAwHx0qM3E8+Ute7SqLOMxlx7b1XCFB03RN1UN4BCSy4
+hCQPi+f3YjAF/Zpduquq9qS4gcIwhlo3FHGWWFFIGDesWfJrsTsssNUCgYEA07IM
+K5+AsvdrHMShMMbys4rOitY9JKUMKV1BdsyRw9z/rsWoDcqupuFTPwWrlc3D3a/i
+/b/cM3Wm8907fPPrauU3LF11tOkIhsP8/xRkK9BZGkjJCSLO5UvWxmlcZreGvHh+
+QAwPWKh8MsatyFBFmn7SGFXSu88LQL+TGilpHGMCgYAOwBiDGDFIKSwhAy77f0gc
+pXFWnBwcF4gLCXIyL81Xr09GiR5lmMbZH3qbavgsQOupkKBTpkyS7vpYk7fuLM1L
+NTJ0F3Wp5Eld9zDqAW1a8/Ih2farBchT/pNYXOWFzpmzov26BWEQJ4ECHtRI5uJ8
+VsJQqfQ6SOarZFHtqmK0eQKBgQCPwWCyXuYuogWCy6QKU4+MjL4lWca7k7jmfgVu
+fwydTP3z2RV+CB0CBhFZwqf6Wnifmkkyt475AvQUti8ncxxywqTs46qC55x6p6yu
+K1K6zgkz6Clcot6Mpyt6ISI2PnqokcpqA8aIFiIA+RoZ5Sje+TAChoVMNBUYKv/h
+zC0ssQKBgEXyFNRGHul7ku8Ss6ZZBZjQEOFdpu7npbZWcqy273tKOdV6uOG93rQX
+6Ez6yxuBepSdwP716CT7o8EaSPBy+QjDH/e2qI3rIUHzfPwAwf4kGbNa6relTCVR
+fLrzEICSbFZKST/zeKvrY0ACOCIn8b6LiiP7GJfnV8bvvpTWXyil
+-----END RSA PRIVATE KEY-----

node_modules/@achrinza/node-ipc/local-node-ipc-certs/private/oldserver.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAyHKCBWzkf58gKkqRIBjJR8cSXlsiuOuirlbBQ1K+recVbh2b
+MdDoqBCk3ibeGw4p/smOxJiH/9rxpcCQ0XrSeNGasLxGB8RcNgenRFonyBPmTAjS
+O85Aa74g8CUBXaYSgk0hMWQNxkkHecGuu9F6LtN5TM7XG6Td7OTRB+bDEGdwfny4
+bqc2ELUsj99CVNxSNc5h0dJE9M6ejvIjdRQFFtfNKGgT3O7inEdDSpPZfeM+JmTB
+r/vz2jnHaSsD7d9hWKYo7Kp74rL0QJSH97ugb+g8kDAkqV1bQaVdzp+nC74/GbVL
+B9E+YH+zzvs2x9nLYPJHknia5KRfOmRjPnCdVwIDAQABAoIBACdNXHUX3s2vM61X
+JZF3iq/KNq3NjMdZXHJ2jDpZFQ4gCzGmGHHyFkwtx0XPtSj05AMTHi0qAzCFi3AG
+i96nCHGsF3qjz89iDvqBEajzTG2MiVFLQX18eWEmzGqJtvTXxTVLTkDS72h7lT2o
+XkxxTFW2HUiUHdVLxD/Ytauo8YJbjGJM5pdCxEp+uJbYWYwsvvfE4IHb8LJmqtOP
+fUG/wR3mjmHYYcYXKEqiDkSnxJL9vWb2lYKht1NFUyeVkv6q5dkr0JeSD6jw84by
+MiHoXsxjXmjn3JPtNfid92kIsMjsZ54oZ5ep2iUW7WpTZJnideyZCa4mIRn3BZZ6
+TPpIKVECgYEA/m7kwNG+WamLLGmgUkq9xWngHvkKaHsjnGuDGi8bYObtzAiOzoPi
+Bav0V/cJeTjZJJ3uW4HGhzmkJCDq+R3kJ9lEBYy9N0cq0tQf/IRorri7SbHm+eP3
++B26z91Vkn0sqV3Htg+78jnjLYV6Nfy4pBvs3u7O91EM7kj3Q8A/xOUCgYEAya6B
+1fsngVVfkdQ6OmsibpWWCksBbN1Ko+bnY8ZoyTWeS2LkPFVn5lihJ9XzTTV+b/s2
+6urtTpCiQo/WAT62ATI2J5xHLBVS46CJj6HP9jPsyIxSEAor7wmKXqCaQDG1J7Zt
+2IszGtg3WYRWgrNSPtYdeB14fGhbpMphigZvkYsCgYAZUvpLwtSaYgirK/w8FJpc
+2tPm4UzK52688+qBoays8W87vqJQJcpKXDoew0TbHvBl954w13LmJLOUsP4SO4po
++PQPRVnT9a5qe5iPbrJoqZRimmVt++XDeVoNtG7+/JyEYwQst9YyHtbgwgdO9k9+
+bhUef1B0R0ntMbACu1DdjQKBgGEzq/vXmkipPvBn2tCBBg1KJxA66irv1KN+DBN4
+ctRW9T3cIag6eWL5YGJ0qViS6adK6kL6ivkMmEeAT2I2OT4GVzdsCJlkhZiTrPj+
+wd4lVH+rsXltjZMdhATrXqyFyIulTvfIzw6nGrYYJCHGD2OdioJzobhEC7c2myAM
+zgTVAoGADfGqbgq8wSv+nLtOnY+s5ajwMVAyld/JqDXm5829CTI/Kd1ch6BxWYZr
+V06PY9mJ8k39GAOab7YWcKX90E85cN7YMSjsQhdMgVAsBCv25eot4BWc8EO8WeCJ
+76aC7LlmX9WlHqaZV/GNcj3PhKao5mIk77BKySxINRaflRiCWjI=
+-----END RSA PRIVATE KEY-----

node_modules/@achrinza/node-ipc/local-node-ipc-certs/private/server.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAw+YwIWPQAh8WlhPAaasfUyb13Fcg0P0y+UmtAHpAxnUKAxc1
+/bkl4FNjbS+kkTGkIvRE4NHJh4DMqEDBsf7mwhfaOl8bTCoustyh14bzxJKdM1Cx
+Q/L2GsTIwF1vZCvqOvrV1glLruRrw8PvSFaWt1JAZ8CUhtyddR3itkSF+suTORxh
++aUjUreyfuaWx0dfIQLYOxMeTa/g94Ar9Q7KPCXgxmDqu8DVCmurDH2jz6iFktbp
++iNvrUfs88Y3I0E8/QRBAK37j7fEp296QcYIDJKkS2z2lenJykAdaqF9qLhb3zrM
+UpGt5VUUSNdHeXzCQr7J9wA7TWjCXnQh3d/xlwIDAQABAoIBACUSQHVxIAHmxC1u
+W3Ejsu/XZZtm2Yzy/VxzdsuqVuu3ZkejctIq4WIMJbqZ03iufjMnKomo6Yw88X29
+k2oNpLmCLgfxy4akTOYIHpBct3CxlhIJ6SHErpHuP1c310aLkO3MXf79D1dvXn1T
+bMqxqB/U7t8zcGf9A8cP+sEnQnttCdj2ayUlDqfPV06sDRPndIS2LFkzIswwHED8
+Z9jRk6tWg+APsEgFAo58lIEYM2iR04c2ffWBvffIEWotYM4YH1pdgvVtILLzky8C
+IogcF/LWe4mFKgBi8O3cS03YowoPgkPBh/4lXBiCXio5rkKJaMJrJMNDmoQTSzqU
+80r8zuECgYEA8PqoY3p6lpUIxR1i4jrDzcmnFJ8vNoehr4SySR8G5EkPloltT0OK
+o1d7g/b19RbulR7XnMq/H4Ic5GDiP2EEI5zM093JbV5luQZHwKrqTykXVdlgiDan
+GAxsJ9Q31ASAixCA92una1+08Xe8N7aNBuJNPuvaPB2603dO30hIlQkCgYEA0Bwu
+oqZMh8Td4pB3nUQM08NiLrYy1vwzbAHhOx3VxRGiF7x8X32NSnAzQmusqYuT6j02
+o4Jg0Jyn+XV67AD4f0D8+4urQEnrfnf32GxSvefucFbekypGLR8w3WR18mkBhVst
+WTkKqZwoJtmyJlbSRRpDZ6ewQqZ/a79NmMkxmZ8CgYEAwQQ0jgGTYTucW64u/v+M
+yC8l2dmrCmVW92w1FWZ5sa5ngu8uk9eIm06+CzRrS1WD4gNjNh4bOdSQ6chET/mY
+RCIa2fSCm0yJ88p4/HSp2qASJdxIerIz4opIsxpDYVn9z+V3NzaOUe3F08dRBdr9
+WK84qhZlpdM2Spz8mtGd+WkCgYBCV3mWaCUlcuC5BQzcmYDtUO/PrE1ws11BJShD
+zDMFa6Wco32Sg1ezTylIF0MnmVNB7NmqLjnmxsnVgFn7OiP9jR4YomGpUOc9ncjo
+uT93QqSEM20oxOUyJStSqF/hMxBFDtfaBZEcmKdEG0nrZuoJFWI/fPl3hdRA6O83
+sYuaSQKBgQCGTN1vEshVEu2Sbdpw+9p/JpHOWT4HuTU78EGfjd4wDtWgme3WgbB4
+geixhSTsoGdb95Da5Wp81nEUN7P/VE9VTX74qcXD3AseCYmhmbFaZTOi0kjYEbAQ
+wGuBa8CDIzttKhBsBQWZpG7YQq3pOqKLgKOuwwf6kJk1eh+HMS7ktQ==
+-----END RSA PRIVATE KEY-----

node_modules/@achrinza/node-ipc/local-node-ipc-certs/server.pub

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIID+zCCAuOgAwIBAgIJANhisawO7GXuMA0GCSqGSIb3DQEBCwUAMIGTMQswCQYD
+VQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNVGhvdXNhbmQg
+T2FrczEUMBIGA1UECgwLRGlnaU5vdyBJbmMxDDAKBgNVBAsMA1JuRDEQMA4GA1UE
+AwwHRGlnaU5vdzEhMB8GCSqGSIb3DQEJARYSYnJhbmRvbkBkaWdpbm93Lml0MB4X
+DTE2MDkxMDIxMDIwNFoXDTE3MDkxMDIxMDIwNFowgZMxCzAJBgNVBAYTAlVTMRMw
+EQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1UaG91c2FuZCBPYWtzMRQwEgYD
+VQQKDAtEaWdpTm93IEluYzEMMAoGA1UECwwDUm5EMRAwDgYDVQQDDAdEaWdpTm93
+MSEwHwYJKoZIhvcNAQkBFhJicmFuZG9uQGRpZ2lub3cuaXQwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDD5jAhY9ACHxaWE8Bpqx9TJvXcVyDQ/TL5Sa0A
+ekDGdQoDFzX9uSXgU2NtL6SRMaQi9ETg0cmHgMyoQMGx/ubCF9o6XxtMKi6y3KHX
+hvPEkp0zULFD8vYaxMjAXW9kK+o6+tXWCUuu5GvDw+9IVpa3UkBnwJSG3J11HeK2
+RIX6y5M5HGH5pSNSt7J+5pbHR18hAtg7Ex5Nr+D3gCv1Dso8JeDGYOq7wNUKa6sM
+faPPqIWS1un6I2+tR+zzxjcjQTz9BEEArfuPt8Snb3pBxggMkqRLbPaV6cnKQB1q
+oX2ouFvfOsxSka3lVRRI10d5fMJCvsn3ADtNaMJedCHd3/GXAgMBAAGjUDBOMB0G
+A1UdDgQWBBSWtsrqQGryJVSJER5int40YIpuxjAfBgNVHSMEGDAWgBSWtsrqQGry
+JVSJER5int40YIpuxjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQDA
+NySrqGBF+h/UCph/YEXTTea8MQIvihLecZ0VpZ/0VDZfwxzZns5oV0znoZEQcyYZ
+olTr40jyCt0Ex59VRWRUUfdR1JgZtaMd29iYxUvGy+tK5pw75mIl3upc8hEe2uzN
+c8hynlLSh9y75GM3RUkUlkSIrIRQIvOTW1+lhqBzhesvYjScCbH8MXL5e6qCkbhZ
+tP5xuTjQlY38oJxDmMHmIxholxCxQtnEVTpKn0lp2diPMXU9qbsTuZ9eYTwZabSk
++CXrtjYtaZPkHGDSldWdMdbHw/+81ViMA3CA2f61aqTcIYyAZz8o9b+4IghLLicZ
+C84hYbMbCAz0rp6bt+PJ
+-----END CERTIFICATE-----

node_modules/@achrinza/node-ipc/node-ipc.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const IPC = require('./services/IPC.js');
+
+class IPCModule extends IPC{
+    constructor(){
+        super();
+        //include IPC to make extensible
+        Object.defineProperty(
+            this,
+            'IPC',
+            {
+                enumerable:true,
+                writable:false,
+                value:IPC
+            }
+        )
+    }
+}
+
+module.exports=new IPCModule;

node_modules/@achrinza/node-ipc/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@achrinza/node-ipc",
+  "version": "9.2.5",
+  "description": "A nodejs module for local and remote Inter Process Communication (IPC), Neural Networking, and able to facilitate machine learning.",
+  "main": "node-ipc.js",
+  "directories": {
+    "example": "example"
+  },
+  "engines": {
+    "node": "8 || 9 || 10 || 11 || 12 || 13 || 14 || 15 || 16 || 17 || 18"
+  },
+  "dependencies": {
+    "@node-ipc/js-queue": "2.0.3",
+    "event-pubsub": "4.3.0",
+    "js-message": "1.0.7"
+  },
+  "devDependencies": {
+    "istanbul": "0.4.1",
+    "jasmine": "2.4.1",
+    "lockfile-lint": "^4.7.4",
+    "node-cmd": "2.0.0"
+  },
+  "scripts": {
+    "istanbul": "istanbul cover -x ./spec/**",
+    "test-windows": "npm run-script istanbul -- ./node_modules/jasmine/bin/jasmine.js",
+    "test": "npm run-script istanbul -- jasmine"
+  },
+  "keywords": [
+    "IPC",
+    "Neural Networking",
+    "Machine Learning",
+    "inter",
+    "process",
+    "communication",
+    "unix",
+    "windows",
+    "win",
+    "socket",
+    "TCP",
+    "UDP",
+    "domain",
+    "sockets",
+    "threaded",
+    "communication",
+    "multi",
+    "process",
+    "shared",
+    "memory"
+  ],
+  "author": "Brandon Nozaki Miller",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/achrinza/node-ipc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/achrinza/node-ipc/issues"
+  },
+  "files": [
+    "dao",
+    "entities",
+    "local-node-ipc-certs",
+    "services"
+  ],
+  "homepage": "https://github.com/achrinza/node-ipc"
+}

node_modules/@achrinza/node-ipc/services/IPC.js

@@ -0,0 +1,338 @@
+'use strict';
+
+const Defaults = require('../entities/Defaults.js'),
+    Client = require('../dao/client.js'),
+    Server = require('../dao/socketServer.js'),
+    util = require('util');
+
+class IPC{
+    constructor(){
+        Object.defineProperties(
+            this,
+            {
+                config      : {
+                    enumerable:true,
+                    writable:true,
+                    value:new Defaults
+                },
+                connectTo   : {
+                    enumerable:true,
+                    writable:false,
+                    value:connect
+                },
+                connectToNet: {
+                    enumerable:true,
+                    writable:false,
+                    value:connectNet
+                },
+                disconnect  : {
+                    enumerable:true,
+                    writable:false,
+                    value:disconnect
+                },
+                serve       : {
+                    enumerable:true,
+                    writable:false,
+                    value:serve
+                },
+                serveNet    : {
+                    enumerable:true,
+                    writable:false,
+                    value:serveNet
+                },
+                of          : {
+                    enumerable:true,
+                    writable:true,
+                    value:{}
+                },
+                server      : {
+                    enumerable:true,
+                    writable:true,
+                    configurable:true,
+                    value:false
+                },
+                log         : {
+                    enumerable:true,
+                    writable:false,
+                    value:log
+                }
+            }
+        );
+    }
+}
+
+function log(...args){
+    if(this.config.silent){
+        return;
+    }
+
+    for(let i=0, count=args.length; i<count; i++){
+        if(typeof args[i] != 'object'){
+            continue;
+        }
+
+        args[i]=util.inspect(
+            args[i],
+            {
+                depth:this.config.logDepth,
+                colors:this.config.logInColor
+            }
+        );
+    }
+
+    this.config.logger(
+        args.join(' ')
+    );
+}
+
+function disconnect(id){
+    if(!this.of[id]){
+        return;
+    }
+
+    this.of[id].explicitlyDisconnected=true;
+
+    this.of[id].off('*','*');
+    if(this.of[id].socket){
+        if(this.of[id].socket.destroy){
+            this.of[id].socket.destroy();
+        }
+    }
+
+    delete this.of[id];
+}
+
+function serve(path,callback){
+    if(typeof path=='function'){
+        callback=path;
+        path=false;
+    }
+    if(!path){
+        this.log(
+            'Server path not specified, so defaulting to',
+            'ipc.config.socketRoot + ipc.config.appspace + ipc.config.id',
+            this.config.socketRoot+this.config.appspace+this.config.id
+        );
+        path=this.config.socketRoot+this.config.appspace+this.config.id;
+    }
+
+    if(!callback){
+        callback=emptyCallback;
+    }
+
+    this.server=new Server(
+        path,
+        this.config,
+        log
+    );
+
+    this.server.on(
+        'start',
+        callback
+    );
+}
+
+function emptyCallback(){
+    //Do Nothing
+}
+
+function serveNet(host,port,UDPType,callback){
+    if(typeof host=='number'){
+        callback=UDPType;
+        UDPType=port;
+        port=host;
+        host=false;
+    }
+    if(typeof host=='function'){
+        callback=host;
+        UDPType=false;
+        host=false;
+        port=false;
+    }
+    if(!host){
+        this.log(
+            'Server host not specified, so defaulting to',
+            'ipc.config.networkHost',
+            this.config.networkHost
+        );
+        host=this.config.networkHost;
+    }
+    if(host.toLowerCase()=='udp4' || host.toLowerCase()=='udp6'){
+        callback=port;
+        UDPType=host.toLowerCase();
+        port=false;
+        host=this.config.networkHost;
+    }
+
+    if(typeof port=='string'){
+        callback=UDPType;
+        UDPType=port;
+        port=false;
+    }
+    if(typeof port=='function'){
+        callback=port;
+        UDPType=false;
+        port=false;
+    }
+    if(!port){
+        this.log(
+            'Server port not specified, so defaulting to',
+            'ipc.config.networkPort',
+            this.config.networkPort
+        );
+        port=this.config.networkPort;
+    }
+
+    if(typeof UDPType=='function'){
+        callback=UDPType;
+        UDPType=false;
+    }
+
+    if(!callback){
+        callback=emptyCallback;
+    }
+
+    this.server=new Server(
+        host,
+        this.config,
+        log,
+        port
+    );
+
+    if(UDPType){
+        this.server[UDPType]=true;
+        if(UDPType === "udp4" && host === "::1") {
+            // bind udp4 socket to an ipv4 address
+            this.server.path = "127.0.0.1";
+        }
+    }
+
+    this.server.on(
+        'start',
+        callback
+    );
+}
+
+function connect(id,path,callback){
+    if(typeof path == 'function'){
+        callback=path;
+        path=false;
+    }
+
+    if(!callback){
+        callback=emptyCallback;
+    }
+
+    if(!id){
+        this.log(
+            'Service id required',
+            'Requested service connection without specifying service id. Aborting connection attempt'
+        );
+        return;
+    }
+
+    if(!path){
+        this.log(
+            'Service path not specified, so defaulting to',
+            'ipc.config.socketRoot + ipc.config.appspace + id',
+            (this.config.socketRoot+this.config.appspace+id).data
+        );
+        path=this.config.socketRoot+this.config.appspace+id;
+    }
+
+    if(this.of[id]){
+        if(!this.of[id].socket.destroyed){
+            this.log(
+                'Already Connected to',
+                id,
+                '- So executing success without connection'
+            );
+            callback();
+            return;
+        }
+        this.of[id].socket.destroy();
+    }
+
+    this.of[id] = new Client(this.config,this.log);
+    this.of[id].id = id;
+    this.of[id].path = path;
+
+    this.of[id].connect();
+
+    callback(this);
+}
+
+function connectNet(id,host,port,callback){
+    if(!id){
+        this.log(
+            'Service id required',
+            'Requested service connection without specifying service id. Aborting connection attempt'
+        );
+        return;
+    }
+    if(typeof host=='number'){
+        callback=port;
+        port=host;
+        host=false;
+    }
+    if(typeof host=='function'){
+        callback=host;
+        host=false;
+        port=false;
+    }
+    if(!host){
+        this.log(
+            'Server host not specified, so defaulting to',
+            'ipc.config.networkHost',
+            this.config.networkHost
+        );
+        host=this.config.networkHost;
+    }
+
+    if(typeof port=='function'){
+        callback=port;
+        port=false;
+    }
+    if(!port){
+        this.log(
+            'Server port not specified, so defaulting to',
+            'ipc.config.networkPort',
+            this.config.networkPort
+        );
+        port=this.config.networkPort;
+    }
+
+    if(typeof callback == 'string'){
+        UDPType=callback;
+        callback=false;
+    }
+    if(!callback){
+        callback=emptyCallback;
+    }
+
+    if(this.of[id]){
+        if(!this.of[id].socket.destroyed){
+
+            this.log(
+                'Already Connected to',
+                id,
+                '- So executing success without connection'
+            );
+            callback();
+            return;
+        }
+        this.of[id].socket.destroy();
+    }
+
+    this.of[id] = new Client(this.config,this.log);
+    this.of[id].id = id;
+    (this.of[id].socket)? this.of[id].socket.id=id:null;
+    this.of[id].path = host;
+    this.of[id].port = port;
+
+    this.of[id].connect();
+
+    callback(this);
+}
+
+module.exports=IPC;

node_modules/@amap/amap-jsapi-loader/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "editor.tabSize": 4,
+  "prettier.tabWidth": 4
+}

node_modules/@amap/amap-jsapi-loader/README.md

@@ -0,0 +1,111 @@
+# amap-jsapi-loader
+amap-jsapi-loader 是高德开放平台官网提供的地图 JSAPI 的加载器，可帮助开发者快速定位、有效避免加载引用地图 JSAPI 各种错误用法。
+
+
+该加载器具有以下特性：
+* 支持以 普通JS 和 npm包 两种方式使用；
+* 有效避免错误异步加载导致的 JSAPI 资源加载不完整问题；
+* 对于加载混用多个版本 JSAPI 的错误用法给予报错处理；
+* 对于不合法加载引用 JSAPI 给予报错处理；
+* 支持指定 JSAPI 版本；
+* 支持插件加载；
+* 允许多次执行加载操作，网络资源不会重复请求，便于大型工程模块管理；
+
+
+# USAGE
+
+## AMapLoader.load方法参数说明
+```js
+AMapLoader.load({
+    "key": "",              // 申请好的Web端开发者Key，首次调用 load 时必填
+    "version": "2.0",   // 指定要加载的 JSAPI 的版本，缺省时默认为 1.4.15
+    "plugins": []           // 需要使用的的插件列表，如比例尺'AMap.Scale'等
+    "AMapUI": {             // 是否加载 AMapUI，缺省不加载
+        "version": '1.1',   // AMapUI 缺省 1.1
+        "plugins":[],       // 需要加载的 AMapUI ui插件
+    },
+    "Loca":{                // 是否加载 Loca， 缺省不加载
+        "version": '1.3.2'  // Loca 版本，缺省 1.3.2
+    },
+}).then(()=>{
+    window.AMap.xx;
+    window.AMapUI.xx;
+    window.Loca.xx
+});
+
+```
+
+## AMapUI
+
+AMapUI 用法和官网有一点点区别。通过 AMapUI.xx 来获取组件
+```js
+AMapLoader.load({
+    key: '',//首次load必填
+    version: '2.0',
+    AMapUI: {
+        version: '1.1',
+        plugins: ['overlay/SimpleMarker'],
+    }
+}).then((AMap) => {
+    map = new AMap.Map('container');
+
+    // !!! 通过 AMap.SimpleMarker 获取组件
+    new AMapUI.SimpleMarker({
+        //前景文字
+        iconLabel: 'A',
+        //图标主题
+        iconTheme: 'default',
+        //背景图标样式
+        iconStyle: 'red',
+        map: map,
+        position: map.getCenter()
+    });
+}).catch((e) => {
+    console.error(e);
+});
+```
+
+
+# 使用
+#### 以普通 JS 方式使用 Loader
+尚未发布在线Loader，可将 dist/index.js 复制到项目下
+```
+<script src="../dist/index.js"></script>
+<script>
+    AMapLoader.load({
+        key:'',//首次load必填
+        version:'2.0',
+        plugins:['AMap.Scale']
+    }).then((AMap)=>{
+        map = new AMap.Map('container');
+        map.addControl(new AMap.Scale())
+    }).catch((e)=>{
+        console.error(e);
+    });   
+</script>
+```
+#### 以 NPM 包方式使用 Loader
+安装
+```
+tnpm i @alife/amap-jsapi-loader --save-dev
+```
+使用
+```
+import AMapLoader from '@alife/amap-jsapi-loader';
+
+AMapLoader.load().then((AMap)=>{
+    map = new AMap.Map('container');
+}).catch(e=>{
+    console.log(e);
+})
+
+```
+
+# 相关链接：
+地&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;图 JSAPI：  &nbsp;&nbsp;[示例中心](https://lbs.amap.com/demo-center/js-api)&nbsp;&nbsp;&nbsp;&nbsp;[教程](https://lbs.amap.com/api/javascript-api/summary)&nbsp;&nbsp;&nbsp;&nbsp;[参考手册](https://lbs.amap.com/api/javascript-api/reference/map)
+
+
+
+数据可视化 JSAPI：  &nbsp;&nbsp;[示例中心](https://lbs.amap.com/demo-center/loca-api)&nbsp;&nbsp;&nbsp;&nbsp;[教程](https://lbs.amap.com/api/loca-api/prod_intro)&nbsp;&nbsp;&nbsp;&nbsp;[参考手册](https://lbs.amap.com/api/loca-api/guide/baselayer)
+
+

node_modules/@amap/amap-jsapi-loader/dist/index.js

@@ -0,0 +1,11 @@
+'use strict';(function(m,p){"object"===typeof exports&&"undefined"!==typeof module?module.exports=p():"function"===typeof define&&define.amd?define(p):(m=m||self,m.AMapLoader=p())})(this,function(){function m(a){var b=[];a.AMapUI&&b.push(p(a.AMapUI));a.Loca&&b.push(r(a.Loca));return Promise.all(b)}function p(a){return new Promise(function(h,c){var f=[];if(a.plugins)for(var e=0;e<a.plugins.length;e+=1)-1==d.AMapUI.plugins.indexOf(a.plugins[e])&&f.push(a.plugins[e]);if(g.AMapUI===b.failed)c("\u524d\u6b21\u8bf7\u6c42 AMapUI \u5931\u8d25");
+else if(g.AMapUI===b.notload){g.AMapUI=b.loading;d.AMapUI.version=a.version||d.AMapUI.version;e=d.AMapUI.version;var l=document.body||document.head,k=document.createElement("script");k.type="text/javascript";k.src="https://webapi.amap.com/ui/"+e+"/main.js";k.onerror=function(a){g.AMapUI=b.failed;c("\u8bf7\u6c42 AMapUI \u5931\u8d25")};k.onload=function(){g.AMapUI=b.loaded;if(f.length)window.AMapUI.loadUI(f,function(){for(var a=0,b=f.length;a<b;a++){var c=f[a].split("/").slice(-1)[0];window.AMapUI[c]=
+arguments[a]}for(h();n.AMapUI.length;)n.AMapUI.splice(0,1)[0]()});else for(h();n.AMapUI.length;)n.AMapUI.splice(0,1)[0]()};l.appendChild(k)}else g.AMapUI===b.loaded?a.version&&a.version!==d.AMapUI.version?c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c AMapUI \u6df7\u7528"):f.length?window.AMapUI.loadUI(f,function(){for(var a=0,b=f.length;a<b;a++){var c=f[a].split("/").slice(-1)[0];window.AMapUI[c]=arguments[a]}h()}):h():a.version&&a.version!==d.AMapUI.version?c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c AMapUI \u6df7\u7528"):
+n.AMapUI.push(function(a){a?c(a):f.length?window.AMapUI.loadUI(f,function(){for(var a=0,b=f.length;a<b;a++){var c=f[a].split("/").slice(-1)[0];window.AMapUI[c]=arguments[a]}h()}):h()})})}function r(a){return new Promise(function(h,c){if(g.Loca===b.failed)c("\u524d\u6b21\u8bf7\u6c42 Loca \u5931\u8d25");else if(g.Loca===b.notload){g.Loca=b.loading;d.Loca.version=a.version||d.Loca.version;var f=d.Loca.version,e=d.AMap.version.startsWith("2"),l=f.startsWith("2");if(e&&!l||!e&&l)c("JSAPI \u4e0e Loca \u7248\u672c\u4e0d\u5bf9\u5e94\uff01\uff01");
+else{e=d.key;l=document.body||document.head;var k=document.createElement("script");k.type="text/javascript";k.src="https://webapi.amap.com/loca?v="+f+"&key="+e;k.onerror=function(a){g.Loca=b.failed;c("\u8bf7\u6c42 AMapUI \u5931\u8d25")};k.onload=function(){g.Loca=b.loaded;for(h();n.Loca.length;)n.Loca.splice(0,1)[0]()};l.appendChild(k)}}else g.Loca===b.loaded?a.version&&a.version!==d.Loca.version?c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c Loca \u6df7\u7528"):h():a.version&&a.version!==d.Loca.version?
+c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c Loca \u6df7\u7528"):n.Loca.push(function(a){a?c(a):c()})})}if(!window)throw Error("AMap JSAPI can only be used in Browser.");var b;(function(a){a.notload="notload";a.loading="loading";a.loaded="loaded";a.failed="failed"})(b||(b={}));var d={key:"",AMap:{version:"1.4.15",plugins:[]},AMapUI:{version:"1.1",plugins:[]},Loca:{version:"1.3.2"}},g={AMap:b.notload,AMapUI:b.notload,Loca:b.notload},n={AMap:[],AMapUI:[],Loca:[]},q=[],t=function(a){"function"==typeof a&&
+(g.AMap===b.loaded?a(window.AMap):q.push(a))};return{load:function(a){return new Promise(function(h,c){if(g.AMap==b.failed)c("");else if(g.AMap==b.notload){var f=a.key,e=a.version,l=a.plugins;f?(window.AMap&&"lbs.amap.com"!==location.host&&c("\u7981\u6b62\u591a\u79cdAPI\u52a0\u8f7d\u65b9\u5f0f\u6df7\u7528"),d.key=f,d.AMap.version=e||d.AMap.version,d.AMap.plugins=l||d.AMap.plugins,g.AMap=b.loading,e=document.body||document.head,window.___onAPILoaded=function(d){delete window.___onAPILoaded;if(d)g.AMap=
+b.failed,c(d);else for(g.AMap=b.loaded,m(a).then(function(){h(window.AMap)})["catch"](c);q.length;)q.splice(0,1)[0]()},l=document.createElement("script"),l.type="text/javascript",l.src="https://webapi.amap.com/maps?callback=___onAPILoaded&v="+d.AMap.version+"&key="+f+"&plugin="+d.AMap.plugins.join(","),l.onerror=function(a){g.AMap=b.failed;c(a)},e.appendChild(l)):c("\u8bf7\u586b\u5199key")}else if(g.AMap==b.loaded)if(a.key&&a.key!==d.key)c("\u591a\u4e2a\u4e0d\u4e00\u81f4\u7684 key");else if(a.version&&
+a.version!==d.AMap.version)c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c JSAPI \u6df7\u7528");else{f=[];if(a.plugins)for(e=0;e<a.plugins.length;e+=1)-1==d.AMap.plugins.indexOf(a.plugins[e])&&f.push(a.plugins[e]);if(f.length)window.AMap.plugin(f,function(){m(a).then(function(){h(window.AMap)})["catch"](c)});else m(a).then(function(){h(window.AMap)})["catch"](c)}else if(a.key&&a.key!==d.key)c("\u591a\u4e2a\u4e0d\u4e00\u81f4\u7684 key");else if(a.version&&a.version!==d.AMap.version)c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c JSAPI \u6df7\u7528");
+else{var k=[];if(a.plugins)for(e=0;e<a.plugins.length;e+=1)-1==d.AMap.plugins.indexOf(a.plugins[e])&&k.push(a.plugins[e]);t(function(){if(k.length)window.AMap.plugin(k,function(){m(a).then(function(){h(window.AMap)})["catch"](c)});else m(a).then(function(){h(window.AMap)})["catch"](c)})}})},reset:function(){delete window.AMap;delete window.AMapUI;delete window.Loca;d={key:"",AMap:{version:"1.4.15",plugins:[]},AMapUI:{version:"1.1",plugins:[]},Loca:{version:"1.3.2"}};g={AMap:b.notload,AMapUI:b.notload,
+Loca:b.notload};n={AMap:[],AMapUI:[],Loca:[]}}}})

node_modules/@amap/amap-jsapi-loader/example/AMapUI.html

@@ -0,0 +1,69 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader</title>
+    <style>
+        html,
+        body,
+        #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="container" tabindex="0"></div>
+
+    <script src="../dist/index.js"></script>
+    <script>
+        AMapLoader.load({
+            key: '',//首次load必填
+            version: '2.0Beta',
+            plugins: ['AMap.Scale'],
+            AMapUI: {
+                plugins: ['overlay/SimpleMarker'],
+            }
+        }).then((AMap) => {
+            map = new AMap.Map('container');
+            map.addControl(new AMap.Scale());
+            new AMapUI.SimpleMarker({
+
+                //前景文字
+                iconLabel: 'A',
+
+                //图标主题
+                iconTheme: 'default',
+
+                //背景图标样式
+                iconStyle: 'red',
+
+                //...其他Marker选项...，不包括content
+                map: map,
+                position: map.getCenter()
+            });
+        }).catch((e) => {
+            console.error(e);
+        });
+        setTimeout(function () {
+            AMapLoader.load({
+                plugins: ['AMap.MapType']
+            }).then((AMap) => {
+                map.addControl(new AMap.MapType())
+            }).catch((e) => {
+                console.error(e);
+            });
+        }, 5000);
+
+    </script>
+
+
+    </script>
+</body>
+
+</html>

node_modules/@amap/amap-jsapi-loader/example/Loca.html

@@ -0,0 +1,76 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader</title>
+    <style>
+        html,
+        body,
+        #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="container" tabindex="0"></div>
+    <script src="https://a.amap.com/Loca/static/mock/districts.js"></script>
+    <script src="../dist/index.js"></script>
+    <script>
+        AMapLoader.load({
+            key: 'd3c5511c8a102496b1fdb985e6ca1cd7',//首次load必填
+            // version: '2.0',
+            Loca: {
+                version: '2.0.0beta'
+            }
+        }).then((AMap) => {
+            var map = new AMap.Map('container', {
+                zoom: 4,
+                center: [107.4976, 32.1697],
+                features: ['bg', 'road'],
+                // Loca 自 1.2.0 起 viewMode 模式默认为 3D，如需 2D 模式，请显示配置。
+                // viewMode: '3D'
+            });
+
+            var layer = new Loca.PointLayer({
+                map: map
+            });
+
+            layer.setData(districts, {
+                // 指定经纬度所在字段
+                lnglat: 'center'
+            });
+
+            layer.setOptions({
+                style: {
+                    // 圆形半径，单位像素
+                    radius: 5,
+                    // 填充颜色
+                    color: '#07E8E4',
+                    // 描边颜色
+                    borderColor: '#5DFBF9',
+                    // 描边宽度，单位像素
+                    borderWidth: 1,
+                    // 透明度 [0-1]
+                    opacity: 0.9,
+                }
+            });
+
+            layer.render();
+
+        }).catch((e) => {
+            console.error(e);
+        });
+
+    </script>
+
+
+    </script>
+</body>
+
+</html>

node_modules/@amap/amap-jsapi-loader/example/Multi.html

@@ -0,0 +1,94 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader</title>
+    <style>
+        html,
+        body,
+        #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="container" tabindex="0"></div>
+    <script src="https://a.amap.com/Loca/static/mock/districts.js"></script>
+    <script src="../dist/index.js"></script>
+    <script>
+        AMapLoader.load({
+            key: '',//首次load必填
+            version: '1.4.15',
+            AMapUI: {
+                plugins: ['overlay/SimpleMarker'],
+            },
+            Loca: {
+                version: '1.3.2'
+            }
+        }).then((AMap) => {
+            var map = new AMap.Map('container', {
+                zoom: 4,
+                center: [107.4976, 32.1697],
+                features: ['bg', 'road'],
+                // Loca 自 1.2.0 起 viewMode 模式默认为 3D，如需 2D 模式，请显示配置。
+                // viewMode: '3D'
+            });
+
+            new AMapUI.SimpleMarker({
+
+                //前景文字
+                iconLabel: 'A',
+
+                //图标主题
+                iconTheme: 'default',
+
+                //背景图标样式
+                iconStyle: 'red',
+
+                //...其他Marker选项...，不包括content
+                map: map,
+                position: map.getCenter()
+            });
+            var layer = new Loca.PointLayer({
+                map: map
+            });
+
+            layer.setData(districts, {
+                // 指定经纬度所在字段
+                lnglat: 'center'
+            });
+
+            layer.setOptions({
+                style: {
+                    // 圆形半径，单位像素
+                    radius: 5,
+                    // 填充颜色
+                    color: '#07E8E4',
+                    // 描边颜色
+                    borderColor: '#5DFBF9',
+                    // 描边宽度，单位像素
+                    borderWidth: 1,
+                    // 透明度 [0-1]
+                    opacity: 0.9,
+                }
+            });
+
+            layer.render();
+
+        }).catch((e) => {
+            console.error(e);
+        });
+
+    </script>
+
+
+    </script>
+</body>
+
+</html>

node_modules/@amap/amap-jsapi-loader/example/example-es6.html

@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader - ES6</title>
+    <style>
+        html, body, #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+<body>
+<div id="container" tabindex="0"></div>
+<script type="module">
+    import AMapLoader from '../src/index.js';
+    AMapLoader.load({
+        key:'',//必填
+        version:'2.0',
+        plugins:['AMap.Scale']
+    }).then((AMap)=>{
+        debugger
+        var map = new AMap.Map('container');
+        map.addControl(new AMap.Scale())
+    }).catch((e)=>{
+        console.error(e);
+    });
+</script>
+
+
+</script>
+</body>
+</html>

node_modules/@amap/amap-jsapi-loader/example/example.html

@@ -0,0 +1,46 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>AMap JSAPI Loader</title>
+    <style>
+        html, body, #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+<body>
+<div id="container" tabindex="0"></div>
+
+<script src="https://webapi.amap.com/loader.js"></script>
+<script>
+    AMapLoader.load({ //首次调用 load
+        key:'你申请的高德开放平台 Web 端 key',//首次load key为必填
+        version:'2.0',
+        plugins:['AMap.Scale','AMap.ToolBar']
+    }).then((AMap)=>{
+        map = new AMap.Map('container');
+        map.addControl(new AMap.Scale())
+        map.addControl(new AMap.ToolBar())
+        map.add(new AMap.Marker({
+            position:map.getCenter()
+        }));
+    }).catch((e)=>{
+        console.error(e);
+    });
+   
+    AMapLoader.load({ //可多次调用load
+        plugins:['AMap.MapType']
+    }).then((AMap)=>{
+        map.addControl(new AMap.MapType())
+    }).catch((e)=>{
+        console.error(e);
+    });
+   
+</script>
+</body>
+</html>

node_modules/@amap/amap-jsapi-loader/example/libs/mocha.min.css

@@ -0,0 +1 @@
+@charset "utf-8";body{margin:0}#mocha{font:20px/1.5 "Helvetica Neue",Helvetica,Arial,sans-serif;margin:60px 50px}#mocha li,#mocha ul{margin:0;padding:0}#mocha ul{list-style:none}#mocha h1,#mocha h2{margin:0}#mocha h1{margin-top:15px;font-size:1em;font-weight:200}#mocha h1 a{text-decoration:none;color:inherit}#mocha h1 a:hover{text-decoration:underline}#mocha .suite .suite h1{margin-top:0;font-size:.8em}#mocha .hidden{display:none}#mocha h2{font-size:12px;font-weight:400;cursor:pointer}#mocha .suite{margin-left:15px}#mocha .test{margin-left:15px;overflow:hidden}#mocha .test.pending:hover h2::after{content:'(pending)';font-family:arial,sans-serif}#mocha .test.pass.medium .duration{background:#c09853}#mocha .test.pass.slow .duration{background:#b94a48}#mocha .test.pass::before{content:'✓';font-size:12px;display:block;float:left;margin-right:5px;color:#00d6b2}#mocha .test.pass .duration{font-size:9px;margin-left:5px;padding:2px 5px;color:#fff;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.2);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,.2);box-shadow:inset 0 1px 1px rgba(0,0,0,.2);-webkit-border-radius:5px;-moz-border-radius:5px;-ms-border-radius:5px;-o-border-radius:5px;border-radius:5px}#mocha .test.pass.fast .duration{display:none}#mocha .test.pending{color:#0b97c4}#mocha .test.pending::before{content:'◦';color:#0b97c4}#mocha .test.fail{color:#c00}#mocha .test.fail pre{color:#000}#mocha .test.fail::before{content:'✖';font-size:12px;display:block;float:left;margin-right:5px;color:#c00}#mocha .test pre.error{color:#c00;max-height:300px;overflow:auto}#mocha .test pre{display:block;float:left;clear:left;font:12px/1.5 monaco,monospace;margin:5px;padding:15px;border:1px solid #eee;max-width:85%;max-width:calc(100% - 42px);word-wrap:break-word;border-bottom-color:#ddd;-webkit-border-radius:3px;-webkit-box-shadow:0 1px 3px #eee;-moz-border-radius:3px;-moz-box-shadow:0 1px 3px #eee;border-radius:3px}#mocha .test h2{position:relative}#mocha .test a.replay{position:absolute;top:3px;right:0;text-decoration:none;vertical-align:middle;display:block;width:15px;height:15px;line-height:15px;text-align:center;background:#eee;font-size:15px;-moz-border-radius:15px;border-radius:15px;-webkit-transition:opacity 200ms;-moz-transition:opacity 200ms;transition:opacity 200ms;opacity:.3;color:#888}#mocha .test:hover a.replay{opacity:1}#mocha-report.fail .test.pass,#mocha-report.pass .test.fail,#mocha-report.pending .test.fail,#mocha-report.pending .test.pass{display:none}#mocha-report.pending .test.pass.pending{display:block}#mocha-error{color:#c00;font-size:1.5em;font-weight:100;letter-spacing:1px}#mocha-stats{position:fixed;top:15px;right:10px;font-size:12px;margin:0;color:#888;z-index:1}#mocha-stats .progress{float:right;padding-top:0}#mocha-stats em{color:#000}#mocha-stats a{text-decoration:none;color:inherit}#mocha-stats a:hover{border-bottom:1px solid #eee}#mocha-stats li{display:inline-block;margin:0 5px;list-style:none;padding-top:11px}#mocha-stats canvas{width:40px;height:40px}#mocha code .comment{color:#ddd}#mocha code .init{color:#2f6fad}#mocha code .string{color:#5890ad}#mocha code .keyword{color:#8a6343}#mocha code .number{color:#2f6fad}@media screen and (max-device-width:480px){#mocha{margin:60px 0}#mocha #stats{position:absolute}}

node_modules/@amap/amap-jsapi-loader/example/test.html

@@ -0,0 +1,287 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader</title>
+    <style>
+        html,
+        body,
+        #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="mocha"></div>
+
+    <link rel="stylesheet" href="./libs/mocha.min.css" />
+    <script src="./libs/chai.min.js"></script>
+    <script src="./libs/mocha.min.js"></script>
+
+    <script>
+        mocha.setup('bdd');
+        mocha.traceIgnores = ['mocha.min.js', 'chai.min.js'];
+        expect = chai.expect;
+    </script>
+    <div id="container" tabindex="0"></div>
+
+    <script src="../dist/index.js"></script>
+    <script>
+        // 请把 key 写在这里
+        const JSAPIKey = '';
+        const chai = window.chai;
+        const mocha = window.mocha;
+        mocha.setup({
+            timeout: '5000',
+            ui: 'bdd',
+        });
+        const expect = chai.expect;
+        describe('JSAPI', () => {
+            beforeEach(function () {
+                AMapLoader.reset()
+            });
+
+            it('Simple', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '2.0',
+                    plugins: ['AMap.Scale'],
+                    AMapUI: {
+                        plugins: ['overlay/SimpleMarker']
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.AMapUI)).eq(true)
+                    expect(Boolean(window.AMapUI.SimpleMarker)).eq(true)
+                    expect(Boolean(window.Loca)).eq(false)
+                    done();
+                });
+
+            });
+            it('Request with AMapUI Loca', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    plugins: ['AMap.Scale'],
+                    AMapUI: {
+                        plugins: ['overlay/SimpleMarker']
+                    },
+                    Loca: {
+                        version: '1.3.2'
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.AMapUI)).eq(true)
+                    expect(Boolean(window.AMapUI.SimpleMarker)).eq(true)
+
+                    expect(Boolean(window.Loca)).eq(true)
+                    done();
+                });
+
+            });
+            it('fail with multi version', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '2.0',
+                }).then(() => {
+                    done()
+                });
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                }).then(() => {
+                    done(Error('should not here'))
+                })
+                    .catch(err => {
+                        try {
+                            expect(err).eq('不允许多个版本 JSAPI 混用')
+
+                        } catch (error) {
+                            done(error)
+                        }
+                    })
+
+            });
+            it('fail with multi key', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '2.0',
+                }).then(() => {
+                    done()
+                });
+                AMapLoader.load({
+                    key: 'asdfas',//首次load必填
+                }).then(() => {
+                    done(Error('should not here'))
+                })
+                    .catch(err => {
+                        try {
+                            expect(err).eq('多个不一致的 key')
+
+                        } catch (error) {
+                            done(error)
+                        }
+                    })
+
+            });
+        })
+
+
+        describe('AMapUI', () => {
+            beforeEach(function () {
+                AMapLoader.reset()
+            });
+
+            it('version', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    AMapUI: {
+                        version: '1.1',
+                        plugins: ['misc/PathSimplifier']
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.AMapUI)).eq(true)
+                    expect(Boolean(window.AMapUI.PathSimplifier)).eq(true)
+                    expect(Boolean(window.AMapUI.version.startsWith('1.1'))).eq(true)
+                    done();
+                }).catch(done);
+            });
+
+            it('async', (done) => {
+                console.log(window.AMap);
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    AMapUI: {
+                        version: '1.0',
+                        plugins: ['overlay/SimpleMarker']
+                    }
+                }).then(() => {
+                    AMapLoader.load({
+                        AMapUI: {
+                            plugins: ['overlay/SimpleInfoWindow']
+                        }
+                    }).then(() => {
+                        expect(Boolean(window.AMap)).eq(true)
+                        expect(Boolean(window.AMapUI.version.startsWith('1.0'))).eq(true)
+                        expect(Boolean(window.AMapUI.SimpleMarker)).eq(true)
+                        expect(Boolean(window.AMapUI.SimpleInfoWindow)).eq(true)
+                        done()
+                    });
+                }).catch(done);
+            })
+        });
+
+        describe('Loca', () => {
+            beforeEach(function () {
+                AMapLoader.reset()
+            });
+
+            it('version', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    Loca: {
+                        version: '1.3.1'
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.Loca)).eq(true)
+                    expect(window.Loca.version).eq('1.3.1')
+                    done()
+                }).catch(done);
+            });
+            it('fail with jsapi2.0', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '2.0',
+                    Loca: {
+                        version: '1.3.1'
+                    }
+                }).then(() => {
+                    done(Error('should not here'))
+                }).catch(err => {
+                    try {
+                        expect(err).eq("Loca 暂不适配 JSAPI 2.0,请使用 1.4.15")
+                        done()
+                    } catch (error) {
+                        done(error)
+                    }
+                });
+            });
+
+
+            it('async', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    Loca: {
+                        version: '1.2.1'
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.Loca)).eq(true)
+                    expect(window.Loca.version).eq('1.2.1')
+                    AMapLoader.load({
+                        Loca: {
+                            version: '1.2.1'
+                        }
+                    }).then(() => {
+                        expect(Boolean(window.AMap)).eq(true)
+                        expect(Boolean(window.Loca)).eq(true)
+                        expect(window.Loca.version).eq('1.2.1')
+                        done()
+                    }).catch(done);
+
+                });
+            })
+        });
+
+
+        describe('Advance', () => {
+            beforeEach(function () {
+                AMapLoader.reset()
+            });
+            it('Multi', (done) => {
+                AMapLoader.load({ key: JSAPIKey, version: '1.4.15' }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true);
+                    expect(window.AMap.v).eq('1.4.15');
+
+                    expect(Boolean(window.AMapUI)).eq(false);
+                    expect(Boolean(window.Loca)).eq(false);
+                    AMapLoader.load({ AMapUI: {} }).then(() => {
+                        expect(Boolean(window.AMap)).eq(true);
+                        expect(window.AMap.v).eq('1.4.15');
+
+                        expect(Boolean(window.AMapUI)).eq(true);
+                        expect(window.AMapUI.version.startsWith('1.1')).eq(true);
+                        expect(Boolean(window.Loca)).eq(false);
+                        AMapLoader.load({ Loca: {} }).then(() => {
+                            expect(Boolean(window.AMap)).eq(true);
+                            expect(window.AMap.v).eq('1.4.15');
+                            expect(Boolean(window.AMapUI)).eq(true);
+                            expect(window.AMapUI.version.startsWith('1.1')).eq(true);
+                            expect(Boolean(window.Loca)).eq(true);
+                            expect(window.Loca.version).eq('1.3.2');
+                            done()
+                        })
+                    })
+                }).catch(done)
+            })
+        })
+        mocha.run()
+    </script>
+
+
+    </script>
+</body>
+
+</html>

node_modules/@amap/amap-jsapi-loader/index.d.ts

@@ -0,0 +1,15 @@
+declare var load: (options: {
+    key: string; // 申请好的Web端开发者Key，首次调用 load 时必填
+    version: string; // 指定要加载的 JSAPI 的版本，缺省时默认为 1.4.15
+    plugins?: string[]; //插件列表
+    // 是否加载 AMapUI，缺省不加载
+    AMapUI?: {
+        version?: string; // AMapUI 缺省 1.1
+        plugins?: string[]; // 需要加载的 AMapUI ui插件
+    };
+    // 是否加载 Loca， 缺省不加载
+    Loca?: {
+        version?: string; // Loca 版本，缺省 1.3.2
+    };
+}) => Promise<any>;
+export { load };

node_modules/@amap/amap-jsapi-loader/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@amap/amap-jsapi-loader",
+  "version": "1.0.1",
+  "description": "高德官网提供的地图JSAPI加载器，可以避免多种异步加载API的错误用法",
+  "main": "dist/index.js",
+  "types": "index.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "build": "rollup -c rollup.config.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@gitlab.alibaba-inc.com:amap-web/amap-jsapi-loader.git"
+  },
+  "keywords": [
+    "amap",
+    "jsapi",
+    "sdk",
+    "loader",
+    "地图",
+    "高德"
+  ],
+  "author": "mengmeng.du@alibaba-inc.com",
+  "license": "MIT",
+  "devDependencies": {
+    "@ampproject/rollup-plugin-closure-compiler": "^0.23.0",
+    "@babel/core": "^7.8.7",
+    "@babel/preset-env": "^7.8.7",
+    "rollup": "^1.32.0",
+    "rollup-plugin-babel": "^4.3.3",
+    "rollup-plugin-server": "^0.7.0",
+    "rollup-plugin-typescript2": "^0.27.1",
+    "typescript": "^3.9.7"
+  }
+}

node_modules/@amap/amap-jsapi-loader/rollup.config.js

@@ -0,0 +1,25 @@
+import server from "rollup-plugin-server";
+import babel from "rollup-plugin-babel";
+import compiler from "@ampproject/rollup-plugin-closure-compiler";
+import rollupTypescript from 'rollup-plugin-typescript2';
+
+export default {
+    input: "src/index.ts",
+    output: {
+        file: "dist/index.js",
+        format: "umd",
+        name: "AMapLoader",
+    },
+    plugins: [
+        rollupTypescript(),
+        babel({
+            presets: [["@babel/env", { targets: { ie: 9 } }]],
+        }),
+        compiler(),
+        server({
+            contentBase: "./",
+            host: "127.0.0.1",
+            port: 3601,
+        }),
+    ],
+};

node_modules/@amap/amap-jsapi-loader/src/global.d.ts

@@ -0,0 +1,5 @@
+declare var AMap: any;
+declare var AMapUI: any;
+declare var Loca: any;
+
+declare var ___onAPILoaded: any;

node_modules/@amap/amap-jsapi-loader/src/index.ts

@@ -0,0 +1,367 @@
+if (!window) {
+    throw Error("AMap JSAPI can only be used in Browser.");
+}
+enum LoadStatus {
+    notload = "notload",
+    loading = "loading",
+    loaded = "loaded",
+    failed = "failed",
+}
+let config = {
+    key: "",
+    AMap: {
+        version: "1.4.15",
+        plugins: [],
+    },
+    AMapUI: {
+        version: "1.1",
+        plugins: [],
+    },
+    Loca: {
+        version: "1.3.2",
+    },
+};
+
+let Status = {
+    AMap: LoadStatus.notload,
+    AMapUI: LoadStatus.notload,
+    Loca: LoadStatus.notload,
+};
+let Callback = {
+    AMap: [],
+    AMapUI: [],
+    Loca: [],
+};
+
+let onloadCBKs = [];
+const onload = function (callback) {
+    if (typeof callback == "function") {
+        if (Status.AMap === LoadStatus.loaded) {
+            callback(window.AMap);
+            return;
+        }
+        onloadCBKs.push(callback);
+    }
+};
+
+interface LoadOption {
+    key: string;
+    version?: string;
+    plugins?: string[];
+    AMapUI?: {
+        version?: string;
+        plugins?: string[];
+    };
+    Loca?: {
+        version?: string;
+    };
+}
+function appendOther(option: LoadOption): Promise<any> {
+    let pros: Promise<void>[] = [];
+    if (option.AMapUI) {
+        pros.push(loadAMapUI(option.AMapUI));
+    }
+    if (option.Loca) {
+        pros.push(loadLoca(option.Loca));
+    }
+    return Promise.all(pros);
+}
+function loadAMapUI(params: { version?: string; plugins?: string[] }): Promise<void> {
+    return new Promise((res, rej) => {
+        const newPlugins: string[] = [];
+        if (params.plugins) {
+            for (var i = 0; i < params.plugins.length; i += 1) {
+                if (config.AMapUI.plugins.indexOf(params.plugins[i]) == -1) {
+                    newPlugins.push(params.plugins[i]);
+                }
+            }
+        }
+        if (Status.AMapUI === LoadStatus.failed) {
+            rej("前次请求 AMapUI 失败");
+        } else if (Status.AMapUI === LoadStatus.notload) {
+            Status.AMapUI = LoadStatus.loading;
+            config.AMapUI.version = params.version || config.AMapUI.version;
+            const version = config.AMapUI.version;
+            const parentNode = document.body || document.head;
+            const script = document.createElement("script");
+            script.type = "text/javascript";
+            script.src = `https://webapi.amap.com/ui/${version}/main.js`;
+
+            script.onerror = (e) => {
+                Status.AMapUI = LoadStatus.failed;
+                rej("请求 AMapUI 失败");
+            };
+            script.onload = () => {
+                Status.AMapUI = LoadStatus.loaded;
+                if (newPlugins.length) {
+                    window.AMapUI.loadUI(newPlugins, function () {
+                        for (let i = 0, len = newPlugins.length; i < len; i++) {
+                            const path = newPlugins[i];
+                            const name = path.split("/").slice(-1)[0];
+                            window.AMapUI[name] = arguments[i];
+                        }
+                        res();
+                        while (Callback.AMapUI.length) {
+                            Callback.AMapUI.splice(0, 1)[0]();
+                        }
+                    });
+                } else {
+                    res();
+                    while (Callback.AMapUI.length) {
+                        Callback.AMapUI.splice(0, 1)[0]();
+                    }
+                }
+            };
+            parentNode.appendChild(script);
+        } else if (Status.AMapUI === LoadStatus.loaded) {
+            if (params.version && params.version !== config.AMapUI.version) {
+                rej("不允许多个版本 AMapUI 混用");
+            } else {
+                if (newPlugins.length) {
+                    window.AMapUI.loadUI(newPlugins, function () {
+                        for (let i = 0, len = newPlugins.length; i < len; i++) {
+                            const path = newPlugins[i];
+                            const name = path.split("/").slice(-1)[0];
+                            window.AMapUI[name] = arguments[i];
+                        }
+                        res();
+                    });
+                } else {
+                    res();
+                }
+            }
+        } else {
+            if (params.version && params.version !== config.AMapUI.version) {
+                rej("不允许多个版本 AMapUI 混用");
+            } else {
+                Callback.AMapUI.push((err) => {
+                    if (err) {
+                        rej(err);
+                    } else {
+                        if (newPlugins.length) {
+                            window.AMapUI.loadUI(newPlugins, function () {
+                                for (let i = 0, len = newPlugins.length; i < len; i++) {
+                                    const path = newPlugins[i];
+                                    const name = path.split("/").slice(-1)[0];
+                                    window.AMapUI[name] = arguments[i];
+                                }
+                                res();
+                            });
+                        } else {
+                            res();
+                        }
+                    }
+                });
+            }
+        }
+    });
+}
+
+function loadLoca(params: { version?: string }): Promise<void> {
+    return new Promise((res, rej) => {
+        if (Status.Loca === LoadStatus.failed) {
+            rej("前次请求 Loca 失败");
+        } else if (Status.Loca === LoadStatus.notload) {
+            Status.Loca = LoadStatus.loading;
+            config.Loca.version = params.version || config.Loca.version;
+            const version = config.Loca.version;
+            const isApiV2 = config.AMap.version.startsWith("2");
+            const isLocaV2 = version.startsWith("2");
+            if ((isApiV2 && !isLocaV2) || (!isApiV2 && isLocaV2)) {
+                rej("JSAPI 与 Loca 版本不对应！！");
+                return;
+            }
+            const key = config.key;
+            const parentNode = document.body || document.head;
+            const script = document.createElement("script");
+            script.type = "text/javascript";
+            script.src = `https://webapi.amap.com/loca?v=${version}&key=${key}`;
+
+            script.onerror = (e) => {
+                Status.Loca = LoadStatus.failed;
+                rej("请求 AMapUI 失败");
+            };
+            script.onload = () => {
+                Status.Loca = LoadStatus.loaded;
+                res();
+                while (Callback.Loca.length) {
+                    Callback.Loca.splice(0, 1)[0]();
+                }
+            };
+            parentNode.appendChild(script);
+        } else if (Status.Loca === LoadStatus.loaded) {
+            if (params.version && params.version !== config.Loca.version) {
+                rej("不允许多个版本 Loca 混用");
+            } else {
+                res();
+            }
+        } else {
+            if (params.version && params.version !== config.Loca.version) {
+                rej("不允许多个版本 Loca 混用");
+            } else {
+                Callback.Loca.push((err) => {
+                    if (err) {
+                        rej(err);
+                    } else {
+                        rej();
+                    }
+                });
+            }
+        }
+    });
+}
+
+const load = function (options: LoadOption) {
+    return new Promise((resolve, reject) => {
+        if (Status.AMap == LoadStatus.failed) {
+            reject("");
+        } else if (Status.AMap == LoadStatus.notload) {
+            //初次加载
+            let { key, version, plugins } = options;
+            if (!key) {
+                reject("请填写key");
+                return;
+            }
+            if (window.AMap && location.host !== "lbs.amap.com") {
+                reject("禁止多种API加载方式混用");
+            }
+            config.key = key;
+            config.AMap.version = version || config.AMap.version;
+            config.AMap.plugins = plugins || config.AMap.plugins;
+            Status.AMap = LoadStatus.loading;
+
+            const parentNode = document.body || document.head;
+
+            window.___onAPILoaded = function (err) {
+                delete window.___onAPILoaded;
+                if (err) {
+                    Status.AMap = LoadStatus.failed;
+                    reject(err);
+                } else {
+                    Status.AMap = LoadStatus.loaded;
+                    appendOther(options)
+                        .then(() => {
+                            resolve(window.AMap);
+                        })
+                        .catch(reject);
+                    while (onloadCBKs.length) {
+                        onloadCBKs.splice(0, 1)[0]();
+                    }
+                }
+            };
+            const script = document.createElement("script");
+            script.type = "text/javascript";
+
+            script.src =
+                "https://webapi.amap.com/maps?callback=___onAPILoaded&v=" +
+                config.AMap.version +
+                "&key=" +
+                key +
+                "&plugin=" +
+                config.AMap.plugins.join(",");
+            script.onerror = (e) => {
+                Status.AMap = LoadStatus.failed;
+                reject(e);
+            };
+            parentNode.appendChild(script);
+        } else if (Status.AMap == LoadStatus.loaded) {
+            //deal multi load
+            if (options.key && options.key !== config.key) {
+                reject("多个不一致的 key");
+                return;
+            }
+            if (options.version && options.version !== config.AMap.version) {
+                reject("不允许多个版本 JSAPI 混用");
+                return;
+            }
+            const newPlugins = [];
+            if (options.plugins) {
+                for (var i = 0; i < options.plugins.length; i += 1) {
+                    if (config.AMap.plugins.indexOf(options.plugins[i]) == -1) {
+                        newPlugins.push(options.plugins[i]);
+                    }
+                }
+            }
+            if (newPlugins.length) {
+                window.AMap.plugin(newPlugins, () => {
+                    appendOther(options)
+                        .then(() => {
+                            resolve(window.AMap);
+                        })
+                        .catch(reject);
+                });
+            } else {
+                appendOther(options)
+                    .then(() => {
+                        resolve(window.AMap);
+                    })
+                    .catch(reject);
+            }
+        } else {
+            // loading
+            if (options.key && options.key !== config.key) {
+                reject("多个不一致的 key");
+                return;
+            }
+            if (options.version && options.version !== config.AMap.version) {
+                reject("不允许多个版本 JSAPI 混用");
+                return;
+            }
+            const newPlugins = [];
+            if (options.plugins) {
+                for (var i = 0; i < options.plugins.length; i += 1) {
+                    if (config.AMap.plugins.indexOf(options.plugins[i]) == -1) {
+                        newPlugins.push(options.plugins[i]);
+                    }
+                }
+            }
+            onload(() => {
+                if (newPlugins.length) {
+                    window.AMap.plugin(newPlugins, () => {
+                        appendOther(options)
+                            .then(() => {
+                                resolve(window.AMap);
+                            })
+                            .catch(reject);
+                    });
+                } else {
+                    appendOther(options)
+                        .then(() => {
+                            resolve(window.AMap);
+                        })
+                        .catch(reject);
+                }
+            });
+        }
+    });
+};
+function reset() {
+    delete window.AMap;
+    delete window.AMapUI;
+    delete window.Loca;
+    config = {
+        key: "",
+        AMap: {
+            version: "1.4.15",
+            plugins: [],
+        },
+        AMapUI: {
+            version: "1.1",
+            plugins: [],
+        },
+        Loca: {
+            version: "1.3.2",
+        },
+    };
+    Status = {
+        AMap: LoadStatus.notload,
+        AMapUI: LoadStatus.notload,
+        Loca: LoadStatus.notload,
+    };
+    Callback = {
+        AMap: [],
+        AMapUI: [],
+        Loca: [],
+    };
+}
+export default { load, reset };

node_modules/@amap/amap-jsapi-loader/test/demo.ts

@@ -0,0 +1,17 @@
+import AMapLoader from "../";
+// import {  } from "@ali/test-amap-jsapi";
+
+AMapLoader.load({
+  key: "test",
+  version: "2.0"
+}).then(() => {
+  new AMap.Circle({})
+  const map = new AMap.Map("div");
+  map.on("complete", () => {
+    const circle = new AMap.Circle({
+      center: [135, 45],
+      radius: 40
+    });
+    map.add(circle);
+  });
+});

node_modules/@amap/amap-jsapi-loader/test/test.ts

@@ -0,0 +1,7 @@
+import AMapLoader from "../";
+import "@amap/amap-jsapi-loader";
+
+AMapLoader.load({
+  key: "test",
+  version: "2.0"
+}).then(() => {});

node_modules/@ampproject/remapping/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2019 Google LLC
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/@ampproject/remapping/README.md

@@ -0,0 +1,218 @@
+# @ampproject/remapping
+
+> Remap sequential sourcemaps through transformations to point at the original source code
+
+Remapping allows you to take the sourcemaps generated through transforming your code and "remap"
+them to the original source locations. Think "my minified code, transformed with babel and bundled
+with webpack", all pointing to the correct location in your original source code.
+
+With remapping, none of your source code transformations need to be aware of the input's sourcemap,
+they only need to generate an output sourcemap. This greatly simplifies building custom
+transformations (think a find-and-replace).
+
+## Installation
+
+```sh
+npm install @ampproject/remapping
+```
+
+## Usage
+
+```typescript
+function remapping(
+  map: SourceMap | SourceMap[],
+  loader: (file: string, ctx: LoaderContext) => (SourceMap | null | undefined),
+  options?: { excludeContent: boolean, decodedMappings: boolean }
+): SourceMap;
+
+// LoaderContext gives the loader the importing sourcemap, tree depth, the ability to override the
+// "source" location (where child sources are resolved relative to, or the location of original
+// source), and the ability to override the "content" of an original source for inclusion in the
+// output sourcemap.
+type LoaderContext = {
+ readonly importer: string;
+ readonly depth: number;
+ source: string;
+ content: string | null | undefined;
+}
+```
+
+`remapping` takes the final output sourcemap, and a `loader` function. For every source file pointer
+in the sourcemap, the `loader` will be called with the resolved path. If the path itself represents
+a transformed file (it has a sourcmap associated with it), then the `loader` should return that
+sourcemap. If not, the path will be treated as an original, untransformed source code.
+
+```js
+// Babel transformed "helloworld.js" into "transformed.js"
+const transformedMap = JSON.stringify({
+  file: 'transformed.js',
+  // 1st column of 2nd line of output file translates into the 1st source
+  // file, line 3, column 2
+  mappings: ';CAEE',
+  sources: ['helloworld.js'],
+  version: 3,
+});
+
+// Uglify minified "transformed.js" into "transformed.min.js"
+const minifiedTransformedMap = JSON.stringify({
+  file: 'transformed.min.js',
+  // 0th column of 1st line of output file translates into the 1st source
+  // file, line 2, column 1.
+  mappings: 'AACC',
+  names: [],
+  sources: ['transformed.js'],
+  version: 3,
+});
+
+const remapped = remapping(
+  minifiedTransformedMap,
+  (file, ctx) => {
+
+    // The "transformed.js" file is an transformed file.
+    if (file === 'transformed.js') {
+      // The root importer is empty.
+      console.assert(ctx.importer === '');
+      // The depth in the sourcemap tree we're currently loading.
+      // The root `minifiedTransformedMap` is depth 0, and its source children are depth 1, etc.
+      console.assert(ctx.depth === 1);
+
+      return transformedMap;
+    }
+
+    // Loader will be called to load transformedMap's source file pointers as well.
+    console.assert(file === 'helloworld.js');
+    // `transformed.js`'s sourcemap points into `helloworld.js`.
+    console.assert(ctx.importer === 'transformed.js');
+    // This is a source child of `transformed`, which is a source child of `minifiedTransformedMap`.
+    console.assert(ctx.depth === 2);
+    return null;
+  }
+);
+
+console.log(remapped);
+// {
+//   file: 'transpiled.min.js',
+//   mappings: 'AAEE',
+//   sources: ['helloworld.js'],
+//   version: 3,
+// };
+```
+
+In this example, `loader` will be called twice:
+
+1. `"transformed.js"`, the first source file pointer in the `minifiedTransformedMap`. We return the
+   associated sourcemap for it (its a transformed file, after all) so that sourcemap locations can
+   be traced through it into the source files it represents.
+2. `"helloworld.js"`, our original, unmodified source code. This file does not have a sourcemap, so
+   we return `null`.
+
+The `remapped` sourcemap now points from `transformed.min.js` into locations in `helloworld.js`. If
+you were to read the `mappings`, it says "0th column of the first line output line points to the 1st
+column of the 2nd line of the file `helloworld.js`".
+
+### Multiple transformations of a file
+
+As a convenience, if you have multiple single-source transformations of a file, you may pass an
+array of sourcemap files in the order of most-recent transformation sourcemap first. Note that this
+changes the `importer` and `depth` of each call to our loader. So our above example could have been
+written as:
+
+```js
+const remapped = remapping(
+  [minifiedTransformedMap, transformedMap],
+  () => null
+);
+
+console.log(remapped);
+// {
+//   file: 'transpiled.min.js',
+//   mappings: 'AAEE',
+//   sources: ['helloworld.js'],
+//   version: 3,
+// };
+```
+
+### Advanced control of the loading graph
+
+#### `source`
+
+The `source` property can overridden to any value to change the location of the current load. Eg,
+for an original source file, it allows us to change the location to the original source regardless
+of what the sourcemap source entry says. And for transformed files, it allows us to change the
+relative resolving location for child sources of the loaded sourcemap.
+
+```js
+const remapped = remapping(
+  minifiedTransformedMap,
+  (file, ctx) => {
+
+    if (file === 'transformed.js') {
+      // We pretend the transformed.js file actually exists in the 'src/' directory. When the nested
+      // source files are loaded, they will now be relative to `src/`.
+      ctx.source = 'src/transformed.js';
+      return transformedMap;
+    }
+
+    console.assert(file === 'src/helloworld.js');
+    // We could futher change the source of this original file, eg, to be inside a nested directory
+    // itself. This will be reflected in the remapped sourcemap.
+    ctx.source = 'src/nested/transformed.js';
+    return null;
+  }
+);
+
+console.log(remapped);
+// {
+//   …,
+//   sources: ['src/nested/helloworld.js'],
+// };
+```
+
+
+#### `content`
+
+The `content` property can be overridden when we encounter an original source file. Eg, this allows
+you to manually provide the source content of the original file regardless of whether the
+`sourcesContent` field is present in the parent sourcemap. It can also be set to `null` to remove
+the source content.
+
+```js
+const remapped = remapping(
+  minifiedTransformedMap,
+  (file, ctx) => {
+
+    if (file === 'transformed.js') {
+      // transformedMap does not include a `sourcesContent` field, so usually the remapped sourcemap
+      // would not include any `sourcesContent` values.
+      return transformedMap;
+    }
+
+    console.assert(file === 'helloworld.js');
+    // We can read the file to provide the source content.
+    ctx.content = fs.readFileSync(file, 'utf8');
+    return null;
+  }
+);
+
+console.log(remapped);
+// {
+//   …,
+//   sourcesContent: [
+//     'console.log("Hello world!")',
+//   ],
+// };
+```
+
+### Options
+
+#### excludeContent
+
+By default, `excludeContent` is `false`. Passing `{ excludeContent: true }` will exclude the
+`sourcesContent` field from the returned sourcemap. This is mainly useful when you want to reduce
+the size out the sourcemap.
+
+#### decodedMappings
+
+By default, `decodedMappings` is `false`. Passing `{ decodedMappings: true }` will leave the
+`mappings` field in a [decoded state](https://github.com/rich-harris/sourcemap-codec) instead of
+encoding into a VLQ string.

node_modules/@ampproject/remapping/dist/remapping.mjs

@@ -0,0 +1,204 @@
+import { decodedMappings, traceSegment, TraceMap } from '@jridgewell/trace-mapping';
+import { GenMapping, addSegment, setSourceContent, decodedMap, encodedMap } from '@jridgewell/gen-mapping';
+
+const SOURCELESS_MAPPING = {
+    source: null,
+    column: null,
+    line: null,
+    name: null,
+    content: null,
+};
+const EMPTY_SOURCES = [];
+function Source(map, sources, source, content) {
+    return {
+        map,
+        sources,
+        source,
+        content,
+    };
+}
+/**
+ * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes
+ * (which may themselves be SourceMapTrees).
+ */
+function MapSource(map, sources) {
+    return Source(map, sources, '', null);
+}
+/**
+ * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
+ * segment tracing ends at the `OriginalSource`.
+ */
+function OriginalSource(source, content) {
+    return Source(null, EMPTY_SOURCES, source, content);
+}
+/**
+ * traceMappings is only called on the root level SourceMapTree, and begins the process of
+ * resolving each mapping in terms of the original source files.
+ */
+function traceMappings(tree) {
+    const gen = new GenMapping({ file: tree.map.file });
+    const { sources: rootSources, map } = tree;
+    const rootNames = map.names;
+    const rootMappings = decodedMappings(map);
+    for (let i = 0; i < rootMappings.length; i++) {
+        const segments = rootMappings[i];
+        let lastSource = null;
+        let lastSourceLine = null;
+        let lastSourceColumn = null;
+        for (let j = 0; j < segments.length; j++) {
+            const segment = segments[j];
+            const genCol = segment[0];
+            let traced = SOURCELESS_MAPPING;
+            // 1-length segments only move the current generated column, there's no source information
+            // to gather from it.
+            if (segment.length !== 1) {
+                const source = rootSources[segment[1]];
+                traced = originalPositionFor(source, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : '');
+                // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a
+                // respective segment into an original source.
+                if (traced == null)
+                    continue;
+            }
+            // So we traced a segment down into its original source file. Now push a
+            // new segment pointing to this location.
+            const { column, line, name, content, source } = traced;
+            if (line === lastSourceLine && column === lastSourceColumn && source === lastSource) {
+                continue;
+            }
+            lastSourceLine = line;
+            lastSourceColumn = column;
+            lastSource = source;
+            // Sigh, TypeScript can't figure out source/line/column are either all null, or all non-null...
+            addSegment(gen, i, genCol, source, line, column, name);
+            if (content != null)
+                setSourceContent(gen, source, content);
+        }
+    }
+    return gen;
+}
+/**
+ * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own
+ * child SourceMapTrees, until we find the original source map.
+ */
+function originalPositionFor(source, line, column, name) {
+    if (!source.map) {
+        return { column, line, name, source: source.source, content: source.content };
+    }
+    const segment = traceSegment(source.map, line, column);
+    // If we couldn't find a segment, then this doesn't exist in the sourcemap.
+    if (segment == null)
+        return null;
+    // 1-length segments only move the current generated column, there's no source information
+    // to gather from it.
+    if (segment.length === 1)
+        return SOURCELESS_MAPPING;
+    return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name);
+}
+
+function asArray(value) {
+    if (Array.isArray(value))
+        return value;
+    return [value];
+}
+/**
+ * Recursively builds a tree structure out of sourcemap files, with each node
+ * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
+ * `OriginalSource`s and `SourceMapTree`s.
+ *
+ * Every sourcemap is composed of a collection of source files and mappings
+ * into locations of those source files. When we generate a `SourceMapTree` for
+ * the sourcemap, we attempt to load each source file's own sourcemap. If it
+ * does not have an associated sourcemap, it is considered an original,
+ * unmodified source file.
+ */
+function buildSourceMapTree(input, loader) {
+    const maps = asArray(input).map((m) => new TraceMap(m, ''));
+    const map = maps.pop();
+    for (let i = 0; i < maps.length; i++) {
+        if (maps[i].sources.length > 1) {
+            throw new Error(`Transformation map ${i} must have exactly one source file.\n` +
+                'Did you specify these with the most recent transformation maps first?');
+        }
+    }
+    let tree = build(map, loader, '', 0);
+    for (let i = maps.length - 1; i >= 0; i--) {
+        tree = MapSource(maps[i], [tree]);
+    }
+    return tree;
+}
+function build(map, loader, importer, importerDepth) {
+    const { resolvedSources, sourcesContent } = map;
+    const depth = importerDepth + 1;
+    const children = resolvedSources.map((sourceFile, i) => {
+        // The loading context gives the loader more information about why this file is being loaded
+        // (eg, from which importer). It also allows the loader to override the location of the loaded
+        // sourcemap/original source, or to override the content in the sourcesContent field if it's
+        // an unmodified source file.
+        const ctx = {
+            importer,
+            depth,
+            source: sourceFile || '',
+            content: undefined,
+        };
+        // Use the provided loader callback to retrieve the file's sourcemap.
+        // TODO: We should eventually support async loading of sourcemap files.
+        const sourceMap = loader(ctx.source, ctx);
+        const { source, content } = ctx;
+        // If there is a sourcemap, then we need to recurse into it to load its source files.
+        if (sourceMap)
+            return build(new TraceMap(sourceMap, source), loader, source, depth);
+        // Else, it's an an unmodified source file.
+        // The contents of this unmodified source file can be overridden via the loader context,
+        // allowing it to be explicitly null or a string. If it remains undefined, we fall back to
+        // the importing sourcemap's `sourcesContent` field.
+        const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;
+        return OriginalSource(source, sourceContent);
+    });
+    return MapSource(map, children);
+}
+
+/**
+ * A SourceMap v3 compatible sourcemap, which only includes fields that were
+ * provided to it.
+ */
+class SourceMap {
+    constructor(map, options) {
+        const out = options.decodedMappings ? decodedMap(map) : encodedMap(map);
+        this.version = out.version; // SourceMap spec says this should be first.
+        this.file = out.file;
+        this.mappings = out.mappings;
+        this.names = out.names;
+        this.sourceRoot = out.sourceRoot;
+        this.sources = out.sources;
+        if (!options.excludeContent) {
+            this.sourcesContent = out.sourcesContent;
+        }
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+}
+
+/**
+ * Traces through all the mappings in the root sourcemap, through the sources
+ * (and their sourcemaps), all the way back to the original source location.
+ *
+ * `loader` will be called every time we encounter a source file. If it returns
+ * a sourcemap, we will recurse into that sourcemap to continue the trace. If
+ * it returns a falsey value, that source file is treated as an original,
+ * unmodified source file.
+ *
+ * Pass `excludeContent` to exclude any self-containing source file content
+ * from the output sourcemap.
+ *
+ * Pass `decodedMappings` to receive a SourceMap with decoded (instead of
+ * VLQ encoded) mappings.
+ */
+function remapping(input, loader, options) {
+    const opts = typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false };
+    const tree = buildSourceMapTree(input, loader);
+    return new SourceMap(traceMappings(tree), opts);
+}
+
+export { remapping as default };
+//# sourceMappingURL=remapping.mjs.map

node_modules/@ampproject/remapping/dist/remapping.umd.js

@@ -0,0 +1,209 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@jridgewell/trace-mapping'), require('@jridgewell/gen-mapping')) :
+    typeof define === 'function' && define.amd ? define(['@jridgewell/trace-mapping', '@jridgewell/gen-mapping'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.remapping = factory(global.traceMapping, global.genMapping));
+})(this, (function (traceMapping, genMapping) { 'use strict';
+
+    const SOURCELESS_MAPPING = {
+        source: null,
+        column: null,
+        line: null,
+        name: null,
+        content: null,
+    };
+    const EMPTY_SOURCES = [];
+    function Source(map, sources, source, content) {
+        return {
+            map,
+            sources,
+            source,
+            content,
+        };
+    }
+    /**
+     * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes
+     * (which may themselves be SourceMapTrees).
+     */
+    function MapSource(map, sources) {
+        return Source(map, sources, '', null);
+    }
+    /**
+     * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
+     * segment tracing ends at the `OriginalSource`.
+     */
+    function OriginalSource(source, content) {
+        return Source(null, EMPTY_SOURCES, source, content);
+    }
+    /**
+     * traceMappings is only called on the root level SourceMapTree, and begins the process of
+     * resolving each mapping in terms of the original source files.
+     */
+    function traceMappings(tree) {
+        const gen = new genMapping.GenMapping({ file: tree.map.file });
+        const { sources: rootSources, map } = tree;
+        const rootNames = map.names;
+        const rootMappings = traceMapping.decodedMappings(map);
+        for (let i = 0; i < rootMappings.length; i++) {
+            const segments = rootMappings[i];
+            let lastSource = null;
+            let lastSourceLine = null;
+            let lastSourceColumn = null;
+            for (let j = 0; j < segments.length; j++) {
+                const segment = segments[j];
+                const genCol = segment[0];
+                let traced = SOURCELESS_MAPPING;
+                // 1-length segments only move the current generated column, there's no source information
+                // to gather from it.
+                if (segment.length !== 1) {
+                    const source = rootSources[segment[1]];
+                    traced = originalPositionFor(source, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : '');
+                    // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a
+                    // respective segment into an original source.
+                    if (traced == null)
+                        continue;
+                }
+                // So we traced a segment down into its original source file. Now push a
+                // new segment pointing to this location.
+                const { column, line, name, content, source } = traced;
+                if (line === lastSourceLine && column === lastSourceColumn && source === lastSource) {
+                    continue;
+                }
+                lastSourceLine = line;
+                lastSourceColumn = column;
+                lastSource = source;
+                // Sigh, TypeScript can't figure out source/line/column are either all null, or all non-null...
+                genMapping.addSegment(gen, i, genCol, source, line, column, name);
+                if (content != null)
+                    genMapping.setSourceContent(gen, source, content);
+            }
+        }
+        return gen;
+    }
+    /**
+     * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own
+     * child SourceMapTrees, until we find the original source map.
+     */
+    function originalPositionFor(source, line, column, name) {
+        if (!source.map) {
+            return { column, line, name, source: source.source, content: source.content };
+        }
+        const segment = traceMapping.traceSegment(source.map, line, column);
+        // If we couldn't find a segment, then this doesn't exist in the sourcemap.
+        if (segment == null)
+            return null;
+        // 1-length segments only move the current generated column, there's no source information
+        // to gather from it.
+        if (segment.length === 1)
+            return SOURCELESS_MAPPING;
+        return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name);
+    }
+
+    function asArray(value) {
+        if (Array.isArray(value))
+            return value;
+        return [value];
+    }
+    /**
+     * Recursively builds a tree structure out of sourcemap files, with each node
+     * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
+     * `OriginalSource`s and `SourceMapTree`s.
+     *
+     * Every sourcemap is composed of a collection of source files and mappings
+     * into locations of those source files. When we generate a `SourceMapTree` for
+     * the sourcemap, we attempt to load each source file's own sourcemap. If it
+     * does not have an associated sourcemap, it is considered an original,
+     * unmodified source file.
+     */
+    function buildSourceMapTree(input, loader) {
+        const maps = asArray(input).map((m) => new traceMapping.TraceMap(m, ''));
+        const map = maps.pop();
+        for (let i = 0; i < maps.length; i++) {
+            if (maps[i].sources.length > 1) {
+                throw new Error(`Transformation map ${i} must have exactly one source file.\n` +
+                    'Did you specify these with the most recent transformation maps first?');
+            }
+        }
+        let tree = build(map, loader, '', 0);
+        for (let i = maps.length - 1; i >= 0; i--) {
+            tree = MapSource(maps[i], [tree]);
+        }
+        return tree;
+    }
+    function build(map, loader, importer, importerDepth) {
+        const { resolvedSources, sourcesContent } = map;
+        const depth = importerDepth + 1;
+        const children = resolvedSources.map((sourceFile, i) => {
+            // The loading context gives the loader more information about why this file is being loaded
+            // (eg, from which importer). It also allows the loader to override the location of the loaded
+            // sourcemap/original source, or to override the content in the sourcesContent field if it's
+            // an unmodified source file.
+            const ctx = {
+                importer,
+                depth,
+                source: sourceFile || '',
+                content: undefined,
+            };
+            // Use the provided loader callback to retrieve the file's sourcemap.
+            // TODO: We should eventually support async loading of sourcemap files.
+            const sourceMap = loader(ctx.source, ctx);
+            const { source, content } = ctx;
+            // If there is a sourcemap, then we need to recurse into it to load its source files.
+            if (sourceMap)
+                return build(new traceMapping.TraceMap(sourceMap, source), loader, source, depth);
+            // Else, it's an an unmodified source file.
+            // The contents of this unmodified source file can be overridden via the loader context,
+            // allowing it to be explicitly null or a string. If it remains undefined, we fall back to
+            // the importing sourcemap's `sourcesContent` field.
+            const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;
+            return OriginalSource(source, sourceContent);
+        });
+        return MapSource(map, children);
+    }
+
+    /**
+     * A SourceMap v3 compatible sourcemap, which only includes fields that were
+     * provided to it.
+     */
+    class SourceMap {
+        constructor(map, options) {
+            const out = options.decodedMappings ? genMapping.decodedMap(map) : genMapping.encodedMap(map);
+            this.version = out.version; // SourceMap spec says this should be first.
+            this.file = out.file;
+            this.mappings = out.mappings;
+            this.names = out.names;
+            this.sourceRoot = out.sourceRoot;
+            this.sources = out.sources;
+            if (!options.excludeContent) {
+                this.sourcesContent = out.sourcesContent;
+            }
+        }
+        toString() {
+            return JSON.stringify(this);
+        }
+    }
+
+    /**
+     * Traces through all the mappings in the root sourcemap, through the sources
+     * (and their sourcemaps), all the way back to the original source location.
+     *
+     * `loader` will be called every time we encounter a source file. If it returns
+     * a sourcemap, we will recurse into that sourcemap to continue the trace. If
+     * it returns a falsey value, that source file is treated as an original,
+     * unmodified source file.
+     *
+     * Pass `excludeContent` to exclude any self-containing source file content
+     * from the output sourcemap.
+     *
+     * Pass `decodedMappings` to receive a SourceMap with decoded (instead of
+     * VLQ encoded) mappings.
+     */
+    function remapping(input, loader, options) {
+        const opts = typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false };
+        const tree = buildSourceMapTree(input, loader);
+        return new SourceMap(traceMappings(tree), opts);
+    }
+
+    return remapping;
+
+}));
+//# sourceMappingURL=remapping.umd.js.map

node_modules/@ampproject/remapping/dist/types/build-source-map-tree.d.ts

@@ -0,0 +1,14 @@
+import type { MapSource as MapSourceType } from './source-map-tree';
+import type { SourceMapInput, SourceMapLoader } from './types';
+/**
+ * Recursively builds a tree structure out of sourcemap files, with each node
+ * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
+ * `OriginalSource`s and `SourceMapTree`s.
+ *
+ * Every sourcemap is composed of a collection of source files and mappings
+ * into locations of those source files. When we generate a `SourceMapTree` for
+ * the sourcemap, we attempt to load each source file's own sourcemap. If it
+ * does not have an associated sourcemap, it is considered an original,
+ * unmodified source file.
+ */
+export default function buildSourceMapTree(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader): MapSourceType;

node_modules/@ampproject/remapping/dist/types/remapping.d.ts

@@ -0,0 +1,19 @@
+import SourceMap from './source-map';
+import type { SourceMapInput, SourceMapLoader, Options } from './types';
+export type { SourceMapSegment, EncodedSourceMap, EncodedSourceMap as RawSourceMap, DecodedSourceMap, SourceMapInput, SourceMapLoader, LoaderContext, Options, } from './types';
+/**
+ * Traces through all the mappings in the root sourcemap, through the sources
+ * (and their sourcemaps), all the way back to the original source location.
+ *
+ * `loader` will be called every time we encounter a source file. If it returns
+ * a sourcemap, we will recurse into that sourcemap to continue the trace. If
+ * it returns a falsey value, that source file is treated as an original,
+ * unmodified source file.
+ *
+ * Pass `excludeContent` to exclude any self-containing source file content
+ * from the output sourcemap.
+ *
+ * Pass `decodedMappings` to receive a SourceMap with decoded (instead of
+ * VLQ encoded) mappings.
+ */
+export default function remapping(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader, options?: boolean | Options): SourceMap;

node_modules/@ampproject/remapping/dist/types/source-map-tree.d.ts

@@ -0,0 +1,48 @@
+import { GenMapping } from '@jridgewell/gen-mapping';
+import type { TraceMap } from '@jridgewell/trace-mapping';
+export declare type SourceMapSegmentObject = {
+    column: number;
+    line: number;
+    name: string;
+    source: string;
+    content: string | null;
+} | {
+    column: null;
+    line: null;
+    name: null;
+    source: null;
+    content: null;
+};
+export declare type OriginalSource = {
+    map: TraceMap;
+    sources: Sources[];
+    source: string;
+    content: string | null;
+};
+export declare type MapSource = {
+    map: TraceMap;
+    sources: Sources[];
+    source: string;
+    content: string | null;
+};
+export declare type Sources = OriginalSource | MapSource;
+/**
+ * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes
+ * (which may themselves be SourceMapTrees).
+ */
+export declare function MapSource(map: TraceMap, sources: Sources[]): MapSource;
+/**
+ * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
+ * segment tracing ends at the `OriginalSource`.
+ */
+export declare function OriginalSource(source: string, content: string | null): OriginalSource;
+/**
+ * traceMappings is only called on the root level SourceMapTree, and begins the process of
+ * resolving each mapping in terms of the original source files.
+ */
+export declare function traceMappings(tree: MapSource): GenMapping;
+/**
+ * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own
+ * child SourceMapTrees, until we find the original source map.
+ */
+export declare function originalPositionFor(source: Sources, line: number, column: number, name: string): SourceMapSegmentObject | null;

node_modules/@ampproject/remapping/dist/types/source-map.d.ts

@@ -0,0 +1,17 @@
+import type { GenMapping } from '@jridgewell/gen-mapping';
+import type { DecodedSourceMap, EncodedSourceMap, Options } from './types';
+/**
+ * A SourceMap v3 compatible sourcemap, which only includes fields that were
+ * provided to it.
+ */
+export default class SourceMap {
+    file?: string | null;
+    mappings: EncodedSourceMap['mappings'] | DecodedSourceMap['mappings'];
+    sourceRoot?: string;
+    names: string[];
+    sources: (string | null)[];
+    sourcesContent?: (string | null)[];
+    version: 3;
+    constructor(map: GenMapping, options: Options);
+    toString(): string;
+}

node_modules/@ampproject/remapping/dist/types/types.d.ts

@@ -0,0 +1,14 @@
+import type { SourceMapInput } from '@jridgewell/trace-mapping';
+export type { SourceMapSegment, DecodedSourceMap, EncodedSourceMap, } from '@jridgewell/trace-mapping';
+export type { SourceMapInput };
+export declare type LoaderContext = {
+    readonly importer: string;
+    readonly depth: number;
+    source: string;
+    content: string | null | undefined;
+};
+export declare type SourceMapLoader = (file: string, ctx: LoaderContext) => SourceMapInput | null | undefined | void;
+export declare type Options = {
+    excludeContent?: boolean;
+    decodedMappings?: boolean;
+};

node_modules/@ampproject/remapping/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@ampproject/remapping",
+  "version": "2.2.0",
+  "description": "Remap sequential sourcemaps through transformations to point at the original source code",
+  "keywords": [
+    "source",
+    "map",
+    "remap"
+  ],
+  "main": "dist/remapping.umd.js",
+  "module": "dist/remapping.mjs",
+  "typings": "dist/types/remapping.d.ts",
+  "files": [
+    "dist"
+  ],
+  "author": "Justin Ridgewell <jridgewell@google.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ampproject/remapping.git"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "scripts": {
+    "build": "run-s -n build:*",
+    "build:rollup": "rollup -c rollup.config.js",
+    "build:ts": "tsc --project tsconfig.build.json",
+    "lint": "run-s -n lint:*",
+    "lint:prettier": "npm run test:lint:prettier -- --write",
+    "lint:ts": "npm run test:lint:ts -- --fix",
+    "prebuild": "rm -rf dist",
+    "prepublishOnly": "npm run preversion",
+    "preversion": "run-s test build",
+    "test": "run-s -n test:lint test:only",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand",
+    "test:lint": "run-s -n test:lint:*",
+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+    "test:only": "jest --coverage",
+    "test:watch": "jest --coverage --watch"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "8.3.2",
+    "@types/jest": "27.4.1",
+    "@typescript-eslint/eslint-plugin": "5.20.0",
+    "@typescript-eslint/parser": "5.20.0",
+    "eslint": "8.14.0",
+    "eslint-config-prettier": "8.5.0",
+    "jest": "27.5.1",
+    "jest-config": "27.5.1",
+    "npm-run-all": "4.1.5",
+    "prettier": "2.6.2",
+    "rollup": "2.70.2",
+    "ts-jest": "27.1.4",
+    "tslib": "2.4.0",
+    "typescript": "4.6.3"
+  },
+  "dependencies": {
+    "@jridgewell/gen-mapping": "^0.1.0",
+    "@jridgewell/trace-mapping": "^0.3.9"
+  }
+}

node_modules/@ant-design/colors/LICENSE

@@ -0,0 +1,22 @@
+MIT LICENSE
+
+Copyright (c) 2018-present Ant UED, https://xtech.antfin.com/
+
+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/@ant-design/colors/README.md

@@ -0,0 +1,95 @@
+<h1 align="center">Ant Design Colors</h1>
+
+<div align="center">
+
+:art: Color palettes calculator of [Ant Design](https://ant.design/docs/spec/colors).
+
+[![Travis](https://img.shields.io/travis/ant-design/ant-design-colors/master.svg?style=flat-square)](https://travis-ci.org/ant-design/ant-design-colors)
+[![Test coverage](https://img.shields.io/coveralls/ant-design/ant-design-colors.svg?style=flat-square)](https://coveralls.io/r/ant-design/ant-design-colors?branch=master)
+[![npm package](https://img.shields.io/npm/v/@ant-design/colors.svg?style=flat-square)](https://www.npmjs.org/package/@ant-design/colors)
+[![NPM downloads](http://img.shields.io/npm/dm/@ant-design/colors.svg?style=flat-square)](http://npmjs.com/@ant-design/colors)
+
+[![Dependencies](https://img.shields.io/david/ant-design/ant-design-colors.svg?style=flat-square)](https://david-dm.org/ant-design/ant-design-colors)
+[![DevDependencies](https://img.shields.io/david/dev/ant-design/ant-design-colors.svg?style=flat-square)](https://david-dm.org/ant-design/ant-design-colors?type=dev) [![Greenkeeper badge](https://badges.greenkeeper.io/ant-design/ant-design-colors.svg)](https://greenkeeper.io/)
+</div>
+
+![](https://user-images.githubusercontent.com/507615/55726820-43e68400-5a43-11e9-8541-b0fc28b78f37.png)
+
+## Install
+
+```bash
+$ npm install @ant-design/colors
+// or
+$ yarn add @ant-design/colors
+```
+
+## Usage
+
+```bash
+$ npm install @ant-design/colors --save
+```
+
+```js
+import { red, volcano, gold, yellow, lime, green, cyan, blue, geekblue, purple, magenta, grey } from '@ant-design/colors';
+
+console.log(blue); // ['#E6F7FF', '#BAE7FF', '#91D5FF', ''#69C0FF', '#40A9FF', '#1890FF', '#096DD9', '#0050B3', '#003A8C', '#002766']
+console.log(blue.primary); // '#1890FF'
+```
+
+```js
+import { generate, presetPalettes } from '@ant-design/colors';
+
+// Generate color palettes by a given color
+const colors = generate('#1890ff');
+console.log(colors); // ['#E6F7FF', '#BAE7FF', '#91D5FF', ''#69C0FF', '#40A9FF', '#1890FF', '#096DD9', '#0050B3', '#003A8C', '#002766']
+console.log(presetPalettes);
+/*
+{
+  red: [...],
+  volcano: [...],
+  orange: [...],
+  gold: [...],
+  yellow: [...],
+  lime: [...],
+  green: [...],
+  cyan: [...],
+  blue: [...],
+  geekblue: [...],
+  purple: [...],
+  magenta: [...],
+}
+*/
+```
+
+```js
+import { generate, presetDarkPalettes } from '@ant-design/colors';
+
+// Generate dark color palettes by a given color
+const colors = generate('#1890ff', {
+  theme: 'dark',
+  backgroundColor: '#141414'
+});
+console.log(colors); // ["#111d2c", "#112a45", "#15395b", "#164c7e", "#1765ad", "#177ddc", "#3993dc", "#65b7f3", "#8bcbf3", "#b2dcf3"]
+console.log(presetDarkPalettes);
+/*
+{
+  red: [...],
+  volcano: [...],
+  orange: [...],
+  gold: [...],
+  yellow: [...],
+  lime: [...],
+  green: [...],
+  cyan: [...],
+  blue: [...],
+  geekblue: [...],
+  purple: [...],
+  magenta: [...],
+}
+*/
+```
+
+## Articles
+
+- [Ant Design Colors](https://ant.design/docs/spec/colors)
+- [Ant Design 色板生成算法演进之路](https://zhuanlan.zhihu.com/p/32422584)

node_modules/@ant-design/colors/dist/index.esm.js

@@ -0,0 +1,235 @@
+import { inputToRGB, rgbToHex, rgbToHsv } from '@ctrl/tinycolor';
+
+var hueStep = 2; // 色相阶梯
+
+var saturationStep = 0.16; // 饱和度阶梯，浅色部分
+
+var saturationStep2 = 0.05; // 饱和度阶梯，深色部分
+
+var brightnessStep1 = 0.05; // 亮度阶梯，浅色部分
+
+var brightnessStep2 = 0.15; // 亮度阶梯，深色部分
+
+var lightColorCount = 5; // 浅色数量，主色上
+
+var darkColorCount = 4; // 深色数量，主色下
+// 暗色主题颜色映射关系表
+
+var darkColorMap = [{
+  index: 7,
+  opacity: 0.15
+}, {
+  index: 6,
+  opacity: 0.25
+}, {
+  index: 5,
+  opacity: 0.3
+}, {
+  index: 5,
+  opacity: 0.45
+}, {
+  index: 5,
+  opacity: 0.65
+}, {
+  index: 5,
+  opacity: 0.85
+}, {
+  index: 4,
+  opacity: 0.9
+}, {
+  index: 3,
+  opacity: 0.95
+}, {
+  index: 2,
+  opacity: 0.97
+}, {
+  index: 1,
+  opacity: 0.98
+}]; // Wrapper function ported from TinyColor.prototype.toHsv
+// Keep it here because of `hsv.h * 360`
+
+function toHsv(_ref) {
+  var r = _ref.r,
+      g = _ref.g,
+      b = _ref.b;
+  var hsv = rgbToHsv(r, g, b);
+  return {
+    h: hsv.h * 360,
+    s: hsv.s,
+    v: hsv.v
+  };
+} // Wrapper function ported from TinyColor.prototype.toHexString
+// Keep it here because of the prefix `#`
+
+
+function toHex(_ref2) {
+  var r = _ref2.r,
+      g = _ref2.g,
+      b = _ref2.b;
+  return "#".concat(rgbToHex(r, g, b, false));
+} // Wrapper function ported from TinyColor.prototype.mix, not treeshakable.
+// Amount in range [0, 1]
+// Assume color1 & color2 has no alpha, since the following src code did so.
+
+
+function mix(rgb1, rgb2, amount) {
+  var p = amount / 100;
+  var rgb = {
+    r: (rgb2.r - rgb1.r) * p + rgb1.r,
+    g: (rgb2.g - rgb1.g) * p + rgb1.g,
+    b: (rgb2.b - rgb1.b) * p + rgb1.b
+  };
+  return rgb;
+}
+
+function getHue(hsv, i, light) {
+  var hue; // 根据色相不同，色相转向不同
+
+  if (Math.round(hsv.h) >= 60 && Math.round(hsv.h) <= 240) {
+    hue = light ? Math.round(hsv.h) - hueStep * i : Math.round(hsv.h) + hueStep * i;
+  } else {
+    hue = light ? Math.round(hsv.h) + hueStep * i : Math.round(hsv.h) - hueStep * i;
+  }
+
+  if (hue < 0) {
+    hue += 360;
+  } else if (hue >= 360) {
+    hue -= 360;
+  }
+
+  return hue;
+}
+
+function getSaturation(hsv, i, light) {
+  // grey color don't change saturation
+  if (hsv.h === 0 && hsv.s === 0) {
+    return hsv.s;
+  }
+
+  var saturation;
+
+  if (light) {
+    saturation = hsv.s - saturationStep * i;
+  } else if (i === darkColorCount) {
+    saturation = hsv.s + saturationStep;
+  } else {
+    saturation = hsv.s + saturationStep2 * i;
+  } // 边界值修正
+
+
+  if (saturation > 1) {
+    saturation = 1;
+  } // 第一格的 s 限制在 0.06-0.1 之间
+
+
+  if (light && i === lightColorCount && saturation > 0.1) {
+    saturation = 0.1;
+  }
+
+  if (saturation < 0.06) {
+    saturation = 0.06;
+  }
+
+  return Number(saturation.toFixed(2));
+}
+
+function getValue(hsv, i, light) {
+  var value;
+
+  if (light) {
+    value = hsv.v + brightnessStep1 * i;
+  } else {
+    value = hsv.v - brightnessStep2 * i;
+  }
+
+  if (value > 1) {
+    value = 1;
+  }
+
+  return Number(value.toFixed(2));
+}
+
+function generate(color) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var patterns = [];
+  var pColor = inputToRGB(color);
+
+  for (var i = lightColorCount; i > 0; i -= 1) {
+    var hsv = toHsv(pColor);
+    var colorString = toHex(inputToRGB({
+      h: getHue(hsv, i, true),
+      s: getSaturation(hsv, i, true),
+      v: getValue(hsv, i, true)
+    }));
+    patterns.push(colorString);
+  }
+
+  patterns.push(toHex(pColor));
+
+  for (var _i = 1; _i <= darkColorCount; _i += 1) {
+    var _hsv = toHsv(pColor);
+
+    var _colorString = toHex(inputToRGB({
+      h: getHue(_hsv, _i),
+      s: getSaturation(_hsv, _i),
+      v: getValue(_hsv, _i)
+    }));
+
+    patterns.push(_colorString);
+  } // dark theme patterns
+
+
+  if (opts.theme === 'dark') {
+    return darkColorMap.map(function (_ref3) {
+      var index = _ref3.index,
+          opacity = _ref3.opacity;
+      var darkColorString = toHex(mix(inputToRGB(opts.backgroundColor || '#141414'), inputToRGB(patterns[index]), opacity * 100));
+      return darkColorString;
+    });
+  }
+
+  return patterns;
+}
+
+var presetPrimaryColors = {
+  red: '#F5222D',
+  volcano: '#FA541C',
+  orange: '#FA8C16',
+  gold: '#FAAD14',
+  yellow: '#FADB14',
+  lime: '#A0D911',
+  green: '#52C41A',
+  cyan: '#13C2C2',
+  blue: '#1890FF',
+  geekblue: '#2F54EB',
+  purple: '#722ED1',
+  magenta: '#EB2F96',
+  grey: '#666666'
+};
+var presetPalettes = {};
+var presetDarkPalettes = {};
+Object.keys(presetPrimaryColors).forEach(function (key) {
+  presetPalettes[key] = generate(presetPrimaryColors[key]);
+  presetPalettes[key].primary = presetPalettes[key][5]; // dark presetPalettes
+
+  presetDarkPalettes[key] = generate(presetPrimaryColors[key], {
+    theme: 'dark',
+    backgroundColor: '#141414'
+  });
+  presetDarkPalettes[key].primary = presetDarkPalettes[key][5];
+});
+var red = presetPalettes.red;
+var volcano = presetPalettes.volcano;
+var gold = presetPalettes.gold;
+var orange = presetPalettes.orange;
+var yellow = presetPalettes.yellow;
+var lime = presetPalettes.lime;
+var green = presetPalettes.green;
+var cyan = presetPalettes.cyan;
+var blue = presetPalettes.blue;
+var geekblue = presetPalettes.geekblue;
+var purple = presetPalettes.purple;
+var magenta = presetPalettes.magenta;
+var grey = presetPalettes.grey;
+
+export { blue, cyan, geekblue, generate, gold, green, grey, lime, magenta, orange, presetDarkPalettes, presetPalettes, presetPrimaryColors, purple, red, volcano, yellow };

node_modules/@ant-design/colors/dist/index.js

@@ -0,0 +1,255 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tinycolor = require('@ctrl/tinycolor');
+
+var hueStep = 2; // 色相阶梯
+
+var saturationStep = 0.16; // 饱和度阶梯，浅色部分
+
+var saturationStep2 = 0.05; // 饱和度阶梯，深色部分
+
+var brightnessStep1 = 0.05; // 亮度阶梯，浅色部分
+
+var brightnessStep2 = 0.15; // 亮度阶梯，深色部分
+
+var lightColorCount = 5; // 浅色数量，主色上
+
+var darkColorCount = 4; // 深色数量，主色下
+// 暗色主题颜色映射关系表
+
+var darkColorMap = [{
+  index: 7,
+  opacity: 0.15
+}, {
+  index: 6,
+  opacity: 0.25
+}, {
+  index: 5,
+  opacity: 0.3
+}, {
+  index: 5,
+  opacity: 0.45
+}, {
+  index: 5,
+  opacity: 0.65
+}, {
+  index: 5,
+  opacity: 0.85
+}, {
+  index: 4,
+  opacity: 0.9
+}, {
+  index: 3,
+  opacity: 0.95
+}, {
+  index: 2,
+  opacity: 0.97
+}, {
+  index: 1,
+  opacity: 0.98
+}]; // Wrapper function ported from TinyColor.prototype.toHsv
+// Keep it here because of `hsv.h * 360`
+
+function toHsv(_ref) {
+  var r = _ref.r,
+      g = _ref.g,
+      b = _ref.b;
+  var hsv = tinycolor.rgbToHsv(r, g, b);
+  return {
+    h: hsv.h * 360,
+    s: hsv.s,
+    v: hsv.v
+  };
+} // Wrapper function ported from TinyColor.prototype.toHexString
+// Keep it here because of the prefix `#`
+
+
+function toHex(_ref2) {
+  var r = _ref2.r,
+      g = _ref2.g,
+      b = _ref2.b;
+  return "#".concat(tinycolor.rgbToHex(r, g, b, false));
+} // Wrapper function ported from TinyColor.prototype.mix, not treeshakable.
+// Amount in range [0, 1]
+// Assume color1 & color2 has no alpha, since the following src code did so.
+
+
+function mix(rgb1, rgb2, amount) {
+  var p = amount / 100;
+  var rgb = {
+    r: (rgb2.r - rgb1.r) * p + rgb1.r,
+    g: (rgb2.g - rgb1.g) * p + rgb1.g,
+    b: (rgb2.b - rgb1.b) * p + rgb1.b
+  };
+  return rgb;
+}
+
+function getHue(hsv, i, light) {
+  var hue; // 根据色相不同，色相转向不同
+
+  if (Math.round(hsv.h) >= 60 && Math.round(hsv.h) <= 240) {
+    hue = light ? Math.round(hsv.h) - hueStep * i : Math.round(hsv.h) + hueStep * i;
+  } else {
+    hue = light ? Math.round(hsv.h) + hueStep * i : Math.round(hsv.h) - hueStep * i;
+  }
+
+  if (hue < 0) {
+    hue += 360;
+  } else if (hue >= 360) {
+    hue -= 360;
+  }
+
+  return hue;
+}
+
+function getSaturation(hsv, i, light) {
+  // grey color don't change saturation
+  if (hsv.h === 0 && hsv.s === 0) {
+    return hsv.s;
+  }
+
+  var saturation;
+
+  if (light) {
+    saturation = hsv.s - saturationStep * i;
+  } else if (i === darkColorCount) {
+    saturation = hsv.s + saturationStep;
+  } else {
+    saturation = hsv.s + saturationStep2 * i;
+  } // 边界值修正
+
+
+  if (saturation > 1) {
+    saturation = 1;
+  } // 第一格的 s 限制在 0.06-0.1 之间
+
+
+  if (light && i === lightColorCount && saturation > 0.1) {
+    saturation = 0.1;
+  }
+
+  if (saturation < 0.06) {
+    saturation = 0.06;
+  }
+
+  return Number(saturation.toFixed(2));
+}
+
+function getValue(hsv, i, light) {
+  var value;
+
+  if (light) {
+    value = hsv.v + brightnessStep1 * i;
+  } else {
+    value = hsv.v - brightnessStep2 * i;
+  }
+
+  if (value > 1) {
+    value = 1;
+  }
+
+  return Number(value.toFixed(2));
+}
+
+function generate(color) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var patterns = [];
+  var pColor = tinycolor.inputToRGB(color);
+
+  for (var i = lightColorCount; i > 0; i -= 1) {
+    var hsv = toHsv(pColor);
+    var colorString = toHex(tinycolor.inputToRGB({
+      h: getHue(hsv, i, true),
+      s: getSaturation(hsv, i, true),
+      v: getValue(hsv, i, true)
+    }));
+    patterns.push(colorString);
+  }
+
+  patterns.push(toHex(pColor));
+
+  for (var _i = 1; _i <= darkColorCount; _i += 1) {
+    var _hsv = toHsv(pColor);
+
+    var _colorString = toHex(tinycolor.inputToRGB({
+      h: getHue(_hsv, _i),
+      s: getSaturation(_hsv, _i),
+      v: getValue(_hsv, _i)
+    }));
+
+    patterns.push(_colorString);
+  } // dark theme patterns
+
+
+  if (opts.theme === 'dark') {
+    return darkColorMap.map(function (_ref3) {
+      var index = _ref3.index,
+          opacity = _ref3.opacity;
+      var darkColorString = toHex(mix(tinycolor.inputToRGB(opts.backgroundColor || '#141414'), tinycolor.inputToRGB(patterns[index]), opacity * 100));
+      return darkColorString;
+    });
+  }
+
+  return patterns;
+}
+
+var presetPrimaryColors = {
+  red: '#F5222D',
+  volcano: '#FA541C',
+  orange: '#FA8C16',
+  gold: '#FAAD14',
+  yellow: '#FADB14',
+  lime: '#A0D911',
+  green: '#52C41A',
+  cyan: '#13C2C2',
+  blue: '#1890FF',
+  geekblue: '#2F54EB',
+  purple: '#722ED1',
+  magenta: '#EB2F96',
+  grey: '#666666'
+};
+var presetPalettes = {};
+var presetDarkPalettes = {};
+Object.keys(presetPrimaryColors).forEach(function (key) {
+  presetPalettes[key] = generate(presetPrimaryColors[key]);
+  presetPalettes[key].primary = presetPalettes[key][5]; // dark presetPalettes
+
+  presetDarkPalettes[key] = generate(presetPrimaryColors[key], {
+    theme: 'dark',
+    backgroundColor: '#141414'
+  });
+  presetDarkPalettes[key].primary = presetDarkPalettes[key][5];
+});
+var red = presetPalettes.red;
+var volcano = presetPalettes.volcano;
+var gold = presetPalettes.gold;
+var orange = presetPalettes.orange;
+var yellow = presetPalettes.yellow;
+var lime = presetPalettes.lime;
+var green = presetPalettes.green;
+var cyan = presetPalettes.cyan;
+var blue = presetPalettes.blue;
+var geekblue = presetPalettes.geekblue;
+var purple = presetPalettes.purple;
+var magenta = presetPalettes.magenta;
+var grey = presetPalettes.grey;
+
+exports.blue = blue;
+exports.cyan = cyan;
+exports.geekblue = geekblue;
+exports.generate = generate;
+exports.gold = gold;
+exports.green = green;
+exports.grey = grey;
+exports.lime = lime;
+exports.magenta = magenta;
+exports.orange = orange;
+exports.presetDarkPalettes = presetDarkPalettes;
+exports.presetPalettes = presetPalettes;
+exports.presetPrimaryColors = presetPrimaryColors;
+exports.purple = purple;
+exports.red = red;
+exports.volcano = volcano;
+exports.yellow = yellow;

node_modules/@ant-design/colors/dist/src/generate.d.ts

@@ -0,0 +1,6 @@
+interface Opts {
+    theme?: 'dark' | 'default';
+    backgroundColor?: string;
+}
+export default function generate(color: string, opts?: Opts): string[];
+export {};

node_modules/@ant-design/colors/dist/src/index.d.ts

@@ -0,0 +1,51 @@
+import generate from './generate';
+export interface PalettesProps {
+    [key: string]: string[] & {
+        primary?: string;
+    };
+}
+declare const presetPrimaryColors: {
+    [key: string]: string;
+};
+declare const presetPalettes: PalettesProps;
+declare const presetDarkPalettes: PalettesProps;
+declare const red: string[] & {
+    primary?: string | undefined;
+};
+declare const volcano: string[] & {
+    primary?: string | undefined;
+};
+declare const gold: string[] & {
+    primary?: string | undefined;
+};
+declare const orange: string[] & {
+    primary?: string | undefined;
+};
+declare const yellow: string[] & {
+    primary?: string | undefined;
+};
+declare const lime: string[] & {
+    primary?: string | undefined;
+};
+declare const green: string[] & {
+    primary?: string | undefined;
+};
+declare const cyan: string[] & {
+    primary?: string | undefined;
+};
+declare const blue: string[] & {
+    primary?: string | undefined;
+};
+declare const geekblue: string[] & {
+    primary?: string | undefined;
+};
+declare const purple: string[] & {
+    primary?: string | undefined;
+};
+declare const magenta: string[] & {
+    primary?: string | undefined;
+};
+declare const grey: string[] & {
+    primary?: string | undefined;
+};
+export { generate, presetPalettes, presetDarkPalettes, presetPrimaryColors, red, volcano, orange, gold, yellow, lime, green, cyan, blue, geekblue, purple, magenta, grey, };

node_modules/@ant-design/colors/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@ant-design/colors",
+  "version": "6.0.0",
+  "description": "Color palettes calculator of Ant Design",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "files": [
+    "lib",
+    "dist/index.js",
+    "dist/index.esm.js",
+    "dist/src/index.d.ts",
+    "dist/src/generate.d.ts"
+  ],
+  "typings": "dist/src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ant-design/ant-design-colors.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ant-design/ant-design-colors/issues"
+  },
+  "scripts": {
+    "tsc": "tsc --noEmit",
+    "compile": "father build --esm --cjs",
+    "prepublishOnly": "npm run compile && np --no-cleanup --no-publish",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "prettier --write '{src,tests}/**/*.ts'",
+    "jest": "jest",
+    "coverage": "jest --coverage && cat ./coverage/lcov.info | coveralls",
+    "test": "npm run tsc && npm run lint && npm run jest"
+  },
+  "author": "afc163 <afc163@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@ctrl/tinycolor": "^3.4.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^26.0.0",
+    "@typescript-eslint/eslint-plugin": "^4.0.0",
+    "@typescript-eslint/parser": "^4.7.0",
+    "coveralls": "^3.0.3",
+    "eslint": "^7.1.0",
+    "eslint-config-prettier": "^7.0.0",
+    "eslint-plugin-prettier": "^3.0.1",
+    "father": "^2.29.5",
+    "jest": "^26.0.1",
+    "np": "^7.0.0",
+    "prettier": "^2.0.0",
+    "ts-jest": "^26.0.0",
+    "typescript": "^4.0.2"
+  },
+  "homepage": "https://github.com/ant-design/ant-design-colors#readme"
+}

node_modules/@babel/code-frame/LICENSE

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

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

@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.codeFrameColumns = codeFrameColumns;
+exports.default = _default;
+
+var _highlight = require("@babel/highlight");
+
+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, end).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

@@ -0,0 +1,30 @@
+{
+  "name": "@babel/code-frame",
+  "version": "7.18.6",
+  "description": "Generate errors that contain a code frame that point to source locations.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "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.18.6"
+  },
+  "devDependencies": {
+    "@types/chalk": "^2.0.0",
+    "chalk": "^2.0.0",
+    "strip-ansi": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}

node_modules/@babel/compat-data/LICENSE

@@ -0,0 +1,22 @@
+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/README.md

@@ -0,0 +1,19 @@
+# @babel/compat-data
+
+> 
+
+See our website [@babel/compat-data](https://babeljs.io/docs/en/babel-compat-data) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/compat-data
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/compat-data
+```

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+{
+  "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

@@ -0,0 +1,22 @@
+{
+  "transform-async-to-generator": [
+    "bugfix/transform-async-arrows-in-class"
+  ],
+  "transform-parameters": [
+    "bugfix/transform-edge-default-parameters",
+    "bugfix/transform-safari-id-destructuring-collision-in-function-expression"
+  ],
+  "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

@@ -0,0 +1,157 @@
+{
+  "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"
+  },
+  "bugfix/transform-edge-default-parameters": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "18",
+    "firefox": "52",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "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"
+  },
+  "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",
+    "rhino": "1.7.13",
+    "electron": "0.37"
+  },
+  "bugfix/transform-safari-id-destructuring-collision-in-function-expression": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "14",
+    "firefox": "2",
+    "node": "6",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "bugfix/transform-tagged-template-caching": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "13",
+    "node": "4",
+    "ios": "13",
+    "samsung": "3.4",
+    "rhino": "1.7.14",
+    "electron": "0.21"
+  },
+  "bugfix/transform-v8-spread-parameters-in-optional-chaining": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "16.9",
+    "ios": "13.4",
+    "electron": "13.0"
+  },
+  "proposal-optional-chaining": {
+    "chrome": "80",
+    "opera": "67",
+    "edge": "80",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "14",
+    "ios": "13.4",
+    "samsung": "13",
+    "electron": "8.0"
+  },
+  "transform-parameters": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "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"
+  },
+  "transform-template-literals": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "13",
+    "firefox": "34",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "samsung": "3.4",
+    "electron": "0.21"
+  },
+  "transform-function-name": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "14",
+    "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"
+  }
+}

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

@@ -0,0 +1,478 @@
+{
+  "proposal-class-static-block": {
+    "chrome": "94",
+    "opera": "80",
+    "edge": "94",
+    "firefox": "93",
+    "node": "16.11",
+    "electron": "15.0"
+  },
+  "proposal-private-property-in-object": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "90",
+    "safari": "15",
+    "node": "16.9",
+    "ios": "15",
+    "electron": "13.0"
+  },
+  "proposal-class-properties": {
+    "chrome": "74",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "90",
+    "safari": "14.1",
+    "node": "12",
+    "ios": "15",
+    "samsung": "11",
+    "electron": "6.0"
+  },
+  "proposal-private-methods": {
+    "chrome": "84",
+    "opera": "70",
+    "edge": "84",
+    "firefox": "90",
+    "safari": "15",
+    "node": "14.6",
+    "ios": "15",
+    "samsung": "14",
+    "electron": "10.0"
+  },
+  "proposal-numeric-separator": {
+    "chrome": "75",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "70",
+    "safari": "13",
+    "node": "12.5",
+    "ios": "13",
+    "samsung": "11",
+    "rhino": "1.7.14",
+    "electron": "6.0"
+  },
+  "proposal-logical-assignment-operators": {
+    "chrome": "85",
+    "opera": "71",
+    "edge": "85",
+    "firefox": "79",
+    "safari": "14",
+    "node": "15",
+    "ios": "14",
+    "samsung": "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": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "16.9",
+    "ios": "13.4",
+    "electron": "13.0"
+  },
+  "proposal-json-strings": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "62",
+    "safari": "12",
+    "node": "10",
+    "ios": "12",
+    "samsung": "9",
+    "rhino": "1.7.14",
+    "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",
+    "node": "6",
+    "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",
+    "rhino": "1.7.14",
+    "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": "43",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "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",
+    "rhino": "1.7.14",
+    "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",
+    "rhino": "1.7.13",
+    "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.4",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "electron": "0.20"
+  },
+  "transform-property-literals": {
+    "chrome": "7",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "5.1",
+    "node": "0.4",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "electron": "0.20"
+  },
+  "transform-reserved-words": {
+    "chrome": "13",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.6",
+    "ie": "9",
+    "android": "4.4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "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

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

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

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

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

@@ -0,0 +1,40 @@
+{
+  "name": "@babel/compat-data",
+  "version": "7.18.13",
+  "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": "^4.0.10",
+    "core-js-compat": "^3.22.1",
+    "electron-to-chromium": "^1.4.113"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}

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

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

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

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

node_modules/@babel/core/LICENSE

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

@@ -0,0 +1,19 @@
+# @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/cjs-proxy.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+const babelP = import("./lib/index.js");
+
+const functionNames = [
+  "createConfigItem",
+  "loadPartialConfig",
+  "loadOptions",
+  "transform",
+  "transformFile",
+  "transformFromAst",
+  "parse",
+];
+
+for (const name of functionNames) {
+  exports[`${name}Sync`] = function () {
+    throw new Error(
+      `"${name}Sync" is not supported when loading @babel/core using require()`
+    );
+  };
+  exports[name] = function (...args) {
+    babelP.then(babel => {
+      babel[name](...args);
+    });
+  };
+  exports[`${name}Async`] = function (...args) {
+    return babelP.then(babel => babel[`${name}Async`](...args));
+  };
+}

node_modules/@babel/core/lib/config/cache-contexts.js

@@ -0,0 +1 @@
+0 && 0;

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

@@ -0,0 +1,326 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertSimpleType = assertSimpleType;
+exports.makeStrongCache = makeStrongCache;
+exports.makeStrongCacheSync = makeStrongCacheSync;
+exports.makeWeakCache = makeWeakCache;
+exports.makeWeakCacheSync = makeWeakCacheSync;
+
+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)) {
+      value = yield* (0, _async.onFirstPause)(handlerResult, () => {
+        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);
+  }
+
+}
+
+0 && 0;

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

@@ -0,0 +1,566 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildPresetChain = buildPresetChain;
+exports.buildPresetChainWalker = void 0;
+exports.buildRootChain = buildRootChain;
+
+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 ignoreListReplacer(_key, value) {
+  if (value instanceof RegExp) {
+    return String(value);
+  }
+
+  return value;
+}
+
+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, ignoreListReplacer)}\` 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, ignoreListReplacer)}\` 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);
+}
+
+0 && 0;

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

@@ -0,0 +1,231 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCachedDescriptors = createCachedDescriptors;
+exports.createDescriptor = createDescriptor;
+exports.createUncachedDescriptors = createUncachedDescriptors;
+
+function _gensync() {
+  const data = require("gensync");
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _functional = require("../gensync-utils/functional");
+
+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) {
+  return {
+    options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
+    plugins: (0, _functional.once)(() => createPluginDescriptors(options.plugins || [], dirname, alias)),
+    presets: (0, _functional.once)(() => createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset))
+  };
+}
+
+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);
+  }
+}
+
+0 && 0;

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

@@ -0,0 +1,360 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ROOT_CONFIG_FILENAMES = void 0;
+exports.findConfigUpwards = findConfigUpwards;
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+exports.resolveShowConfigPath = resolveShowConfigPath;
+
+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`);
+  }
+
+  delete options["$schema"];
+  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 { };
+};`);
+}
+
+0 && 0;

node_modules/@babel/core/lib/config/files/import-meta-resolve.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = resolve;
+
+function _module() {
+  const data = require("module");
+
+  _module = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _importMetaResolve = require("../../vendor/import-meta-resolve");
+
+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.cjs");
+} catch (_unused) {}
+
+const importMetaResolveP = import_ && process.execArgv.includes("--experimental-import-meta-resolve") ? import_("data:text/javascript,export default import.meta.resolve").then(m => m.default || _importMetaResolve.resolve, () => _importMetaResolve.resolve) : Promise.resolve(_importMetaResolve.resolve);
+
+function resolve(_x, _x2) {
+  return _resolve.apply(this, arguments);
+}
+
+function _resolve() {
+  _resolve = _asyncToGenerator(function* (specifier, parent) {
+    return (yield importMetaResolveP)(specifier, parent);
+  });
+  return _resolve.apply(this, arguments);
+}
+
+0 && 0;

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

@@ -0,0 +1,5 @@
+module.exports = function import_(filepath) {
+  return import(filepath);
+};
+
+0 && 0;

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

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ROOT_CONFIG_FILENAMES = void 0;
+exports.findConfigUpwards = findConfigUpwards;
+exports.findPackageData = findPackageData;
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+exports.resolveShowConfigPath = resolveShowConfigPath;
+
+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`);
+}
+
+0 && 0;

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

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ROOT_CONFIG_FILENAMES", {
+  enumerable: true,
+  get: function () {
+    return _configuration.ROOT_CONFIG_FILENAMES;
+  }
+});
+Object.defineProperty(exports, "findConfigUpwards", {
+  enumerable: true,
+  get: function () {
+    return _configuration.findConfigUpwards;
+  }
+});
+Object.defineProperty(exports, "findPackageData", {
+  enumerable: true,
+  get: function () {
+    return _package.findPackageData;
+  }
+});
+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, "loadPlugin", {
+  enumerable: true,
+  get: function () {
+    return plugins.loadPlugin;
+  }
+});
+Object.defineProperty(exports, "loadPreset", {
+  enumerable: true,
+  get: function () {
+    return plugins.loadPreset;
+  }
+});
+exports.resolvePreset = exports.resolvePlugin = void 0;
+Object.defineProperty(exports, "resolveShowConfigPath", {
+  enumerable: true,
+  get: function () {
+    return _configuration.resolveShowConfigPath;
+  }
+});
+
+var _package = require("./package");
+
+var _configuration = require("./configuration");
+
+var plugins = require("./plugins");
+
+function _gensync() {
+  const data = require("gensync");
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
+({});
+
+const resolvePlugin = _gensync()(plugins.resolvePlugin).sync;
+
+exports.resolvePlugin = resolvePlugin;
+
+const resolvePreset = _gensync()(plugins.resolvePreset).sync;
+
+exports.resolvePreset = resolvePreset;
+0 && 0;

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

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadCjsOrMjsDefault;
+exports.supportsESM = void 0;
+
+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 _semver() {
+  const data = require("semver");
+
+  _semver = 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.cjs");
+} catch (_unused) {}
+
+const supportsESM = _semver().satisfies(process.versions.node, "^12.17 || >=13.2");
+
+exports.supportsESM = supportsESM;
+
+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);
+}
+
+0 && 0;

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

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

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

@@ -0,0 +1,275 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+
+function _debug() {
+  const data = require("debug");
+
+  _debug = function () {
+    return data;
+  };
+
+  return data;
+}
+
+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 _async = require("../../gensync-utils/async");
+
+var _moduleTypes = require("./module-types");
+
+function _url() {
+  const data = require("url");
+
+  _url = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _importMetaResolve = require("./import-meta-resolve");
+
+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); }); }; }
+
+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 yield* resolveStandardizedName("plugin", name, dirname);
+}
+
+function* resolvePreset(name, dirname) {
+  return yield* resolveStandardizedName("preset", name, dirname);
+}
+
+function* loadPlugin(name, dirname) {
+  const filepath = yield* resolvePlugin(name, dirname);
+  const value = yield* requireModule("plugin", filepath);
+  debug("Loaded plugin %o from %o.", name, dirname);
+  return {
+    filepath,
+    value
+  };
+}
+
+function* loadPreset(name, dirname) {
+  const filepath = yield* resolvePreset(name, 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* resolveAlternativesHelper(type, name) {
+  const standardizedName = standardizeName(type, name);
+  const {
+    error,
+    value
+  } = yield standardizedName;
+  if (!error) return value;
+  if (error.code !== "MODULE_NOT_FOUND") throw error;
+
+  if (standardizedName !== name && !(yield name).error) {
+    error.message += `\n- If you want to resolve "${name}", use "module:${name}"`;
+  }
+
+  if (!(yield standardizeName(type, "@babel/" + name)).error) {
+    error.message += `\n- Did you mean "@babel/${name}"?`;
+  }
+
+  const oppositeType = type === "preset" ? "plugin" : "preset";
+
+  if (!(yield standardizeName(oppositeType, name)).error) {
+    error.message += `\n- Did you accidentally pass a ${oppositeType} as a ${type}?`;
+  }
+
+  throw error;
+}
+
+function tryRequireResolve(id, {
+  paths: [dirname]
+}) {
+  try {
+    return {
+      error: null,
+      value: (((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;
+      })(id, {
+        paths: [dirname]
+      })
+    };
+  } catch (error) {
+    return {
+      error,
+      value: null
+    };
+  }
+}
+
+function tryImportMetaResolve(_x, _x2) {
+  return _tryImportMetaResolve.apply(this, arguments);
+}
+
+function _tryImportMetaResolve() {
+  _tryImportMetaResolve = _asyncToGenerator(function* (id, options) {
+    try {
+      return {
+        error: null,
+        value: yield (0, _importMetaResolve.default)(id, options)
+      };
+    } catch (error) {
+      return {
+        error,
+        value: null
+      };
+    }
+  });
+  return _tryImportMetaResolve.apply(this, arguments);
+}
+
+function resolveStandardizedNameForRequire(type, name, dirname) {
+  const it = resolveAlternativesHelper(type, name);
+  let res = it.next();
+
+  while (!res.done) {
+    res = it.next(tryRequireResolve(res.value, {
+      paths: [dirname]
+    }));
+  }
+
+  return res.value;
+}
+
+function resolveStandardizedNameForImport(_x3, _x4, _x5) {
+  return _resolveStandardizedNameForImport.apply(this, arguments);
+}
+
+function _resolveStandardizedNameForImport() {
+  _resolveStandardizedNameForImport = _asyncToGenerator(function* (type, name, dirname) {
+    const parentUrl = (0, _url().pathToFileURL)(_path().join(dirname, "./babel-virtual-resolve-base.js")).href;
+    const it = resolveAlternativesHelper(type, name);
+    let res = it.next();
+
+    while (!res.done) {
+      res = it.next(yield tryImportMetaResolve(res.value, parentUrl));
+    }
+
+    return (0, _url().fileURLToPath)(res.value);
+  });
+  return _resolveStandardizedNameForImport.apply(this, arguments);
+}
+
+const resolveStandardizedName = _gensync()({
+  sync(type, name, dirname = process.cwd()) {
+    return resolveStandardizedNameForRequire(type, name, dirname);
+  },
+
+  async(type, name, dirname = process.cwd()) {
+    return _asyncToGenerator(function* () {
+      if (!_moduleTypes.supportsESM) {
+        return resolveStandardizedNameForRequire(type, name, dirname);
+      }
+
+      try {
+        return yield resolveStandardizedNameForImport(type, name, dirname);
+      } catch (e) {
+        try {
+          return resolveStandardizedNameForRequire(type, name, dirname);
+        } catch (e2) {
+          if (e.type === "MODULE_NOT_FOUND") throw e;
+          if (e2.type === "MODULE_NOT_FOUND") throw e2;
+          throw e;
+        }
+      }
+    })();
+  }
+
+});
+
+{
+  var LOADING_MODULES = new Set();
+}
+
+function* requireModule(type, name) {
+  {
+    if (!(yield* (0, _async.isAsync)()) && 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);
+    }
+  }
+}
+
+0 && 0;

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

@@ -0,0 +1 @@
+0 && 0;

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

@@ -0,0 +1,46 @@
+"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;
+}
+
+0 && 0;

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

@@ -0,0 +1,380 @@
+"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");
+
+var _deepArray = require("./helpers/deep-array");
+
+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 externalDependencies = [];
+  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 {
+          var preset = yield* loadPresetDescriptor(descriptor, presetContext);
+        } catch (e) {
+          if (e.code === "BABEL_UNKNOWN_OPTION") {
+            (0, _options.checkNoUnwrappedItemOptionPairs)(rawPresets, i, "preset", e);
+          }
+
+          throw e;
+        }
+
+        externalDependencies.push(preset.externalDependencies);
+
+        if (descriptor.ownPass) {
+          presets.push({
+            preset: preset.chain,
+            pass: []
+          });
+        } else {
+          presets.unshift({
+            preset: preset.chain,
+            pass: pluginDescriptorsPass
+          });
+        }
+      }
+    }
+
+    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 {
+            var plugin = yield* loadPluginDescriptor(descriptor, pluginContext);
+          } catch (e) {
+            if (e.code === "BABEL_UNKNOWN_PLUGIN_PROPERTY") {
+              (0, _options.checkNoUnwrappedItemOptionPairs)(descs, i, "plugin", e);
+            }
+
+            throw e;
+          }
+
+          pass.push(plugin);
+          externalDependencies.push(plugin.externalDependencies);
+        }
+      }
+    }
+  })();
+  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,
+    externalDependencies: (0, _deepArray.finalize)(externalDependencies)
+  };
+});
+
+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 || {};
+  const externalDependencies = [];
+  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, externalDependencies));
+
+    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)})`);
+  }
+
+  if (externalDependencies.length > 0 && (!cache.configured() || cache.mode() === "forever")) {
+    let error = `A plugin/preset has external untracked dependencies ` + `(${externalDependencies[0]}), but the cache `;
+
+    if (!cache.configured()) {
+      error += `has not been configured to be invalidated when the external dependencies change. `;
+    } else {
+      error += ` has been configured to never be invalidated. `;
+    }
+
+    error += `Plugins/presets should configure their cache to be invalidated when the external ` + `dependencies change, for example using \`api.cache.invalidate(() => ` + `statSync(filepath).mtimeMs)\` or \`api.cache.never()\`\n` + `(While processing: ${JSON.stringify(alias)})`;
+    throw new Error(error);
+  }
+
+  return {
+    value: item,
+    options,
+    dirname,
+    alias,
+    externalDependencies: (0, _deepArray.finalize)(externalDependencies)
+  };
+});
+
+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,
+  externalDependencies
+}, 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 || {}]);
+
+    if (inherits.externalDependencies.length > 0) {
+      if (externalDependencies.length === 0) {
+        externalDependencies = inherits.externalDependencies;
+      } else {
+        externalDependencies = (0, _deepArray.finalize)([externalDependencies, inherits.externalDependencies]);
+      }
+    }
+  }
+
+  return new _plugin.default(plugin, options, alias, externalDependencies);
+});
+
+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.transformSync(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 {
+    chain: yield* (0, _configChain.buildPresetChain)(preset, context),
+    externalDependencies: preset.externalDependencies
+  };
+}
+
+const instantiatePreset = (0, _caching.makeWeakCacheSync)(({
+  value,
+  dirname,
+  alias,
+  externalDependencies
+}) => {
+  return {
+    options: (0, _options.validate)("preset", value),
+    alias,
+    dirname,
+    externalDependencies
+  };
+});
+
+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);
+    }
+  };
+}
+
+0 && 0;

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

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeConfigAPI = makeConfigAPI;
+exports.makePluginAPI = makePluginAPI;
+exports.makePresetAPI = makePresetAPI;
+
+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));
+    }
+
+    return (Array.isArray(value) ? value : [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, externalDependencies) {
+  const targets = () => JSON.parse(cache.using(data => JSON.stringify(data.targets)));
+
+  const addExternalDependency = ref => {
+    externalDependencies.push(ref);
+  };
+
+  return Object.assign({}, makeConfigAPI(cache), {
+    targets,
+    addExternalDependency
+  });
+}
+
+function makePluginAPI(cache, externalDependencies) {
+  const assumption = name => cache.using(data => data.assumptions[name]);
+
+  return Object.assign({}, makePresetAPI(cache, externalDependencies), {
+    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
+  });
+}
+
+0 && 0;

node_modules/@babel/core/lib/config/helpers/deep-array.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.finalize = finalize;
+exports.flattenToSet = flattenToSet;
+
+function finalize(deepArr) {
+  return Object.freeze(deepArr);
+}
+
+function flattenToSet(arr) {
+  const result = new Set();
+  const stack = [arr];
+
+  while (stack.length > 0) {
+    for (const el of stack.pop()) {
+      if (Array.isArray(el)) stack.push(el);else result.add(el);
+    }
+  }
+
+  return result;
+}
+
+0 && 0;

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

@@ -0,0 +1,12 @@
+"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;
+}
+
+0 && 0;

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

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConfigItem = createConfigItem;
+exports.createConfigItemSync = exports.createConfigItemAsync = void 0;
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _full.default;
+  }
+});
+exports.loadPartialConfigSync = exports.loadPartialConfigAsync = exports.loadPartialConfig = exports.loadOptionsSync = exports.loadOptionsAsync = exports.loadOptions = 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 => (argOrCallback, maybeCallback) => {
+  let arg;
+  let callback;
+
+  if (maybeCallback === undefined && typeof argOrCallback === "function") {
+    callback = argOrCallback;
+    arg = undefined;
+  } else {
+    callback = maybeCallback;
+    arg = argOrCallback;
+  }
+
+  return callback ? runner.errback(arg, callback) : runner.sync(arg);
+};
+
+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);
+  }
+}
+
+0 && 0;

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

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConfigItem = createConfigItem;
+exports.createItemFromDescriptor = createItemFromDescriptor;
+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);
+0 && 0;

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

@@ -0,0 +1,198 @@
+"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");
+
+const _excluded = ["showIgnoredFiles"];
+
+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, _excluded);
+    _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);
+0 && 0;

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

@@ -0,0 +1,46 @@
+"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(""));
+}
+
+0 && 0;

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _deepArray = require("./helpers/deep-array");
+
+class Plugin {
+  constructor(plugin, options, key, externalDependencies = (0, _deepArray.finalize)([])) {
+    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.externalDependencies = 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;
+    this.externalDependencies = externalDependencies;
+  }
+
+}
+
+exports.default = Plugin;
+0 && 0;