From 3647edef5eda2e7971da6bba06f1099407e0d647 Mon Sep 17 00:00:00 2001 From: Jonathan Lukas Date: Mon, 5 Feb 2024 11:44:03 +0100 Subject: [PATCH] migrated example --- custom-tasklist-exporter-based/README.md | 46 + .../c7-exporter/pom.xml | 152 + .../org/camunda/bpm/run/EventExporter.java | 86 + .../bpm/run/ExporterConfiguration.java | 22 + .../bpm/run/consumer/ActivityHandler.java | 71 + .../bpm/run/listener/BpmnDeployListener.java | 27 + .../run/listener/UserTaskEventListener.java | 33 + .../bpm/run/producer/UserTaskProducer.java | 56 + .../org/camunda/bpm/run/ExporterTest.java | 152 + .../src/test/resources/camunda.cfg.xml | 27 + .../src/test/resources/logback-test.xml | 63 + .../src/test/resources/logging.properties | 2 + .../src/test/resources/process.bpmn | 47 + .../c8-exporter/pom.xml | 82 + .../com/camunda/consulting/KafkaExporter.java | 224 + .../com/camunda/consulting/ExporterTest.java | 160 + .../c8-jobworker/Dockerfile | 4 + .../c8-jobworker/pom.xml | 93 + .../consulting/UserTaskWorkerApplication.java | 12 + .../listener/CannotCompleteTaskException.java | 8 + .../listener/CompletedTaskListener.java | 35 + .../consulting/zeebe/ClientConfiguration.java | 47 + .../consulting/zeebe/UserTaskHandler.java | 17 + .../src/main/resources/application.yaml | 21 + .../consulting/CompleteTaskListenerTest.java | 97 + .../config/c7-default.yml | 43 + .../config/log4j2.xml | 53 + .../docker-compose.yml | 141 + .../architecture/architecture-overview.drawio | 1 + .../architecture-overview.drawio.png | Bin 0 -> 113711 bytes .../frontend/Colors for Tasklist.png | Bin 0 -> 38847 bytes custom-tasklist-exporter-based/model/pom.xml | 32 + .../camunda/consulting/BpmnErrorAction.java | 13 + .../camunda/consulting/CompleteAction.java | 9 + .../consulting/DeployEventExporter.java | 9 + .../com/camunda/consulting/EventType.java | 7 + .../com/camunda/consulting/MessageAction.java | 13 + .../com/camunda/consulting/TaskAction.java | 15 + .../camunda/consulting/TaskEventExporter.java | 9 + .../com/camunda/consulting/TaskHandler.java | 11 + .../camunda/consulting/impl/BpmnDiagram.java | 27 + .../consulting/impl/CompletedTaskMessage.java | 20 + .../com/camunda/consulting/impl/UserTask.java | 45 + .../java/com/camunda/consulting/AppTest.java | 35 + custom-tasklist-exporter-based/pom.xml | 128 + .../tasklist/Dockerfile | 4 + .../tasklist/client/.gitignore | 23 + .../tasklist/client/README.md | 70 + .../tasklist/client/package-lock.json | 17928 ++++++++++++++++ .../tasklist/client/package.json | 49 + .../tasklist/client/public/favicon.ico | Bin 0 -> 15406 bytes .../tasklist/client/public/index.html | 50 + .../tasklist/client/public/logo192.png | Bin 0 -> 5347 bytes .../tasklist/client/public/logo512.png | Bin 0 -> 9664 bytes .../tasklist/client/public/manifest.json | 25 + .../tasklist/client/public/robots.txt | 3 + .../tasklist/client/src/App.css | 146 + .../tasklist/client/src/App.js | 14 + .../tasklist/client/src/BpmnMock.js | 177 + .../tasklist/client/src/DataMock.js | 107 + .../src/components/Bpmn/DiagramViewer.js | 22 + .../client/src/components/Bpmn/FormViewer.js | 35 + .../tasklist/client/src/components/Main.js | 13 + .../src/components/Navigation/Header.js | 16 + .../client/src/components/Tasks/Tabs/Tab.js | 11 + .../client/src/components/Tasks/Tabs/Tabs.js | 66 + .../client/src/components/Tasks/Task.js | 27 + .../client/src/components/Tasks/TaskHeader.js | 43 + .../client/src/components/Tasks/TaskInfo.js | 15 + .../client/src/components/Tasks/Tasks.js | 28 + .../tasklist/client/src/index.css | 0 .../tasklist/client/src/index.js | 22 + .../integration/CompleteUserTaskMutation.js | 15 + .../client/src/integration/DefaultForm.js | 22 + .../client/src/integration/DiagramQuery.js | 12 + .../src/integration/GetFilteredTasks.js | 22 + .../tasklist/client/src/logo.svg | 1 + .../tasklist/pom.xml | 162 + .../consulting/TasklistApplication.java | 17 + .../api/controller/DiagramController.java | 22 + .../api/controller/UserTaskController.java | 63 + .../consulting/api/graphql/UserTaskDTO.java | 180 + .../api/repository/DiagramRepository.java | 8 + .../api/repository/UserTaskRepository.java | 12 + .../api/service/DiagramService.java | 25 + .../api/service/UserTaskService.java | 161 + .../listener/DeploymentKafkaListener.java | 29 + .../listener/UserTaskKafkaListener.java | 58 + .../src/main/resources/application.yaml | 45 + .../main/resources/graphql/schema.graphqls | 61 + .../DeploymentKafkaListenerTest.java | 36 + .../consulting/UserTaskKafkaListenerTest.java | 72 + .../consulting/UserTaskServiceTest.java | 92 + .../src/test/resources/application.yaml | 46 + 94 files changed, 22250 insertions(+) create mode 100644 custom-tasklist-exporter-based/README.md create mode 100644 custom-tasklist-exporter-based/c7-exporter/pom.xml create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/EventExporter.java create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/ExporterConfiguration.java create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/consumer/ActivityHandler.java create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/listener/BpmnDeployListener.java create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/listener/UserTaskEventListener.java create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/producer/UserTaskProducer.java create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/test/java/org/camunda/bpm/run/ExporterTest.java create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/test/resources/camunda.cfg.xml create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/test/resources/logback-test.xml create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/test/resources/logging.properties create mode 100644 custom-tasklist-exporter-based/c7-exporter/src/test/resources/process.bpmn create mode 100644 custom-tasklist-exporter-based/c8-exporter/pom.xml create mode 100644 custom-tasklist-exporter-based/c8-exporter/src/main/java/com/camunda/consulting/KafkaExporter.java create mode 100644 custom-tasklist-exporter-based/c8-exporter/src/test/java/com/camunda/consulting/ExporterTest.java create mode 100644 custom-tasklist-exporter-based/c8-jobworker/Dockerfile create mode 100644 custom-tasklist-exporter-based/c8-jobworker/pom.xml create mode 100644 custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/UserTaskWorkerApplication.java create mode 100644 custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/listener/CannotCompleteTaskException.java create mode 100644 custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/listener/CompletedTaskListener.java create mode 100644 custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/zeebe/ClientConfiguration.java create mode 100644 custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/zeebe/UserTaskHandler.java create mode 100644 custom-tasklist-exporter-based/c8-jobworker/src/main/resources/application.yaml create mode 100644 custom-tasklist-exporter-based/c8-jobworker/src/test/java/com/camunda/consulting/CompleteTaskListenerTest.java create mode 100644 custom-tasklist-exporter-based/config/c7-default.yml create mode 100644 custom-tasklist-exporter-based/config/log4j2.xml create mode 100644 custom-tasklist-exporter-based/docker-compose.yml create mode 100644 custom-tasklist-exporter-based/documentation/architecture/architecture-overview.drawio create mode 100644 custom-tasklist-exporter-based/documentation/architecture/architecture-overview.drawio.png create mode 100644 custom-tasklist-exporter-based/documentation/frontend/Colors for Tasklist.png create mode 100644 custom-tasklist-exporter-based/model/pom.xml create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/BpmnErrorAction.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/CompleteAction.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/DeployEventExporter.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/EventType.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/MessageAction.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskAction.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskEventExporter.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskHandler.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/BpmnDiagram.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/CompletedTaskMessage.java create mode 100644 custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/UserTask.java create mode 100644 custom-tasklist-exporter-based/model/src/test/java/com/camunda/consulting/AppTest.java create mode 100644 custom-tasklist-exporter-based/pom.xml create mode 100644 custom-tasklist-exporter-based/tasklist/Dockerfile create mode 100644 custom-tasklist-exporter-based/tasklist/client/.gitignore create mode 100644 custom-tasklist-exporter-based/tasklist/client/README.md create mode 100644 custom-tasklist-exporter-based/tasklist/client/package-lock.json create mode 100644 custom-tasklist-exporter-based/tasklist/client/package.json create mode 100644 custom-tasklist-exporter-based/tasklist/client/public/favicon.ico create mode 100644 custom-tasklist-exporter-based/tasklist/client/public/index.html create mode 100644 custom-tasklist-exporter-based/tasklist/client/public/logo192.png create mode 100644 custom-tasklist-exporter-based/tasklist/client/public/logo512.png create mode 100644 custom-tasklist-exporter-based/tasklist/client/public/manifest.json create mode 100644 custom-tasklist-exporter-based/tasklist/client/public/robots.txt create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/App.css create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/App.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/BpmnMock.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/DataMock.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Bpmn/DiagramViewer.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Bpmn/FormViewer.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Main.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Navigation/Header.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tabs/Tab.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tabs/Tabs.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Task.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/TaskHeader.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/TaskInfo.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tasks.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/index.css create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/index.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/integration/CompleteUserTaskMutation.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/integration/DefaultForm.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/integration/DiagramQuery.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/integration/GetFilteredTasks.js create mode 100644 custom-tasklist-exporter-based/tasklist/client/src/logo.svg create mode 100644 custom-tasklist-exporter-based/tasklist/pom.xml create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/TasklistApplication.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/controller/DiagramController.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/controller/UserTaskController.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/graphql/UserTaskDTO.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/repository/DiagramRepository.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/repository/UserTaskRepository.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/service/DiagramService.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/service/UserTaskService.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/listener/DeploymentKafkaListener.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/listener/UserTaskKafkaListener.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/resources/application.yaml create mode 100644 custom-tasklist-exporter-based/tasklist/src/main/resources/graphql/schema.graphqls create mode 100644 custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/DeploymentKafkaListenerTest.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/UserTaskKafkaListenerTest.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/UserTaskServiceTest.java create mode 100644 custom-tasklist-exporter-based/tasklist/src/test/resources/application.yaml diff --git a/custom-tasklist-exporter-based/README.md b/custom-tasklist-exporter-based/README.md new file mode 100644 index 00000000..f46bf1d2 --- /dev/null +++ b/custom-tasklist-exporter-based/README.md @@ -0,0 +1,46 @@ +# Custom Tasklist for User Tasks (Camunda 7 and 8) + +## Components + +![Architecture](./documentation/architecture/architecture-overview.drawio.png) + +### C8 +#### Exporter +[Exporter Module](./c8-exporter/) +Exporting User Tasks and Deployment Events to Kafka. +#### Job Worker +[Job Worker Module](./c8-jobworker/) +Job Worker for topic "io.camunda.zeebe:userTask". +Includes Kafka Listeners to complete UserTasks, once message is received. + +### C7 +#### Engine Plugin +[C7 Exporter](./c7-exporter/) + +### Tasklist +#### Backend +[Tasklist Module](./tasklist/) +Spring Boot Application with GraphQL API + +#### Frontend +[Frontend](./tasklist/client/) +Written in React + + +## How to run this project +`` +mvn clean install +`` + +`` +docker compose up +`` + +Exporter and Engine Plugin jars need to be mounted to the respective Engine. +For the Tasklist & Tasklist Worker Docker Images are available: +- [Tasklist](https://hub.docker.com/repository/docker/camundomanu/tasklist/general) +- [Tasklist Worker](https://hub.docker.com/repository/docker/camundomanu/tasklist-worker/general) + +The Docker Compose File also includes Components that are not required, but helped me a lot during development. +- mongo-express +- provectuslabs/kafka-ui diff --git a/custom-tasklist-exporter-based/c7-exporter/pom.xml b/custom-tasklist-exporter-based/c7-exporter/pom.xml new file mode 100644 index 00000000..f89f6dc3 --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/pom.xml @@ -0,0 +1,152 @@ + + + 4.0.0 + + + com.camunda.consulting + tasklist-parent + 1.0-SNAPSHOT + + + com.camunda.consulting + c7-exporter + + c7-exporter + + + UTF-8 + + + + + com.camunda.consulting + model + ${project.version} + + + + + org.camunda.bpm + camunda-engine + ${c7.version} + provided + + + + org.camunda.bpm.springboot + camunda-bpm-spring-boot-starter + ${c7.version} + provided + + + + org.projectlombok + lombok + + + + org.springframework.kafka + spring-kafka + 2.8.10 + + + + com.fasterxml.jackson.core + jackson-databind + 2.14.1 + + + + + + org.junit.jupiter + junit-jupiter-api + test + + + + junit + junit + 4.13.2 + test + + + + + com.h2database + h2 + 2.1.214 + test + + + + org.camunda.bpm + camunda-bpm-junit5 + 7.17.0 + test + + + + org.springframework.kafka + spring-kafka-test + 2.8.10 + test + + + + org.testcontainers + kafka + 1.16.2 + test + + + + + + + + org.junit + junit-bom + 5.9.2 + pom + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + + org.apache.maven.plugins + maven-shade-plugin + + + package + + shade + + + + + org.springframework.kafka:spring-kafka + org.springframework:spring-messaging + org.apache.kafka:kafka-clients + org.springframework.retry:spring-retry + com.camunda.consulting:model + + + + + + + + + + + diff --git a/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/EventExporter.java b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/EventExporter.java new file mode 100644 index 00000000..388f5a67 --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/EventExporter.java @@ -0,0 +1,86 @@ +package org.camunda.bpm.run; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import org.apache.kafka.clients.consumer.KafkaConsumer; +import org.apache.kafka.clients.producer.ProducerConfig; +import org.camunda.bpm.engine.ProcessEngine; +import org.camunda.bpm.engine.TaskService; +import org.camunda.bpm.engine.impl.cfg.ProcessEngineConfigurationImpl; +import org.camunda.bpm.engine.impl.cfg.ProcessEnginePlugin; +import org.camunda.bpm.engine.impl.persistence.deploy.Deployer; +import org.camunda.bpm.run.consumer.ActivityHandler; +import org.camunda.bpm.run.listener.BpmnDeployListener; +import org.camunda.bpm.run.producer.UserTaskProducer; +import org.springframework.kafka.core.DefaultKafkaProducerFactory; +import org.springframework.kafka.core.KafkaTemplate; + +public class EventExporter extends ExporterConfiguration implements ProcessEnginePlugin { + + private static KafkaConsumer consumer; + + private static UserTaskProducer userTaskProducer; + + + @Override + public void preInit(ProcessEngineConfigurationImpl processEngineConfiguration) { + List customPostDeployers = processEngineConfiguration.getCustomPostDeployers(); + + if (customPostDeployers == null) { + customPostDeployers = new ArrayList<>(); + } + + customPostDeployers.add(new BpmnDeployListener()); + processEngineConfiguration.setCustomPostDeployers(customPostDeployers); + + createConsumer(); + createProducer(); + } + + @Override + public void postInit(ProcessEngineConfigurationImpl processEngineConfiguration) { + + } + + @Override + public void postProcessEngineBuild(ProcessEngine processEngine) { + TaskService taskService = processEngine.getTaskService(); + ActivityHandler activityHandler = new ActivityHandler(taskService, consumer, this.sourceId); + Thread thread = new Thread(activityHandler); + thread.start(); + + } + + private void createConsumer() { + Properties config = new Properties(); + config.put("bootstrap.servers", bootstrapServer); + config.put("client.id", clientId); + config.put("group.id", groupId); + config.put("key.deserializer", consumer_key_deserializer); + config.put("value.deserializer", consumer_value_deserializer); + config.put("spring.json.use.type.headers", useTypeHeaders); + config.put("spring.json.value.default.type", defaultType); + consumer = new KafkaConsumer(config); + } + + private void createProducer() { + Map props = new HashMap<>(); + props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServer); + props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, producer_key_serializer); + props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, producer_value_serializer); + KafkaTemplate template = new KafkaTemplate<>(new DefaultKafkaProducerFactory<>(props)); + userTaskProducer = new UserTaskProducer(sourceId, userTaskTopic, deployTopic, template); + } + + public static UserTaskProducer getUserTaskProducer() { + return userTaskProducer; + } + + public static KafkaConsumer getConsumer() { + return consumer; + } + +} diff --git a/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/ExporterConfiguration.java b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/ExporterConfiguration.java new file mode 100644 index 00000000..47a99a03 --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/ExporterConfiguration.java @@ -0,0 +1,22 @@ +package org.camunda.bpm.run; + + +import lombok.Data; + +@Data +public class ExporterConfiguration { + + protected String bootstrapServer = ""; + protected String userTaskTopic = "usertask-info"; + protected String deployTopic = "deploy-info"; + protected String sourceId = ""; + protected String clientId = ""; + protected String groupId = ""; + protected String producer_value_serializer = "org.springframework.kafka.support.serializer.JsonSerializer"; + protected String producer_key_serializer = "org.apache.kafka.common.serialization.StringSerializer"; + protected String consumer_value_deserializer = "org.springframework.kafka.support.serializer.JsonDeserializer"; + protected String consumer_key_deserializer = "org.apache.kafka.common.serialization.StringDeserializer"; + protected boolean useTypeHeaders = false; + protected String defaultType = "com.camunda.consulting.impl.CompletedTaskMessage"; + +} diff --git a/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/consumer/ActivityHandler.java b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/consumer/ActivityHandler.java new file mode 100644 index 00000000..a560f332 --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/consumer/ActivityHandler.java @@ -0,0 +1,71 @@ +package org.camunda.bpm.run.consumer; + +import static java.util.Collections.singletonList; + +import com.camunda.consulting.BpmnErrorAction; +import com.camunda.consulting.CompleteAction; +import com.camunda.consulting.MessageAction; +import com.camunda.consulting.TaskHandler; +import com.camunda.consulting.impl.CompletedTaskMessage; +import java.time.Duration; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.logging.Logger; +import org.apache.kafka.clients.consumer.ConsumerRecords; +import org.apache.kafka.clients.consumer.KafkaConsumer; +import org.camunda.bpm.engine.TaskService; + +public class ActivityHandler implements TaskHandler, Runnable { + + private final AtomicBoolean shutdown = new AtomicBoolean(false); + private final CountDownLatch shutdownLatch = new CountDownLatch(1); + private final TaskService taskService; + + private final KafkaConsumer consumer; + private final String sourceId; + + private final Logger LOGGER = Logger.getLogger(ActivityHandler.class.getName()); + + public ActivityHandler(TaskService taskService, KafkaConsumer consumer, String sourceId) { + this.taskService = taskService; + this.consumer = consumer; + this.sourceId = sourceId; + } + + @Override + public void run() { + try { + this.consumer.subscribe(singletonList(this.sourceId)); + while (!shutdown.get()) { + ConsumerRecords records = consumer.poll(Duration.ofMillis(100)); + records.forEach(record -> { + CompletedTaskMessage message = (CompletedTaskMessage) record.value(); + completeTask(message); + }); + } + } finally { + consumer.close(); + shutdownLatch.countDown(); + } + } + + @Override + public void completeTask(CompleteAction completeAction) { + try { + taskService.complete(completeAction.getId(), completeAction.getVariables()); + } catch (Exception e) { + LOGGER.severe("Error completing user task: " + completeAction.getId() + " " + e.getMessage()); + e.printStackTrace(); + } + } + + @Override + public void throwError(BpmnErrorAction bpmnErrorAction) { + + } + + @Override + public void correlateMessage(MessageAction messageAction) { + + } +} diff --git a/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/listener/BpmnDeployListener.java b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/listener/BpmnDeployListener.java new file mode 100644 index 00000000..affad830 --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/listener/BpmnDeployListener.java @@ -0,0 +1,27 @@ +package org.camunda.bpm.run.listener; + +import com.camunda.consulting.impl.BpmnDiagram; +import java.util.logging.Logger; +import org.camunda.bpm.engine.impl.persistence.deploy.Deployer; +import org.camunda.bpm.engine.impl.persistence.entity.DeploymentEntity; +import org.camunda.bpm.engine.impl.persistence.entity.ResourceEntity; +import org.camunda.bpm.run.EventExporter; + +public class BpmnDeployListener implements Deployer { + + private final Logger LOGGER = Logger.getLogger(BpmnDeployListener.class.getName()); + + @Override + public void deploy(DeploymentEntity deploymentEntity) { + + deploymentEntity.getDeployedProcessDefinitions().forEach(processDefinitionEntity -> { + String id = processDefinitionEntity.getId(); + ResourceEntity entity = deploymentEntity.getResource( + processDefinitionEntity.getResourceName()); + String processDefinition = new String(entity.getBytes()); + BpmnDiagram diagram = new BpmnDiagram(id, processDefinition); + LOGGER.info("Process deployed: " + id); + EventExporter.getUserTaskProducer().exportDeployEvent(diagram); + }); + } +} diff --git a/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/listener/UserTaskEventListener.java b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/listener/UserTaskEventListener.java new file mode 100644 index 00000000..75198ae4 --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/listener/UserTaskEventListener.java @@ -0,0 +1,33 @@ +package org.camunda.bpm.run.listener; + +import com.camunda.consulting.EventType; +import java.util.logging.Logger; +import org.camunda.bpm.engine.delegate.DelegateTask; +import org.camunda.bpm.run.EventExporter; +import org.springframework.context.event.EventListener; +import org.springframework.stereotype.Component; + +@Component +public class UserTaskEventListener { + + private final Logger LOGGER = Logger.getLogger(UserTaskEventListener.class.getName()); + + @EventListener(condition = "#delegateTask.eventName.equals('create')") + public void taskCreated(DelegateTask delegateTask) { + LOGGER.finest("Task Created: " + delegateTask.getTaskDefinitionKey()); + EventExporter.getUserTaskProducer().sendMessage(delegateTask, EventType.CREATED); + } + + @EventListener(condition = "#delegateTask.eventName.equals('delete')") + public void taskDeleted(DelegateTask delegateTask) { + LOGGER.finest("Task Deleted: " + delegateTask.getTaskDefinitionKey()); + EventExporter.getUserTaskProducer().sendMessage(delegateTask, EventType.ENDED); + } + + @EventListener(condition = "#delegateTask.eventName.equals('complete')") + public void taskCompleted(DelegateTask delegateTask) { + LOGGER.finest("Task Completed: " + delegateTask.getTaskDefinitionKey()); + EventExporter.getUserTaskProducer().sendMessage(delegateTask, EventType.COMPLETED); + } + +} diff --git a/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/producer/UserTaskProducer.java b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/producer/UserTaskProducer.java new file mode 100644 index 00000000..c3de830a --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/main/java/org/camunda/bpm/run/producer/UserTaskProducer.java @@ -0,0 +1,56 @@ +package org.camunda.bpm.run.producer; + +import com.camunda.consulting.DeployEventExporter; +import com.camunda.consulting.EventType; +import com.camunda.consulting.TaskEventExporter; +import com.camunda.consulting.impl.BpmnDiagram; +import com.camunda.consulting.impl.UserTask; +import org.camunda.bpm.engine.delegate.DelegateTask; +import org.springframework.kafka.core.KafkaTemplate; + +public class UserTaskProducer implements TaskEventExporter, DeployEventExporter { + + private final String sourceId; + private final String userTaskTopic; + private final String deployTopic; + private final KafkaTemplate template; + + public UserTaskProducer(String sourceId, String userTaskTopic, String deployTopic, KafkaTemplate template) { + this.sourceId = sourceId; + this.userTaskTopic = userTaskTopic; + this.deployTopic = deployTopic; + this.template = template; + } + + @Override + public void exportTaskEvent(UserTask userTask) { + this.template.send(userTaskTopic, userTask.getUserTaskId(), userTask); + } + + public void sendMessage(DelegateTask delegateTask, EventType eventType) { + String dueDate = delegateTask.getDueDate() != null ? delegateTask.getDueDate().toString() : null; + String followUpDate = delegateTask.getFollowUpDate() != null ? delegateTask.getFollowUpDate().toString() : null; + UserTask task = UserTask.builder() + .userTaskId(delegateTask.getId()) + .source(sourceId) + .eventType(eventType) + .processInstanceId(delegateTask.getProcessInstanceId()) + .processDefinitionId(delegateTask.getProcessDefinitionId()) + .taskElementName(delegateTask.getTaskDefinitionKey()) + .formKey(delegateTask.getBpmnModelElementInstance().getCamundaFormKey()) + .assignee(delegateTask.getAssignee()) + .candidateGroups(delegateTask.getBpmnModelElementInstance().getCamundaCandidateGroupsList()) + .candidateUsers(delegateTask.getBpmnModelElementInstance().getCamundaCandidateUsersList()) + .dueDate(dueDate) + .followUpDate(followUpDate) + .priority(delegateTask.getPriority()) + .variables(delegateTask.getVariables()) + .build(); + exportTaskEvent(task); + } + + @Override + public void exportDeployEvent(BpmnDiagram bpmnDiagram) { + this.template.send(deployTopic, bpmnDiagram.getDiagramId(), bpmnDiagram); + } +} diff --git a/custom-tasklist-exporter-based/c7-exporter/src/test/java/org/camunda/bpm/run/ExporterTest.java b/custom-tasklist-exporter-based/c7-exporter/src/test/java/org/camunda/bpm/run/ExporterTest.java new file mode 100644 index 00000000..5f9c6bb7 --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/test/java/org/camunda/bpm/run/ExporterTest.java @@ -0,0 +1,152 @@ +package org.camunda.bpm.run; + +import static org.junit.jupiter.api.Assertions.*; + +import com.camunda.consulting.impl.CompletedTaskMessage; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import org.apache.kafka.clients.consumer.Consumer; +import org.apache.kafka.clients.consumer.ConsumerConfig; +import org.apache.kafka.clients.consumer.ConsumerRecord; +import org.apache.kafka.clients.producer.Producer; +import org.apache.kafka.clients.producer.ProducerRecord; +import org.apache.kafka.common.serialization.StringDeserializer; +import org.apache.kafka.common.serialization.StringSerializer; +import org.camunda.bpm.engine.RepositoryService; +import org.camunda.bpm.engine.RuntimeService; +import org.camunda.bpm.engine.TaskService; +import org.camunda.bpm.engine.repository.ProcessDefinitionQuery; +import org.camunda.bpm.engine.test.junit5.ProcessEngineExtension; +import org.camunda.bpm.model.bpmn.Bpmn; +import org.camunda.bpm.model.bpmn.BpmnModelInstance; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.kafka.core.DefaultKafkaConsumerFactory; +import org.springframework.kafka.core.DefaultKafkaProducerFactory; +import org.springframework.kafka.support.serializer.JsonSerializer; +import org.springframework.kafka.test.EmbeddedKafkaBroker; +import org.springframework.kafka.test.context.EmbeddedKafka; +import org.springframework.kafka.test.utils.KafkaTestUtils; +import org.springframework.test.context.junit.jupiter.SpringExtension; + +@EmbeddedKafka(partitions = 1 , brokerProperties = { "listeners=PLAINTEXT://localhost:9092" , "port=9092" }) +@ExtendWith(SpringExtension.class) +public class ExporterTest { + + @RegisterExtension + ProcessEngineExtension extension = ProcessEngineExtension.builder() + .configurationResource("camunda.cfg.xml") + .build(); + + private static final String USERTASK_TOPIC = "usertask-info" ; + private static final String DEPLOY_TOPIC = "deploy-info" ; + private static final String ENGINE_TOPIC = "C7Engine" ; + + private static final String PROCESS_KEY = "test" ; + private static final String PROCESS_FILE_NAME = "test.bpmn" ; + + private RuntimeService runtimeService; + private RepositoryService repositoryService; + private TaskService taskService; + @Autowired + private EmbeddedKafkaBroker embeddedKafkaBroker; + + @BeforeEach + public void setup() { + taskService = extension.getProcessEngine().getTaskService(); + runtimeService = extension.getProcessEngine().getRuntimeService(); + repositoryService = extension.getProcessEngine().getRepositoryService(); + } + + @Test + public void whenDeploySendToTopic() { + // Given + Consumer consumer = configureConsumer(DEPLOY_TOPIC); + BpmnModelInstance model = Bpmn.createExecutableProcess(PROCESS_KEY) + .name(PROCESS_KEY) + .startEvent() + .endEvent() + .done(); + // When + repositoryService.createDeployment() + .addModelInstance(PROCESS_FILE_NAME, model) + .deploy(); + + ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery(); + assertEquals(1, query.count()); + String id = query.list().get(0).getId(); + // Then + ConsumerRecord record = KafkaTestUtils.getSingleRecord(consumer, DEPLOY_TOPIC); + + assertNotNull(record); + assertEquals(id, record.key()); + assertTrue(record.value().toString().contains( "processDefinition")); + } + + @Test + public void whenCompleteUserTaskReceivedCompleteOnEngine() throws InterruptedException { + // Given + createUserTask(); + assertEquals(1, taskService.createTaskQuery().count()); + String taskId = taskService.createTaskQuery().list().get(0).getId(); + Producer producer = configureProducer(); + CompletedTaskMessage message = new CompletedTaskMessage(); + message.setId(taskId); + // When + ProducerRecord record = new ProducerRecord<>(ENGINE_TOPIC, taskId, message); + producer.send(record); + Thread.sleep(1000); + // Then + assertEquals(0, taskService.createTaskQuery().count()); + + } + + // TODO Figure out how to use Event Plugin in Spring xml config + //@Test + public void whenCreateUserTaskSendToTopic() { + // Given + Consumer consumer = configureConsumer(USERTASK_TOPIC); + createUserTask(); + // When + runtimeService.startProcessInstanceByKey(PROCESS_KEY); + assertEquals(1, taskService.createTaskQuery().count()); + // Then + ConsumerRecord record = KafkaTestUtils.getSingleRecord(consumer, USERTASK_TOPIC); + assertNotNull(record); + } + + private Consumer configureConsumer(String topic) { + Map consumerProps = KafkaTestUtils.consumerProps("testGroup", "true", embeddedKafkaBroker); + consumerProps.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest"); + Consumer consumer = new DefaultKafkaConsumerFactory(consumerProps, new StringDeserializer(), new StringDeserializer()) + .createConsumer(); + consumer.subscribe(Collections.singleton(topic)); + return consumer; + } + + private Producer configureProducer() { + Map producerProps = new HashMap<>(KafkaTestUtils.producerProps(embeddedKafkaBroker)); + return new DefaultKafkaProducerFactory(producerProps, new StringSerializer(), new JsonSerializer<>()).createProducer(); + } + + private void createUserTask() { + BpmnModelInstance model = Bpmn.createExecutableProcess(PROCESS_KEY) + .name(PROCESS_KEY) + .startEvent() + .userTask() + .endEvent() + .done(); + + repositoryService + .createDeployment() + .addModelInstance(PROCESS_FILE_NAME, model) + .deploy(); + + runtimeService.startProcessInstanceByKey(PROCESS_KEY); + } + +} diff --git a/custom-tasklist-exporter-based/c7-exporter/src/test/resources/camunda.cfg.xml b/custom-tasklist-exporter-based/c7-exporter/src/test/resources/camunda.cfg.xml new file mode 100644 index 00000000..e4f8b3dd --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/test/resources/camunda.cfg.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/custom-tasklist-exporter-based/c7-exporter/src/test/resources/logback-test.xml b/custom-tasklist-exporter-based/c7-exporter/src/test/resources/logback-test.xml new file mode 100644 index 00000000..1759702d --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/test/resources/logback-test.xml @@ -0,0 +1,63 @@ + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + + + + + + + + + + + + + + diff --git a/custom-tasklist-exporter-based/c7-exporter/src/test/resources/logging.properties b/custom-tasklist-exporter-based/c7-exporter/src/test/resources/logging.properties new file mode 100644 index 00000000..7b26dc03 --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/test/resources/logging.properties @@ -0,0 +1,2 @@ +#register SLF4JBridgeHandler as handler for the j.u.l. root logger +handlers=org.slf4j.bridge.SLF4JBridgeHandler diff --git a/custom-tasklist-exporter-based/c7-exporter/src/test/resources/process.bpmn b/custom-tasklist-exporter-based/c7-exporter/src/test/resources/process.bpmn new file mode 100644 index 00000000..c17197b3 --- /dev/null +++ b/custom-tasklist-exporter-based/c7-exporter/src/test/resources/process.bpmn @@ -0,0 +1,47 @@ + + + + + SequenceFlow1 + + + SequenceFlow_14t5oxg + + + + + SequenceFlow1 + SequenceFlow_14t5oxg + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/custom-tasklist-exporter-based/c8-exporter/pom.xml b/custom-tasklist-exporter-based/c8-exporter/pom.xml new file mode 100644 index 00000000..261fb236 --- /dev/null +++ b/custom-tasklist-exporter-based/c8-exporter/pom.xml @@ -0,0 +1,82 @@ + + + 4.0.0 + + + com.camunda.consulting + tasklist-parent + 1.0-SNAPSHOT + + + com.camunda.consulting + c8-exporter + + c8-exporter + + + 17 + 17 + + + + + com.camunda.consulting + model + + + + org.apache.kafka + connect-json + + + + io.camunda + zeebe-exporter-api + + + + + + org.junit.jupiter + junit-jupiter-api + test + + + + junit + junit + 4.13.2 + test + + + + + + + + org.apache.maven.plugins + maven-shade-plugin + + + package + + shade + + + + + org.apache.kafka:kafka-clients + org.apache.kafka:connect-json + com.camunda.consulting:model + + + + + + + + + diff --git a/custom-tasklist-exporter-based/c8-exporter/src/main/java/com/camunda/consulting/KafkaExporter.java b/custom-tasklist-exporter-based/c8-exporter/src/main/java/com/camunda/consulting/KafkaExporter.java new file mode 100644 index 00000000..45f4c268 --- /dev/null +++ b/custom-tasklist-exporter-based/c8-exporter/src/main/java/com/camunda/consulting/KafkaExporter.java @@ -0,0 +1,224 @@ +package com.camunda.consulting; + +import com.camunda.consulting.impl.BpmnDiagram; +import com.camunda.consulting.impl.UserTask; +import com.fasterxml.jackson.databind.ObjectMapper; +import io.camunda.zeebe.exporter.api.Exporter; +import io.camunda.zeebe.exporter.api.context.Context; +import io.camunda.zeebe.exporter.api.context.Controller; +import io.camunda.zeebe.protocol.record.Record; +import io.camunda.zeebe.protocol.record.RecordType; +import io.camunda.zeebe.protocol.record.RecordValue; +import io.camunda.zeebe.protocol.record.intent.Intent; +import io.camunda.zeebe.protocol.record.intent.JobBatchIntent; +import io.camunda.zeebe.protocol.record.intent.JobIntent; +import io.camunda.zeebe.protocol.record.value.DeploymentRecordValue; +import io.camunda.zeebe.protocol.record.value.JobBatchRecordValue; +import io.camunda.zeebe.protocol.record.value.JobRecordValue; +import io.camunda.zeebe.protocol.record.value.deployment.DeploymentResource; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import org.apache.kafka.clients.producer.KafkaProducer; +import org.apache.kafka.clients.producer.Producer; +import org.apache.kafka.clients.producer.ProducerRecord; +import org.apache.kafka.common.serialization.StringSerializer; +import org.apache.kafka.connect.json.JsonSerializer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class KafkaExporter implements Exporter { + + private String sourceId; + private Producer producer; + private static String exporterJobType = "io.camunda.zeebe:userTask"; + private static String kafkaTopicUsertask = "usertask-info"; + private static String kafkaTopicDeploy = "deploy-info"; + + Logger logger = LoggerFactory.getLogger(KafkaExporter.class); + + @Override + public void configure(Context context) throws Exception { + Exporter.super.configure(context); + Map config = context.getConfiguration().getArguments(); + this.sourceId = (String) config.get("sourceid"); + String kafkaUrl = (String) config.get("url"); + String jobType = (String) config.get("jobtype"); + String kafkaTopicUserTask = (String) config.get("kafkatopicusertask"); + String kafkaTopicDeploy = (String) config.get("kafkatopicdeploy"); + + if (sourceId == null || kafkaUrl == null) { + throw new IllegalArgumentException("sourceId and kafkaUrl are required"); + } + + if (jobType != null) { + exporterJobType = jobType; + } + + if (kafkaTopicUserTask != null) { + kafkaTopicUsertask = kafkaTopicUserTask; + } + + if (kafkaTopicDeploy != null) { + KafkaExporter.kafkaTopicDeploy = kafkaTopicDeploy; + } + + logger.info("Exporter Configuration: " + config); + + Properties props = new Properties(); + props.put("bootstrap.servers", kafkaUrl); + props.put("key.serializer", StringSerializer.class.getName()); + props.put("value.serializer", JsonSerializer.class.getName()); + producer = new KafkaProducer<>(props); + } + + @Override + public void open(Controller controller) { + Exporter.super.open(controller); + } + + @Override + public void close() { + Exporter.super.close(); + } + + @Override + public void export(Record record) { + + RecordValue recordValue = record.getValue(); + Intent intent = record.getIntent(); + + if (record.getRecordType() == RecordType.EVENT) { + + switch (record.getValueType()) { + case JOB_BATCH: + exportJobBatch((JobBatchRecordValue) recordValue, intent); + break; + case JOB: + exportJob((JobRecordValue) recordValue, (JobIntent) intent); + break; + case DEPLOYMENT: + exportDeployment((DeploymentRecordValue) recordValue, intent); + break; + } + } + } + + + private void exportJobBatch(JobBatchRecordValue recordValue, Intent intent) { + if (intent == JobBatchIntent.ACTIVATED) { + logger.debug("Export JobBatchRecordValue: {}", recordValue); + for (int i = 0; i < recordValue.getJobKeys().size(); i++) { + long jobKey = recordValue.getJobKeys().get(i); + JobRecordValue jobRecordValue = recordValue.getJobs().get(i); + if(jobRecordValue.getType().equals(exporterJobType)) { + UserTask userTask = toUserTask(sourceId, EventType.CREATED, jobRecordValue, jobKey); + sendToKafka(recordValue.getJobKeys().get(i), userTask); + } + } + } + } + + private void exportJob(JobRecordValue jobRecordValue, + JobIntent intent) { + UserTask userTask; + if (jobRecordValue.getType().equals(exporterJobType)) { + switch (intent) { + case CANCELED: + userTask = toUserTask(sourceId, EventType.ENDED, jobRecordValue); + logger.debug("UserTask canceled: {}", userTask); + sendToKafka(jobRecordValue.getElementInstanceKey(), userTask); + break; + case COMPLETED: + userTask = toUserTask(sourceId, EventType.COMPLETED, jobRecordValue); + logger.debug("UserTask completed: {}", userTask); + sendToKafka(jobRecordValue.getElementInstanceKey(), userTask); + break; + } + } + } + + private void exportDeployment(DeploymentRecordValue recordValue, Intent intent) { + List resources = recordValue.getResources(); + for (int i = 0; i < resources.size(); i++) { + DeploymentResource resource = resources.get(i); + String resourceName = resource.getResourceName(); + if(resourceName.endsWith(".bpmn")) { + String id = String.valueOf( + recordValue.getProcessesMetadata().get(i).getProcessDefinitionKey()); + String processDefinition = new String(resource.getResource()); + BpmnDiagram bpmnDiagram = new BpmnDiagram(id, processDefinition); + ObjectMapper mapper = new ObjectMapper(); + + ProducerRecord record = new ProducerRecord(kafkaTopicDeploy, id, mapper.valueToTree(bpmnDiagram)); + record.headers().add("__TypeId__", bpmnDiagram.getClass().getCanonicalName().getBytes()); + producer.send(record); + } + + } + } + + private void sendToKafka(long key, UserTask userTask) { + + try { + ObjectMapper mapper = new ObjectMapper(); + ProducerRecord record = new ProducerRecord<>(kafkaTopicUsertask, String.valueOf(key), + mapper.valueToTree(userTask)); + record.headers().add("__TypeId__", userTask.getClass().getCanonicalName().getBytes()); + producer.send(record); + } catch (Exception ex) { + logger.error("Error sending userTask to kafka: {}", ex.getMessage()); + } + } + + private UserTask toUserTask(String sourceId, EventType eventType, JobRecordValue jobRecordValue) { + String priorityString = jobRecordValue.getCustomHeaders().get("priority"); + int priority = priorityString == null ? 0 : Integer.parseInt(priorityString); + + UserTask task = UserTask.builder() + .userTaskId(String.valueOf(jobRecordValue.getElementInstanceKey())) + .source(sourceId) + .eventType(eventType) + .processInstanceId(String.valueOf(jobRecordValue.getProcessInstanceKey())) + .processDefinitionId(String.valueOf(jobRecordValue.getProcessDefinitionKey())) + .taskElementName(jobRecordValue.getElementId()) + .formKey(jobRecordValue.getCustomHeaders().get("io.camunda.zeebe:formKey")) + .assignee(jobRecordValue.getCustomHeaders().get("io.camunda.zeebe:assignee")) + .candidateGroups(candidateStringToList( + jobRecordValue.getCustomHeaders().get("io.camunda.zeebe:candidateGroups"))) + .candidateUsers( + candidateStringToList(jobRecordValue.getCustomHeaders().get("candidateUsers"))) + .dueDate(jobRecordValue.getCustomHeaders().get("dueDate")) + .followUpDate(jobRecordValue.getCustomHeaders().get("followUpDate")) + .priority(priority) + .variables(jobRecordValue.getVariables()) + .build(); + + return task; + } + + private UserTask toUserTask(String sourceId, EventType eventType, JobRecordValue jobRecordValue, + long jobKey) { + UserTask task = toUserTask(sourceId, eventType, jobRecordValue); + task.setJobKey(String.valueOf(jobKey)); + return task; + } + + private List candidateStringToList(String candidateString) { + if (candidateString != null) { + String reducedCandidateString = candidateString + .replace("[", "") + .replace("]", "") + .replace(" ", "") + .replace("\"", ""); + return Arrays.asList(reducedCandidateString.split(",")); + } + return null; + } + + void setProducer(Producer producer) { + this.producer = producer; + } + +} diff --git a/custom-tasklist-exporter-based/c8-exporter/src/test/java/com/camunda/consulting/ExporterTest.java b/custom-tasklist-exporter-based/c8-exporter/src/test/java/com/camunda/consulting/ExporterTest.java new file mode 100644 index 00000000..668489ac --- /dev/null +++ b/custom-tasklist-exporter-based/c8-exporter/src/test/java/com/camunda/consulting/ExporterTest.java @@ -0,0 +1,160 @@ +package com.camunda.consulting; + +import static org.junit.jupiter.api.Assertions.*; + +import com.camunda.consulting.impl.BpmnDiagram; +import com.camunda.consulting.impl.UserTask; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import io.camunda.zeebe.protocol.record.ImmutableRecord; +import io.camunda.zeebe.protocol.record.RecordType; +import io.camunda.zeebe.protocol.record.ValueType; +import io.camunda.zeebe.protocol.record.intent.JobBatchIntent; +import io.camunda.zeebe.protocol.record.intent.JobIntent; +import io.camunda.zeebe.protocol.record.value.ImmutableDeploymentRecordValue; +import io.camunda.zeebe.protocol.record.value.ImmutableJobBatchRecordValue; +import io.camunda.zeebe.protocol.record.value.ImmutableJobRecordValue; +import io.camunda.zeebe.protocol.record.value.deployment.ImmutableDeploymentResource; +import io.camunda.zeebe.protocol.record.value.deployment.ImmutableProcessMetadataValue; +import java.util.List; +import org.apache.kafka.clients.producer.MockProducer; +import org.apache.kafka.common.serialization.StringSerializer; +import org.apache.kafka.connect.json.JsonSerializer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + + +public class ExporterTest { + + private final KafkaExporter exporter = new KafkaExporter(); + private final MockProducer mockProducer = new MockProducer<>(true, new StringSerializer(), new JsonSerializer()); + + private final ObjectMapper mapper = new ObjectMapper(); + + @BeforeEach + public void setup() { + exporter.setProducer(mockProducer); + } + + @Test + public void whenDeploySendToTopic() { + // Given + String proccesId = "aProcessId"; + Long processKey = 123L; + String resourceName = "aResourceName.bpmn"; + String bpmnXml = "aBpmnXml"; + + ImmutableDeploymentResource resource = ImmutableDeploymentResource.builder() + .withResourceName("test.bpmn") + .withResource(bpmnXml.getBytes()) + .build(); + + ImmutableRecord record = ImmutableRecord.builder().withRecordType(RecordType.EVENT) + .withValueType(ValueType.DEPLOYMENT) + .withValue(ImmutableDeploymentRecordValue.builder() + .withResources(List.of(resource)) + .withProcessesMetadata(List.of(ImmutableProcessMetadataValue.builder() + .withResourceName(resourceName) + .withProcessDefinitionKey(processKey) + .withBpmnProcessId(proccesId) + .build())) + .build()) + .build(); + + // When + exporter.export(record); + BpmnDiagram diagram = mapper.convertValue(mockProducer.history().get(0).value(), BpmnDiagram.class); + + // Then + assertEquals(1, mockProducer.history().size()); + assertEquals(processKey.toString(), mockProducer.history().get(0).key()); + assertEquals(processKey.toString(), diagram.getDiagramId()); + assertEquals(bpmnXml, diagram.getProcessDefinition()); + } + + @Test + public void whenUserTaskSendToTopic() { + // Given + Long jobKey = 123L; + Long elementInstanceKey = 456L; + Long processKey = 789L; + + ImmutableJobRecordValue jobRecordValue = getImmutableJobRecordValue(elementInstanceKey, processKey); + + ImmutableJobBatchRecordValue jobBatchRecordValue = ImmutableJobBatchRecordValue.builder() + .withJobs(List.of(jobRecordValue)) + .withJobKeys(List.of(jobKey)) + .build(); + + // When + exporter.export(ImmutableRecord.builder().withRecordType(RecordType.EVENT) + .withIntent(JobBatchIntent.ACTIVATED) + .withValueType(ValueType.JOB_BATCH) + .withValue(jobBatchRecordValue) + .build()); + + UserTask userTask = mapper.convertValue(mockProducer.history().get(0).value(), UserTask.class); + + // Then + assertEquals(1, mockProducer.history().size()); + assertEquals(jobKey.toString(), mockProducer.history().get(0).key()); + assertEquals(jobKey.toString(), userTask.getJobKey()); + assertEquals(elementInstanceKey.toString(), userTask.getUserTaskId()); + assertEquals(processKey.toString(), userTask.getProcessDefinitionId()); + assertEquals(EventType.CREATED,userTask.getEventType()); + } + + @Test + public void whenUserTaskCompleteSendToTopic() { + // Given + Long elementInstanceKey = 456L; + Long processKey = 789L; + + ImmutableJobRecordValue jobRecordValue = getImmutableJobRecordValue(elementInstanceKey, processKey); + + exporter.export(ImmutableRecord.builder().withRecordType(RecordType.EVENT) + .withIntent(JobIntent.COMPLETED) + .withValueType(ValueType.JOB) + .withValue(jobRecordValue) + .build()); + + assertEquals(1, mockProducer.history().size()); + UserTask userTask = mapper.convertValue(mockProducer.history().get(0).value(), UserTask.class); + assertEquals(EventType.COMPLETED,userTask.getEventType()); + } + + @Test + public void whenUserTaskCanceledSendToTopic() { + // Given + Long elementInstanceKey = 456L; + Long processKey = 789L; + + ImmutableJobRecordValue jobRecordValue = getImmutableJobRecordValue(elementInstanceKey, processKey); + + // When + exporter.export(ImmutableRecord.builder().withRecordType(RecordType.EVENT) + .withIntent(JobIntent.CANCELED) + .withValueType(ValueType.JOB) + .withValue(jobRecordValue) + .build()); + + // Then + assertEquals(1, mockProducer.history().size()); + UserTask userTask = mapper.convertValue(mockProducer.history().get(0).value(), UserTask.class); + assertEquals(EventType.ENDED,userTask.getEventType()); + + } + + private static ImmutableJobRecordValue getImmutableJobRecordValue(Long elementInstanceKey, + Long processKey) { + ImmutableJobRecordValue jobRecordValue = ImmutableJobRecordValue.builder() + .withProcessDefinitionKey(processKey) + .withProcessDefinitionVersion(1) + .withType("io.camunda.zeebe:userTask") + .withElementId("aElementId") + .withElementInstanceKey(elementInstanceKey) + .build(); + return jobRecordValue; + } + +} diff --git a/custom-tasklist-exporter-based/c8-jobworker/Dockerfile b/custom-tasklist-exporter-based/c8-jobworker/Dockerfile new file mode 100644 index 00000000..55653fc8 --- /dev/null +++ b/custom-tasklist-exporter-based/c8-jobworker/Dockerfile @@ -0,0 +1,4 @@ +FROM openjdk:17-oracle +ARG JAR_FILE=target/c8-jobworker-1.0-SNAPSHOT.jar +COPY ${JAR_FILE} app.jar +ENTRYPOINT ["java","-jar","/app.jar"] \ No newline at end of file diff --git a/custom-tasklist-exporter-based/c8-jobworker/pom.xml b/custom-tasklist-exporter-based/c8-jobworker/pom.xml new file mode 100644 index 00000000..07ffca67 --- /dev/null +++ b/custom-tasklist-exporter-based/c8-jobworker/pom.xml @@ -0,0 +1,93 @@ + + + 4.0.0 + + + com.camunda.consulting + tasklist-parent + 1.0-SNAPSHOT + + + com.camunda.consulting + c8-jobworker + + c8-jobworker + + + + com.camunda.consulting + model + + + org.springframework.boot + spring-boot-starter + + + org.springframework.kafka + spring-kafka + + + io.camunda + zeebe-client-java + + + + + + org.junit.jupiter + junit-jupiter-api + test + + + + junit + junit + 4.13.2 + test + + + + io.camunda + zeebe-process-test-extension + ${c8.version} + test + + + + + + + org.apache.maven.plugins + maven-shade-plugin + + + org.springframework.boot + spring-boot-maven-plugin + + com.camunda.consulting.UserTaskWorkerApplication + JAR + + + + + repackage + + + + + + + + + + + + org.springframework.boot + spring-boot-dependencies + + + + diff --git a/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/UserTaskWorkerApplication.java b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/UserTaskWorkerApplication.java new file mode 100644 index 00000000..148d4aad --- /dev/null +++ b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/UserTaskWorkerApplication.java @@ -0,0 +1,12 @@ +package com.camunda.consulting; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class UserTaskWorkerApplication { + + public static void main(String[] args) { + SpringApplication.run(UserTaskWorkerApplication.class, args); + } +} diff --git a/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/listener/CannotCompleteTaskException.java b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/listener/CannotCompleteTaskException.java new file mode 100644 index 00000000..2f27b65b --- /dev/null +++ b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/listener/CannotCompleteTaskException.java @@ -0,0 +1,8 @@ +package com.camunda.consulting.listener; + +public class CannotCompleteTaskException extends Exception { + + public CannotCompleteTaskException(String message) { + super(message); + } +} diff --git a/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/listener/CompletedTaskListener.java b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/listener/CompletedTaskListener.java new file mode 100644 index 00000000..f3e558c5 --- /dev/null +++ b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/listener/CompletedTaskListener.java @@ -0,0 +1,35 @@ +package com.camunda.consulting.listener; + +import com.camunda.consulting.CompleteAction; +import io.camunda.zeebe.client.ZeebeClient; +import java.util.logging.Logger; +import org.springframework.kafka.annotation.KafkaListener; +import org.springframework.stereotype.Component; + +@Component +public class CompletedTaskListener { + + private final Logger LOGGER = Logger.getLogger(CompletedTaskListener.class.getName()); + + private final ZeebeClient client; + + public CompletedTaskListener(ZeebeClient client) { + System.out.println("CompletedTaskListener Created"); + this.client = client; + } + + + @KafkaListener(topics = "${tasklist.kafka.topic}") + public void listen(CompleteAction message) throws CannotCompleteTaskException { + LOGGER.info("Received CompletedTaskMessage: " + message); + try { + client.newCompleteCommand(Long.parseLong(message.getId())) + .variables(message.getVariables()) + .send() + .join(); + } catch (Exception e) { + throw new CannotCompleteTaskException("Error while completing UserTask: " + message + " - " + e.getMessage()); + } + } + +} diff --git a/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/zeebe/ClientConfiguration.java b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/zeebe/ClientConfiguration.java new file mode 100644 index 00000000..e194c6fd --- /dev/null +++ b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/zeebe/ClientConfiguration.java @@ -0,0 +1,47 @@ +package com.camunda.consulting.zeebe; + +import io.camunda.zeebe.client.ZeebeClient; +import io.camunda.zeebe.client.ZeebeClientBuilder; +import io.camunda.zeebe.client.api.worker.JobWorker; +import java.time.Duration; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +@Configuration +public class ClientConfiguration { + + final String JOB_TYPE = "io.camunda.zeebe:userTask"; + + @Bean + public ZeebeClient zeebeClient() { + final String defaultAddress = "localhost:26500"; + final String envVarAddress = System.getenv("ZEEBE_ADDRESS"); + + final ZeebeClientBuilder clientBuilder; + if (envVarAddress != null) { + /* Connect to Camunda Cloud Cluster, assumes that credentials are set in environment variables. + * See JavaDoc on class level for details + */ + clientBuilder = ZeebeClient.newClientBuilder().gatewayAddress(envVarAddress).usePlaintext(); + } else { + // connect to local deployment; assumes that authentication is disabled + clientBuilder = ZeebeClient.newClientBuilder().gatewayAddress(defaultAddress).usePlaintext(); + } + + return clientBuilder + .defaultJobWorkerName("userTaskWorker") + .build(); + } + + @Bean + public JobWorker jobWorker(ZeebeClient client) { + return client + .newWorker() + .jobType(JOB_TYPE) + .handler(new UserTaskHandler()) + .timeout(Duration.ofDays(30)) + .open(); + } + + +} diff --git a/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/zeebe/UserTaskHandler.java b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/zeebe/UserTaskHandler.java new file mode 100644 index 00000000..d23f3856 --- /dev/null +++ b/custom-tasklist-exporter-based/c8-jobworker/src/main/java/com/camunda/consulting/zeebe/UserTaskHandler.java @@ -0,0 +1,17 @@ +package com.camunda.consulting.zeebe; + +import io.camunda.zeebe.client.api.response.ActivatedJob; +import io.camunda.zeebe.client.api.worker.JobClient; +import io.camunda.zeebe.client.api.worker.JobHandler; +import java.util.logging.Logger; + + +public class UserTaskHandler implements JobHandler { + + private final Logger LOGGER = Logger.getLogger(UserTaskHandler.class.getName()); + + @Override + public void handle(JobClient client, ActivatedJob job) throws Exception { + LOGGER.finest("User Task received: " + job); + } +} diff --git a/custom-tasklist-exporter-based/c8-jobworker/src/main/resources/application.yaml b/custom-tasklist-exporter-based/c8-jobworker/src/main/resources/application.yaml new file mode 100644 index 00000000..e8980ebb --- /dev/null +++ b/custom-tasklist-exporter-based/c8-jobworker/src/main/resources/application.yaml @@ -0,0 +1,21 @@ +server: + port: 8084 +tasklist: + kafka: + topic: C8LocalMachine +spring: + kafka: + bootstrap-servers: localhost:29092 + consumer: + key-deserializer: org.apache.kafka.common.serialization.StringDeserializer + value-deserializer: org.springframework.kafka.support.serializer.ErrorHandlingDeserializer + group-id: usertask-worker + properties: + spring: + deserializer: + value: + delegate: + class: org.springframework.kafka.support.serializer.JsonDeserializer + spring.json.trusted.packages: "com.camunda.consulting.*" + spring.json.use.type.headers: true + spring.json.value.default.type: com.camunda.consulting.CompleteAction \ No newline at end of file diff --git a/custom-tasklist-exporter-based/c8-jobworker/src/test/java/com/camunda/consulting/CompleteTaskListenerTest.java b/custom-tasklist-exporter-based/c8-jobworker/src/test/java/com/camunda/consulting/CompleteTaskListenerTest.java new file mode 100644 index 00000000..e9da3791 --- /dev/null +++ b/custom-tasklist-exporter-based/c8-jobworker/src/test/java/com/camunda/consulting/CompleteTaskListenerTest.java @@ -0,0 +1,97 @@ +package com.camunda.consulting; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import com.camunda.consulting.impl.CompletedTaskMessage; +import com.camunda.consulting.listener.CannotCompleteTaskException; +import com.camunda.consulting.listener.CompletedTaskListener; +import io.camunda.zeebe.client.ZeebeClient; +import io.camunda.zeebe.client.api.response.ActivateJobsResponse; +import io.camunda.zeebe.client.api.response.ActivatedJob; +import io.camunda.zeebe.client.api.response.ProcessInstanceEvent; +import io.camunda.zeebe.model.bpmn.Bpmn; +import io.camunda.zeebe.model.bpmn.BpmnModelInstance; +import io.camunda.zeebe.process.test.api.ZeebeTestEngine; +import io.camunda.zeebe.process.test.assertions.BpmnAssert; +import io.camunda.zeebe.process.test.assertions.ProcessInstanceAssert; +import io.camunda.zeebe.process.test.extension.ZeebeProcessTest; +import java.time.Duration; +import java.util.Map; +import java.util.concurrent.TimeoutException; +import org.junit.jupiter.api.Test; + +@ZeebeProcessTest +public class CompleteTaskListenerTest { + + private ZeebeTestEngine engine; + private ZeebeClient client; + + + @Test + public void whenCompleteReceivedCompleteUserTask() + throws InterruptedException, TimeoutException, CannotCompleteTaskException { + + // Given + BpmnModelInstance process = Bpmn.createExecutableProcess("process") + .startEvent() + .userTask("userTask") + .endEvent() + .done(); + + client.newDeployResourceCommand() + .addProcessModel(process, "process.bpmn") + .send() + .join(); + + ProcessInstanceEvent event = client.newCreateInstanceCommand() + .bpmnProcessId("process") + .latestVersion() + .send() + .join(); + + engine.waitForIdleState(Duration.ofSeconds(1)); + + ProcessInstanceAssert instance = BpmnAssert.assertThat(event); + + instance.isWaitingAtElements("userTask"); + + ActivateJobsResponse response = client.newActivateJobsCommand() + .jobType("io.camunda.zeebe:userTask") + .maxJobsToActivate(1) + .send() + .join(); + + assertEquals(1, response.getJobs().size()); + + ActivatedJob activatedJob = response.getJobs().get(0); + long jobKey = activatedJob.getKey(); + CompletedTaskMessage completedTaskMessage = new CompletedTaskMessage(); + completedTaskMessage.setId(String.valueOf(jobKey)); + completedTaskMessage.setVariables(Map.of("test", "test")); + + // When + CompletedTaskListener listener = new CompletedTaskListener(client); + listener.listen(completedTaskMessage); + engine.waitForIdleState(Duration.ofSeconds(1)); + + // Then + instance.isCompleted(); + instance.hasVariableWithValue("test", "test"); + } + + @Test + public void whenCompleteTaskThatDoesNotExistThrow() { + // Given + CompletedTaskMessage completedTaskMessage = new CompletedTaskMessage(); + completedTaskMessage.setId("123"); + completedTaskMessage.setVariables(Map.of("test", "test")); + + // When + CompletedTaskListener listener = new CompletedTaskListener(client); + + // Then + assertThrows(CannotCompleteTaskException.class, () -> listener.listen(completedTaskMessage)); + } + +} diff --git a/custom-tasklist-exporter-based/config/c7-default.yml b/custom-tasklist-exporter-based/config/c7-default.yml new file mode 100644 index 00000000..60da0dcc --- /dev/null +++ b/custom-tasklist-exporter-based/config/c7-default.yml @@ -0,0 +1,43 @@ +# Find more available configuration properties on the following pages of the documentation. +# https://docs.camunda.org/manual/latest/user-guide/camunda-bpm-run/#configure-camunda-bpm-run +# https://docs.camunda.org/manual/latest/user-guide/spring-boot-integration/configuration/#camunda-engine-properties + +camunda.bpm: + admin-user: + id: demo + password: demo + authorization.enabled: true + run: + # https://docs.camunda.org/manual/latest/user-guide/camunda-bpm-run/#cross-origin-resource-sharing + cors: + enabled: true + allowed-origins: "*" + # https://docs.camunda.org/manual/latest/user-guide/camunda-bpm-run/#example-application + example: + enabled: false + process-engine-plugins: + - plugin-class: org.camunda.bpm.run.EventExporter + plugin-parameters: + bootstrapServer: kafka:9092 + userTaskTopic: usertask-info + deployTopic: deploy-info + sourceId: C7Engine + groupId: C7Engine + clientId: C7FirstClient + +# datasource configuration is required +spring.datasource: + url: jdbc:h2:./camunda-h2-default/process-engine;TRACE_LEVEL_FILE=0;DB_CLOSE_ON_EXIT=FALSE + driver-class-name: org.h2.Driver + username: sa + password: sa + +# By default, Spring Boot serves static content from any directories called /static or /public or /resources or +# /META-INF/resources in the classpath. To prevent users from accidentally sharing files, this is disabled here by setting static locations to NULL. +# https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-spring-mvc-static-content +spring.web.resources: + static-locations: NULL + +logging: + level.root: INFO + file.name: logs/camunda-bpm-run.log \ No newline at end of file diff --git a/custom-tasklist-exporter-based/config/log4j2.xml b/custom-tasklist-exporter-based/config/log4j2.xml new file mode 100644 index 00000000..63caf3d2 --- /dev/null +++ b/custom-tasklist-exporter-based/config/log4j2.xml @@ -0,0 +1,53 @@ + + + + + ${sys:app.home}/logs + %d{yyyy-MM-dd HH:mm:ss.SSS} [%X{actor-name}] [%t] %-5level + %logger{36} - %msg%n + + ${env:ZEEBE_LOG_STACKDRIVER_SERVICENAME:-} + + ${env:ZEEBE_LOG_STACKDRIVER_SERVICEVERSION:-} + + + + + + + + + + + + + + + ${log.pattern} + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/custom-tasklist-exporter-based/docker-compose.yml b/custom-tasklist-exporter-based/docker-compose.yml new file mode 100644 index 00000000..fb6e6867 --- /dev/null +++ b/custom-tasklist-exporter-based/docker-compose.yml @@ -0,0 +1,141 @@ +version: '2' +services: + zeebe: # https://docs.camunda.io/docs/self-managed/platform-deployment/docker/#zeebe + image: camunda/zeebe:${CAMUNDA_PLATFORM_VERSION:-8.0.5} + container_name: zeebe + depends_on: + kafka: + condition: service_healthy + ports: + - "26500:26500" + - "9600:9600" + environment: # https://docs.camunda.io/docs/self-managed/zeebe-deployment/configuration/environment-variables/ + - ZEEBE_BROKER_EXPORTERS_KAFKA_CLASSNAME=com.camunda.consulting.KafkaExporter + - ZEEBE_BROKER_EXPORTERS_KAFKA_JARPATH=lib/c8-exporter-1.0-SNAPSHOT.jar + - ZEEBE_BROKER_EXPORTERS_KAFKA_ARGS_SOURCEID=C8LocalMachine + - ZEEBE_BROKER_EXPORTERS_KAFKA_ARGS_JOBTYPE=io.camunda.zeebe:userTask + - ZEEBE_BROKER_EXPORTERS_KAFKA_ARGS_KAFKATOPICUSERTASK=usertask-info + - ZEEBE_BROKER_EXPORTERS_KAFKA_ARGS_KAFKATOPICDEPLOY=deploy-info + - ZEEBE_BROKER_EXPORTERS_KAFKA_ARGS_URL=kafka:9092 + # allow running with low disk space + - ZEEBE_BROKER_DATA_DISKUSAGECOMMANDWATERMARK=0.998 + - ZEEBE_BROKER_DATA_DISKUSAGEREPLICATIONWATERMARK=0.999 + - "JAVA_TOOL_OPTIONS=-Xms512m -Xmx512m" + restart: always + volumes: + - zeebe:/usr/local/zeebe/data + - type: bind + source: ./c8-exporter/target/c8-exporter-1.0-SNAPSHOT.jar + target: /usr/local/zeebe/lib/c8-exporter-1.0-SNAPSHOT.jar + - type: bind + source: ./config/log4j2.xml + target: /usr/local/zeebe/config/log4j2.xml + camunda-run: + image: registry.camunda.cloud/cambpm-ee/camunda-bpm-platform-ee:run-7.17.5 + container_name: camunda-run + volumes: + - type: bind + source: ./config/c7-default.yml + target: /camunda/configuration/default.yml + - type: bind + source: ./c7-exporter/target/c7-exporter-1.0-SNAPSHOT.jar + target: /camunda/configuration/userlib/c7-exporter-1.0-SNAPSHOT.jar + ports: + - 8080:8080 + restart: unless-stopped + mongo-express: + image: mongo-express + container_name: mongo-express + restart: always + environment: + - ME_CONFIG_MONGODB_SERVER=mongodb + - ME_CONFIG_MONGODB_PORT=27017 + - ME_CONFIG_MONGODB_ENABLE_ADMIN=true + - ME_CONFIG_MONGODB_AUTH_DATABASE=admin + - ME_CONFIG_MONGODB_AUTH_USERNAME=demo + - ME_CONFIG_MONGODB_AUTH_PASSWORD=demo + depends_on: + - mongodb + ports: + - 8081:8081 + mongodb: + image: mongo + container_name: mongodb + restart: always + ports: + - 27017:27017 + volumes: + - ~/apps/mongo:/data/db + environment: + - MONGO_INITDB_ROOT_USERNAME=demo + - MONGO_INITDB_ROOT_PASSWORD=demo + - MONGO_INITDB_DATABASE=tasks + kafka-ui: + image: provectuslabs/kafka-ui + depends_on: + - kafka + container_name: kafka-ui + ports: + - "8082:8080" + restart: always + environment: + - KAFKA_CLUSTERS_0_NAME=local + - KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS=kafka:9092 + - KAFKA_CLUSTERS_0_ZOOKEEPER=zookeeper:2181 + kafka: + image: confluentinc/cp-kafka:latest + container_name: kafka + restart: always + depends_on: + - zookeeper + ports: + - 29092:29092 + - 9092:9092 + environment: + KAFKA_BROKER_ID: 1 + KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181 + KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092 + KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT + KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT + KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1 + healthcheck: + test: nc -z localhost 9092 || exit -1 + start_period: 15s + interval: 5s + timeout: 10s + retries: 10 + zookeeper: + image: confluentinc/cp-zookeeper:latest + container_name: zookeeper + restart: always + environment: + ZOOKEEPER_CLIENT_PORT: 2181 + ZOOKEEPER_TICK_TIME: 2000 + ports: + - 22181:2181 + tasklist: + image: camundomanu/tasklist:latest + container_name: tasklist + restart: always + depends_on: + - mongodb + - kafka + ports: + - 8083:8083 + environment: + SPRING_KAFKA_BOOTSTRAP-SERVERS: kafka:9092 + SPRING_DATA_MONGODB_HOST: mongodb + tasklist-worker: + image: camundomanu/tasklist-worker:latest + container_name: tasklist-worker + restart: always + depends_on: + - kafka + - zeebe + ports: + - 8084:8084 + environment: + SPRING_KAFKA_BOOTSTRAP-SERVERS: kafka:9092 + ZEEBE_ADDRESS: zeebe:26500 +volumes: + zeebe: \ No newline at end of file diff --git a/custom-tasklist-exporter-based/documentation/architecture/architecture-overview.drawio b/custom-tasklist-exporter-based/documentation/architecture/architecture-overview.drawio new file mode 100644 index 00000000..af4384ed --- /dev/null +++ b/custom-tasklist-exporter-based/documentation/architecture/architecture-overview.drawio @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/custom-tasklist-exporter-based/documentation/architecture/architecture-overview.drawio.png b/custom-tasklist-exporter-based/documentation/architecture/architecture-overview.drawio.png new file mode 100644 index 0000000000000000000000000000000000000000..4fd238395797321b667626aac51628f3c0d34aed GIT binary patch literal 113711 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 literal 0 HcmV?d00001 diff --git a/custom-tasklist-exporter-based/documentation/frontend/Colors for Tasklist.png b/custom-tasklist-exporter-based/documentation/frontend/Colors for Tasklist.png new file mode 100644 index 0000000000000000000000000000000000000000..902d2c369e4f5bf7f48dff944197cd908854960b GIT binary patch literal 38847 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
SpBW#Y%b;(be3ky{{kIxFO%Ol$OsjLIJov#$ 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 Mtm>-@>DR&k2P=2#Pyhe` literal 0 HcmV?d00001 diff --git a/custom-tasklist-exporter-based/model/pom.xml b/custom-tasklist-exporter-based/model/pom.xml new file mode 100644 index 00000000..2db14f74 --- /dev/null +++ b/custom-tasklist-exporter-based/model/pom.xml @@ -0,0 +1,32 @@ + + + 4.0.0 + + + com.camunda.consulting + tasklist-parent + 1.0-SNAPSHOT + + + com.camunda.consulting + model + + model + + + + + + + org.springframework.boot + spring-boot-starter-data-mongodb + + + org.projectlombok + lombok + + + diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/BpmnErrorAction.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/BpmnErrorAction.java new file mode 100644 index 00000000..02c0b6a5 --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/BpmnErrorAction.java @@ -0,0 +1,13 @@ +package com.camunda.consulting; + +public interface BpmnErrorAction extends TaskAction { + + String getErrorCode(); + + void setErrorCode(String errorCode); + + String getErrorMessage(); + + void setErrorMessage(String errorMessage); + +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/CompleteAction.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/CompleteAction.java new file mode 100644 index 00000000..f3d8a036 --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/CompleteAction.java @@ -0,0 +1,9 @@ +package com.camunda.consulting; + +public interface CompleteAction extends TaskAction { + + String getCompleter(); + + void setCompleter(String completer); + +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/DeployEventExporter.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/DeployEventExporter.java new file mode 100644 index 00000000..ca4cf2eb --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/DeployEventExporter.java @@ -0,0 +1,9 @@ +package com.camunda.consulting; + +import com.camunda.consulting.impl.BpmnDiagram; + +public interface DeployEventExporter { + + void exportDeployEvent(BpmnDiagram diagram); + +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/EventType.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/EventType.java new file mode 100644 index 00000000..956aad82 --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/EventType.java @@ -0,0 +1,7 @@ +package com.camunda.consulting; + +public enum EventType { + CREATED, + COMPLETED, + ENDED +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/MessageAction.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/MessageAction.java new file mode 100644 index 00000000..1f69b2f9 --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/MessageAction.java @@ -0,0 +1,13 @@ +package com.camunda.consulting; + +public interface MessageAction extends TaskAction { + + String getMessageName(); + + void setMessageName(); + + String getCorrelationKey(); + + void setCorrelationKey(); + +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskAction.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskAction.java new file mode 100644 index 00000000..a7d9865e --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskAction.java @@ -0,0 +1,15 @@ +package com.camunda.consulting; + +import java.util.Map; + +public interface TaskAction { + + String getId(); + + void setId(String id); + + Map getVariables(); + + void setVariables(Map variables); + +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskEventExporter.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskEventExporter.java new file mode 100644 index 00000000..6f5f84e9 --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskEventExporter.java @@ -0,0 +1,9 @@ +package com.camunda.consulting; + +import com.camunda.consulting.impl.UserTask; + +public interface TaskEventExporter { + + void exportTaskEvent(UserTask userTask); + +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskHandler.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskHandler.java new file mode 100644 index 00000000..72ce931e --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/TaskHandler.java @@ -0,0 +1,11 @@ +package com.camunda.consulting; + +public interface TaskHandler { + + void completeTask(CompleteAction action); + + void throwError(BpmnErrorAction bpmnError); + + void correlateMessage(MessageAction action); + +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/BpmnDiagram.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/BpmnDiagram.java new file mode 100644 index 00000000..2bd9a995 --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/BpmnDiagram.java @@ -0,0 +1,27 @@ +package com.camunda.consulting.impl; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import lombok.ToString; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; +import org.springframework.data.mongodb.core.mapping.Field; + +@Builder +@Getter +@Setter +@NoArgsConstructor +@AllArgsConstructor +@ToString +@Document(collection = "Diagrams") +public class BpmnDiagram { + + @Id + @Field("_id") + String diagramId; + String processDefinition; + +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/CompletedTaskMessage.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/CompletedTaskMessage.java new file mode 100644 index 00000000..28c0fadf --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/CompletedTaskMessage.java @@ -0,0 +1,20 @@ +package com.camunda.consulting.impl; + +import com.camunda.consulting.CompleteAction; +import java.util.Map; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@NoArgsConstructor +@AllArgsConstructor +@Getter +@Setter +public class CompletedTaskMessage implements CompleteAction { + + private String id; + private Map variables; + private String completer; + +} diff --git a/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/UserTask.java b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/UserTask.java new file mode 100644 index 00000000..e413a7d0 --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/main/java/com/camunda/consulting/impl/UserTask.java @@ -0,0 +1,45 @@ +package com.camunda.consulting.impl; + +import com.camunda.consulting.EventType; +import java.util.List; +import java.util.Map; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import lombok.ToString; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; +import org.springframework.data.mongodb.core.mapping.Field; + +@Builder +@Getter +@Setter +@NoArgsConstructor +@AllArgsConstructor +@ToString +@Document(collection = "UserTasks") +public class UserTask { + + // required + @Id + @Field("_id") + protected String userTaskId; + protected String source; + protected EventType eventType; + protected String processInstanceId; + protected String processDefinitionId; + protected String taskElementName; + // optional + protected String jobKey; + protected String formKey; + protected String assignee; + protected List candidateGroups; + protected List candidateUsers; + protected String dueDate; + protected String followUpDate; + protected int priority; + protected Map variables; + +} diff --git a/custom-tasklist-exporter-based/model/src/test/java/com/camunda/consulting/AppTest.java b/custom-tasklist-exporter-based/model/src/test/java/com/camunda/consulting/AppTest.java new file mode 100644 index 00000000..94df01c5 --- /dev/null +++ b/custom-tasklist-exporter-based/model/src/test/java/com/camunda/consulting/AppTest.java @@ -0,0 +1,35 @@ +package com.camunda.consulting; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +/** + * Unit test for simple App. + */ +public class AppTest + extends TestCase { + + /** + * Create the test case + * + * @param testName name of the test case + */ + public AppTest(String testName) { + super(testName); + } + + /** + * @return the suite of tests being tested + */ + public static Test suite() { + return new TestSuite(AppTest.class); + } + + /** + * Rigourous Test :-) + */ + public void testApp() { + assertTrue(true); + } +} diff --git a/custom-tasklist-exporter-based/pom.xml b/custom-tasklist-exporter-based/pom.xml new file mode 100644 index 00000000..37a561b5 --- /dev/null +++ b/custom-tasklist-exporter-based/pom.xml @@ -0,0 +1,128 @@ + + + + 4.0.0 + com.camunda.consulting + tasklist-parent + 1.0-SNAPSHOT + + pom + tasklist-parent + + + UTF-8 + 11 + 11 + 2.8.1 + + 7.17.0 + + 8.1.2 + + + + + junit + junit + 3.8.1 + test + + + + org.projectlombok + lombok + 1.18.24 + provided + + + + + + + + + com.camunda.consulting + model + ${project.version} + + + + + org.projectlombok + lombok + 1.18.24 + compile + + + + + org.springframework.kafka + spring-kafka + ${springboot.version} + + + + org.apache.kafka + connect-json + 3.2.1 + + + + io.camunda + zeebe-exporter-api + ${c8.version} + + + + io.camunda + zeebe-client-java + ${c8.version} + + + + org.springframework.boot + spring-boot-dependencies + 2.7.3 + pom + import + + + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0-M5 + + + org.apache.maven.plugins + maven-shade-plugin + 3.4.0 + + + package + + shade + + + + + + + + + + c7-exporter + c8-exporter + c8-jobworker + tasklist + model + + + diff --git a/custom-tasklist-exporter-based/tasklist/Dockerfile b/custom-tasklist-exporter-based/tasklist/Dockerfile new file mode 100644 index 00000000..60979d0a --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/Dockerfile @@ -0,0 +1,4 @@ +FROM openjdk:17-oracle +ARG JAR_FILE=target/tasklist-1.0-SNAPSHOT.jar +COPY ${JAR_FILE} app.jar +ENTRYPOINT ["java","-jar","/app.jar"] \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/.gitignore b/custom-tasklist-exporter-based/tasklist/client/.gitignore new file mode 100644 index 00000000..4d29575d --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/.gitignore @@ -0,0 +1,23 @@ +# See https://help.github.com/articles/ignoring-files/ for more about ignoring files. + +# dependencies +/node_modules +/.pnp +.pnp.js + +# testing +/coverage + +# production +/build + +# misc +.DS_Store +.env.local +.env.development.local +.env.test.local +.env.production.local + +npm-debug.log* +yarn-debug.log* +yarn-error.log* diff --git a/custom-tasklist-exporter-based/tasklist/client/README.md b/custom-tasklist-exporter-based/tasklist/client/README.md new file mode 100644 index 00000000..58beeacc --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/README.md @@ -0,0 +1,70 @@ +# Getting Started with Create React App + +This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app). + +## Available Scripts + +In the project directory, you can run: + +### `npm start` + +Runs the app in the development mode.\ +Open [http://localhost:3000](http://localhost:3000) to view it in your browser. + +The page will reload when you make changes.\ +You may also see any lint errors in the console. + +### `npm test` + +Launches the test runner in the interactive watch mode.\ +See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information. + +### `npm run build` + +Builds the app for production to the `build` folder.\ +It correctly bundles React in production mode and optimizes the build for the best performance. + +The build is minified and the filenames include the hashes.\ +Your app is ready to be deployed! + +See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information. + +### `npm run eject` + +**Note: this is a one-way operation. Once you `eject`, you can't go back!** + +If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project. + +Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own. + +You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it. + +## Learn More + +You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started). + +To learn React, check out the [React documentation](https://reactjs.org/). + +### Code Splitting + +This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting) + +### Analyzing the Bundle Size + +This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size) + +### Making a Progressive Web App + +This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app) + +### Advanced Configuration + +This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration) + +### Deployment + +This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment) + +### `npm run build` fails to minify + +This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify) diff --git a/custom-tasklist-exporter-based/tasklist/client/package-lock.json b/custom-tasklist-exporter-based/tasklist/client/package-lock.json new file mode 100644 index 00000000..f3db1f4a --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/package-lock.json @@ -0,0 +1,17928 @@ +{ + "name": "tasklist", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "tasklist", + "version": "0.1.0", + "dependencies": { + "@apollo/client": "^3.7.4", + "@bpmn-io/form-js": "^0.10.1", + "@bpmn-io/form-js-viewer": "^0.10.1", + "@testing-library/jest-dom": "^5.16.5", + "@testing-library/react": "^13.4.0", + "@testing-library/user-event": "^13.5.0", + "bootstrap": "^5.2.3", + "bootstrap-icons": "^1.10.3", + "bpmn-js": "^11.1.0", + "graphql": "^16.6.0", + "react": "^18.2.0", + "react-bpmn": "^0.2.0", + "react-dom": "^18.2.0", + "react-icons": "^4.7.1", + "react-scripts": "5.0.1", + "web-vitals": "^2.1.4" + } + }, + "node_modules/@adobe/css-tools": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.0.1.tgz", + "integrity": "sha512-+u76oB43nOHrF4DDWRLWDCtci7f3QJoEBigemIdIeTi1ODqjx6Tad9NCVnPRwewWlKkVab5PlK8DCtPTyX7S8g==" + }, + "node_modules/@ampproject/remapping": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.0.tgz", + "integrity": "sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==", + "dependencies": { + "@jridgewell/gen-mapping": "^0.1.0", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@apollo/client": { + "version": "3.7.4", + "resolved": "https://registry.npmjs.org/@apollo/client/-/client-3.7.4.tgz", + "integrity": "sha512-bgiCKRmLSBImX4JRrw8NjqGo0AQE/mowCdHX1PJp2r5zIXrJx0UeaAYmx1qJY69Oz/KR7SKlLt4xK+bOP1jx7A==", + "dependencies": { + "@graphql-typed-document-node/core": "^3.1.1", + "@wry/context": "^0.7.0", + "@wry/equality": "^0.5.0", + "@wry/trie": "^0.3.0", + "graphql-tag": "^2.12.6", + "hoist-non-react-statics": "^3.3.2", + "optimism": "^0.16.1", + "prop-types": "^15.7.2", + "response-iterator": "^0.2.6", + "symbol-observable": "^4.0.0", + "ts-invariant": "^0.10.3", + "tslib": "^2.3.0", + "zen-observable-ts": "^1.2.5" + }, + "peerDependencies": { + "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0", + "graphql-ws": "^5.5.5", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0", + "subscriptions-transport-ws": "^0.9.0 || ^0.11.0" + }, + "peerDependenciesMeta": { + "graphql-ws": { + "optional": true + }, + "react": { + "optional": true + }, + "react-dom": { + "optional": true + }, + "subscriptions-transport-ws": { + "optional": true + } + } + }, + "node_modules/@babel/code-frame": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", + "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", + "dependencies": { + "@babel/highlight": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.20.10", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.20.10.tgz", + "integrity": "sha512-sEnuDPpOJR/fcafHMjpcpGN5M2jbUGUHwmuWKM/YdPzeEDJg8bgmbcWQFUfE32MQjti1koACvoPVsDe8Uq+idg==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.20.7.tgz", + "integrity": "sha512-t1ZjCluspe5DW24bn2Rr1CDb2v9rn/hROtg9a2tmd0+QYf4bsloYfLQzjG4qHPNMhWtKdGC33R5AxGR2Af2cBw==", + "dependencies": { + "@ampproject/remapping": "^2.1.0", + "@babel/code-frame": "^7.18.6", + "@babel/generator": "^7.20.7", + "@babel/helper-compilation-targets": "^7.20.7", + "@babel/helper-module-transforms": "^7.20.7", + "@babel/helpers": "^7.20.7", + "@babel/parser": "^7.20.7", + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.20.7", + "@babel/types": "^7.20.7", + "convert-source-map": "^1.7.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.1", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/core/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/eslint-parser": { + "version": "7.19.1", + "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-7.19.1.tgz", + "integrity": "sha512-AqNf2QWt1rtu2/1rLswy6CDP7H9Oh3mMhk177Y67Rg8d7RD9WfOLLv8CGn6tisFvS2htm86yIe1yLF6I1UDaGQ==", + "dependencies": { + "@nicolo-ribaudo/eslint-scope-5-internals": "5.1.1-v1", + "eslint-visitor-keys": "^2.1.0", + "semver": "^6.3.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || >=14.0.0" + }, + "peerDependencies": { + "@babel/core": ">=7.11.0", + "eslint": "^7.5.0 || ^8.0.0" + } + }, + "node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz", + "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==", + "engines": { + "node": ">=10" + } + }, + "node_modules/@babel/eslint-parser/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/generator": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.20.7.tgz", + "integrity": "sha512-7wqMOJq8doJMZmP4ApXTzLxSr7+oO2jroJURrVEp6XShrQUObV8Tq/D0NCcoYg2uHqUrjzO0zwBjoYzelxK+sw==", + "dependencies": { + "@babel/types": "^7.20.7", + "@jridgewell/gen-mapping": "^0.3.2", + "jsesc": "^2.5.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/generator/node_modules/@jridgewell/gen-mapping": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz", + "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==", + "dependencies": { + "@jridgewell/set-array": "^1.0.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/helper-annotate-as-pure": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.18.6.tgz", + "integrity": "sha512-duORpUiYrEpzKIop6iNbjnwKLAKnJ47csTyRACyEmWj0QdUrm5aqNJGHSSEQSUAvNW0ojX0dOmK9dZduvkfeXA==", + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-builder-binary-assignment-operator-visitor": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.18.9.tgz", + "integrity": "sha512-yFQ0YCHoIqarl8BCRwBL8ulYUaZpz3bNsA7oFepAzee+8/+ImtADXNOmO5vJvsPff3qi+hvpkY/NYBTrBQgdNw==", + "dependencies": { + "@babel/helper-explode-assignable-expression": "^7.18.6", + "@babel/types": "^7.18.9" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.7.tgz", + "integrity": "sha512-4tGORmfQcrc+bvrjb5y3dG9Mx1IOZjsHqQVUz7XCNHO+iTmqxWnVg3KRygjGmpRLJGdQSKuvFinbIb0CnZwHAQ==", + "dependencies": { + "@babel/compat-data": "^7.20.5", + "@babel/helper-validator-option": "^7.18.6", + "browserslist": "^4.21.3", + "lru-cache": "^5.1.1", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-create-class-features-plugin": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.20.7.tgz", + "integrity": "sha512-LtoWbDXOaidEf50hmdDqn9g8VEzsorMexoWMQdQODbvmqYmaF23pBP5VNPAGIFHsFQCIeKokDiz3CH5Y2jlY6w==", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.18.6", + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-function-name": "^7.19.0", + "@babel/helper-member-expression-to-functions": "^7.20.7", + "@babel/helper-optimise-call-expression": "^7.18.6", + "@babel/helper-replace-supers": "^7.20.7", + "@babel/helper-split-export-declaration": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-create-regexp-features-plugin": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.20.5.tgz", + "integrity": "sha512-m68B1lkg3XDGX5yCvGO0kPx3v9WIYLnzjKfPcQiwntEQa5ZeRkPmo2X/ISJc8qxWGfwUr+kvZAeEzAwLec2r2w==", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.18.6", + "regexpu-core": "^5.2.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-define-polyfill-provider": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.3.3.tgz", + "integrity": "sha512-z5aQKU4IzbqCC1XH0nAqfsFLMVSo22SBKUc0BxGrLkolTdPTructy0ToNnlO2zA4j9Q/7pjMZf0DSY+DSTYzww==", + "dependencies": { + "@babel/helper-compilation-targets": "^7.17.7", + "@babel/helper-plugin-utils": "^7.16.7", + "debug": "^4.1.1", + "lodash.debounce": "^4.0.8", + "resolve": "^1.14.2", + "semver": "^6.1.2" + }, + "peerDependencies": { + "@babel/core": "^7.4.0-0" + } + }, + "node_modules/@babel/helper-define-polyfill-provider/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-environment-visitor": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz", + "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-explode-assignable-expression": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.18.6.tgz", + "integrity": "sha512-eyAYAsQmB80jNfg4baAtLeWAQHfHFiR483rzFK+BhETlGZaQC9bsfrugfXDCbRHLQbIA7U5NxhhOxN7p/dWIcg==", + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-function-name": { + "version": "7.19.0", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.19.0.tgz", + "integrity": "sha512-WAwHBINyrpqywkUH0nTnNgI5ina5TFn85HKS0pbPDfxFfhyR/aNQEn4hGi1P1JyT//I0t4OgXUlofzWILRvS5w==", + "dependencies": { + "@babel/template": "^7.18.10", + "@babel/types": "^7.19.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-hoist-variables": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz", + "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==", + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-member-expression-to-functions": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.20.7.tgz", + "integrity": "sha512-9J0CxJLq315fEdi4s7xK5TQaNYjZw+nDVpVqr1axNGKzdrdwYBD5b4uKv3n75aABG0rCCTK8Im8Ww7eYfMrZgw==", + "dependencies": { + "@babel/types": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", + "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.20.11", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.20.11.tgz", + "integrity": "sha512-uRy78kN4psmji1s2QtbtcCSaj/LILFDp0f/ymhpQH5QY3nljUZCaNWz9X1dEj/8MBdBEFECs7yRhKn8i7NjZgg==", + "dependencies": { + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-module-imports": "^7.18.6", + "@babel/helper-simple-access": "^7.20.2", + "@babel/helper-split-export-declaration": "^7.18.6", + "@babel/helper-validator-identifier": "^7.19.1", + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.20.10", + "@babel/types": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-optimise-call-expression": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.18.6.tgz", + "integrity": "sha512-HP59oD9/fEHQkdcbgFCnbmgH5vIQTJbxh2yf+CdM89/glUNnuzr87Q8GIjGEnOktTROemO0Pe0iPAYbqZuOUiA==", + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.20.2.tgz", + "integrity": "sha512-8RvlJG2mj4huQ4pZ+rU9lqKi9ZKiRmuvGuM2HlWmkmgOhbs6zEAw6IEiJ5cQqGbDzGZOhwuOQNtZMi/ENLjZoQ==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-remap-async-to-generator": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.18.9.tgz", + "integrity": "sha512-dI7q50YKd8BAv3VEfgg7PS7yD3Rtbi2J1XMXaalXO0W0164hYLnh8zpjRS0mte9MfVp/tltvr/cfdXPvJr1opA==", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.18.6", + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-wrap-function": "^7.18.9", + "@babel/types": "^7.18.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-replace-supers": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.20.7.tgz", + "integrity": "sha512-vujDMtB6LVfNW13jhlCrp48QNslK6JXi7lQG736HVbHz/mbf4Dc7tIRh1Xf5C0rF7BP8iiSxGMCmY6Ci1ven3A==", + "dependencies": { + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-member-expression-to-functions": "^7.20.7", + "@babel/helper-optimise-call-expression": "^7.18.6", + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.20.7", + "@babel/types": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-simple-access": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz", + "integrity": "sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA==", + "dependencies": { + "@babel/types": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-skip-transparent-expression-wrappers": { + "version": "7.20.0", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.20.0.tgz", + "integrity": "sha512-5y1JYeNKfvnT8sZcK9DVRtpTbGiomYIHviSP3OQWmDPU3DeH4a1ZlT/N2lyQ5P8egjcRaT/Y9aNqUxK0WsnIIg==", + "dependencies": { + "@babel/types": "^7.20.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-split-export-declaration": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz", + "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==", + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.19.4", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.19.4.tgz", + "integrity": "sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.19.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz", + "integrity": "sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.18.6.tgz", + "integrity": "sha512-XO7gESt5ouv/LRJdrVjkShckw6STTaB7l9BrpBaAHDeF5YZT+01PCwmR0SJHnkW6i8OwW/EVWRShfi4j2x+KQw==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-wrap-function": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.20.5.tgz", + "integrity": "sha512-bYMxIWK5mh+TgXGVqAtnu5Yn1un+v8DDZtqyzKRLUzrh70Eal2O3aZ7aPYiMADO4uKlkzOiRiZ6GX5q3qxvW9Q==", + "dependencies": { + "@babel/helper-function-name": "^7.19.0", + "@babel/template": "^7.18.10", + "@babel/traverse": "^7.20.5", + "@babel/types": "^7.20.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.20.7.tgz", + "integrity": "sha512-PBPjs5BppzsGaxHQCDKnZ6Gd9s6xl8bBCluz3vEInLGRJmnZan4F6BYCeqtyXqkk4W5IlPmjK4JlOuZkpJ3xZA==", + "dependencies": { + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.20.7", + "@babel/types": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", + "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", + "dependencies": { + "@babel/helper-validator-identifier": "^7.18.6", + "chalk": "^2.0.0", + "js-tokens": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.20.7.tgz", + "integrity": "sha512-T3Z9oHybU+0vZlY9CiDSJQTD5ZapcW18ZctFMi0MOAl/4BjFF4ul7NVSARLdbGO5vDqy9eQiGTV0LtKfvCYvcg==", + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.18.6.tgz", + "integrity": "sha512-Dgxsyg54Fx1d4Nge8UnvTrED63vrwOdPmyvPzlNN/boaliRP54pm3pGzZD1SJUwrBA+Cs/xdG8kXX6Mn/RfISQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.20.7.tgz", + "integrity": "sha512-sbr9+wNE5aXMBBFBICk01tt7sBf2Oc9ikRFEcem/ZORup9IMUdNhW7/wVLEbbtlWOsEubJet46mHAL2C8+2jKQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-skip-transparent-expression-wrappers": "^7.20.0", + "@babel/plugin-proposal-optional-chaining": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.13.0" + } + }, + "node_modules/@babel/plugin-proposal-async-generator-functions": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.20.7.tgz", + "integrity": "sha512-xMbiLsn/8RK7Wq7VeVytytS2L6qE69bXPB10YCmMdDZbKF4okCqY74pI/jJQ/8U0b/F6NrT2+14b8/P9/3AMGA==", + "dependencies": { + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-remap-async-to-generator": "^7.18.9", + "@babel/plugin-syntax-async-generators": "^7.8.4" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-class-properties": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.18.6.tgz", + "integrity": "sha512-cumfXOF0+nzZrrN8Rf0t7M+tF6sZc7vhQwYQck9q1/5w2OExlD+b4v4RpMJFaV1Z7WcDRgO6FqvxqxGlwo+RHQ==", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-class-static-block": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.20.7.tgz", + "integrity": "sha512-AveGOoi9DAjUYYuUAG//Ig69GlazLnoyzMw68VCDux+c1tsnnH/OkYcpz/5xzMkEFC6UxjR5Gw1c+iY2wOGVeQ==", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.20.7", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/plugin-syntax-class-static-block": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.12.0" + } + }, + "node_modules/@babel/plugin-proposal-decorators": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-decorators/-/plugin-proposal-decorators-7.20.7.tgz", + "integrity": "sha512-JB45hbUweYpwAGjkiM7uCyXMENH2lG+9r3G2E+ttc2PRXAoEkpfd/KW5jDg4j8RS6tLtTG1jZi9LbHZVSfs1/A==", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.20.7", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-replace-supers": "^7.20.7", + "@babel/helper-split-export-declaration": "^7.18.6", + "@babel/plugin-syntax-decorators": "^7.19.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-dynamic-import": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.18.6.tgz", + "integrity": "sha512-1auuwmK+Rz13SJj36R+jqFPMJWyKEDd7lLSdOj4oJK0UTgGueSAtkrCvz9ewmgyU/P941Rv2fQwZJN8s6QruXw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/plugin-syntax-dynamic-import": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-export-namespace-from": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.18.9.tgz", + "integrity": "sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.9", + "@babel/plugin-syntax-export-namespace-from": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-json-strings": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.18.6.tgz", + "integrity": "sha512-lr1peyn9kOdbYc0xr0OdHTZ5FMqS6Di+H0Fz2I/JwMzGmzJETNeOFq2pBySw6X/KFL5EWDjlJuMsUGRFb8fQgQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/plugin-syntax-json-strings": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-logical-assignment-operators": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.20.7.tgz", + "integrity": "sha512-y7C7cZgpMIjWlKE5T7eJwp+tnRYM89HmRvWM5EQuB5BoHEONjmQ8lSNmBUwOyy/GFRsohJED51YBF79hE1djug==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-nullish-coalescing-operator": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.18.6.tgz", + "integrity": "sha512-wQxQzxYeJqHcfppzBDnm1yAY0jSRkUXR2z8RePZYrKwMKgMlE8+Z6LUno+bd6LvbGh8Gltvy74+9pIYkr+XkKA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-numeric-separator": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.18.6.tgz", + "integrity": "sha512-ozlZFogPqoLm8WBr5Z8UckIoE4YQ5KESVcNudyXOR8uqIkliTEgJ3RoketfG6pmzLdeZF0H/wjE9/cCEitBl7Q==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/plugin-syntax-numeric-separator": "^7.10.4" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-object-rest-spread": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.20.7.tgz", + "integrity": "sha512-d2S98yCiLxDVmBmE8UjGcfPvNEUbA1U5q5WxaWFUGRzJSVAZqm5W6MbPct0jxnegUZ0niLeNX+IOzEs7wYg9Dg==", + "dependencies": { + "@babel/compat-data": "^7.20.5", + "@babel/helper-compilation-targets": "^7.20.7", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-transform-parameters": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-optional-catch-binding": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.18.6.tgz", + "integrity": "sha512-Q40HEhs9DJQyaZfUjjn6vE8Cv4GmMHCYuMGIWUnlxH6400VGxOuwWsPt4FxXxJkC/5eOzgn0z21M9gMT4MOhbw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-optional-chaining": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.20.7.tgz", + "integrity": "sha512-T+A7b1kfjtRM51ssoOfS1+wbyCVqorfyZhT99TvxxLMirPShD8CzKMRepMlCBGM5RpHMbn8s+5MMHnPstJH6mQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-skip-transparent-expression-wrappers": "^7.20.0", + "@babel/plugin-syntax-optional-chaining": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-private-methods": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.18.6.tgz", + "integrity": "sha512-nutsvktDItsNn4rpGItSNV2sz1XwS+nfU0Rg8aCx3W3NOKVzdMjJRu0O5OkgDp3ZGICSTbgRpxZoWsxoKRvbeA==", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-private-property-in-object": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.20.5.tgz", + "integrity": "sha512-Vq7b9dUA12ByzB4EjQTPo25sFhY+08pQDBSZRtUAkj7lb7jahaHR5igera16QZ+3my1nYR4dKsNdYj5IjPHilQ==", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.18.6", + "@babel/helper-create-class-features-plugin": "^7.20.5", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-unicode-property-regex": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.18.6.tgz", + "integrity": "sha512-2BShG/d5yoZyXZfVePH91urL5wTG6ASZU9M4o03lKK8u8UW1y08OMttBSOADTcJrnPMpvDXRG3G8fyLh4ovs8w==", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", + "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-bigint": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz", + "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-class-properties": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", + "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.12.13" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-class-static-block": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz", + "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-decorators": { + "version": "7.19.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-decorators/-/plugin-syntax-decorators-7.19.0.tgz", + "integrity": "sha512-xaBZUEDntt4faL1yN8oIFlhfXeQAWJW7CLKYsHTUqriCUbj8xOra8bfxxKGi/UwExPFBuPdH4XfHc9rGQhrVkQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.19.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-dynamic-import": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz", + "integrity": "sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-export-namespace-from": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz", + "integrity": "sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.3" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-flow": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.18.6.tgz", + "integrity": "sha512-LUbR+KNTBWCUAqRG9ex5Gnzu2IOkt8jRJbHHXFT9q+L9zm7M/QQbEqXyw1n1pohYvOyWC8CjeyjrSaIwiYjK7A==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-assertions": { + "version": "7.20.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.20.0.tgz", + "integrity": "sha512-IUh1vakzNoWalR8ch/areW7qFopR2AEw03JlG7BbrDqmQ4X3q9uuipQwSGrUn7oGiemKjtSLDhNtQHzMHr1JdQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.19.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-jsx": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.18.6.tgz", + "integrity": "sha512-6mmljtAedFGTWu2p/8WIORGwy+61PLgOMPOdazc7YoJ9ZCWUyFy3A6CpPkRKLKD1ToAesxX8KGEViAiLo9N+7Q==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", + "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", + "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", + "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-object-rest-spread": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", + "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-catch-binding": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", + "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-chaining": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-private-property-in-object": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz", + "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-top-level-await": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-typescript": { + "version": "7.20.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.20.0.tgz", + "integrity": "sha512-rd9TkG+u1CExzS4SM1BlMEhMXwFLKVjOAFFCDx9PbX5ycJWDoWMcwdJH9RhkPu1dOgn5TrxLot/Gx6lWFuAUNQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.19.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-arrow-functions": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.20.7.tgz", + "integrity": "sha512-3poA5E7dzDomxj9WXWwuD6A5F3kc7VXwIJO+E+J8qtDtS+pXPAhrgEyh+9GBwBgPq1Z+bB+/JD60lp5jsN7JPQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-async-to-generator": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.20.7.tgz", + "integrity": "sha512-Uo5gwHPT9vgnSXQxqGtpdufUiWp96gk7yiP4Mp5bm1QMkEmLXBO7PAGYbKoJ6DhAwiNkcHFBol/x5zZZkL/t0Q==", + "dependencies": { + "@babel/helper-module-imports": "^7.18.6", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-remap-async-to-generator": "^7.18.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-block-scoped-functions": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.18.6.tgz", + "integrity": "sha512-ExUcOqpPWnliRcPqves5HJcJOvHvIIWfuS4sroBUenPuMdmW+SMHDakmtS7qOo13sVppmUijqeTv7qqGsvURpQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-block-scoping": { + "version": "7.20.11", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.20.11.tgz", + "integrity": "sha512-tA4N427a7fjf1P0/2I4ScsHGc5jcHPbb30xMbaTke2gxDuWpUfXDuX1FEymJwKk4tuGUvGcejAR6HdZVqmmPyw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-classes": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.20.7.tgz", + "integrity": "sha512-LWYbsiXTPKl+oBlXUGlwNlJZetXD5Am+CyBdqhPsDVjM9Jc8jwBJFrKhHf900Kfk2eZG1y9MAG3UNajol7A4VQ==", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.18.6", + "@babel/helper-compilation-targets": "^7.20.7", + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-function-name": "^7.19.0", + "@babel/helper-optimise-call-expression": "^7.18.6", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-replace-supers": "^7.20.7", + "@babel/helper-split-export-declaration": "^7.18.6", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-computed-properties": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.20.7.tgz", + "integrity": "sha512-Lz7MvBK6DTjElHAmfu6bfANzKcxpyNPeYBGEafyA6E5HtRpjpZwU+u7Qrgz/2OR0z+5TvKYbPdphfSaAcZBrYQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/template": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-destructuring": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.20.7.tgz", + "integrity": "sha512-Xwg403sRrZb81IVB79ZPqNQME23yhugYVqgTxAhT99h485F4f+GMELFhhOsscDUB7HCswepKeCKLn/GZvUKoBA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-dotall-regex": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.18.6.tgz", + "integrity": "sha512-6S3jpun1eEbAxq7TdjLotAsl4WpQI9DxfkycRcKrjhQYzU87qpXdknpBg/e+TdcMehqGnLFi7tnFUBR02Vq6wg==", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-duplicate-keys": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.18.9.tgz", + "integrity": "sha512-d2bmXCtZXYc59/0SanQKbiWINadaJXqtvIQIzd4+hNwkWBgyCd5F/2t1kXoUdvPMrxzPvhK6EMQRROxsue+mfw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-exponentiation-operator": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.18.6.tgz", + "integrity": "sha512-wzEtc0+2c88FVR34aQmiz56dxEkxr2g8DQb/KfaFa1JYXOFVsbhvAonFN6PwVWj++fKmku8NP80plJ5Et4wqHw==", + "dependencies": { + "@babel/helper-builder-binary-assignment-operator-visitor": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-flow-strip-types": { + "version": "7.19.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.19.0.tgz", + "integrity": "sha512-sgeMlNaQVbCSpgLSKP4ZZKfsJVnFnNQlUSk6gPYzR/q7tzCgQF2t8RBKAP6cKJeZdveei7Q7Jm527xepI8lNLg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.19.0", + "@babel/plugin-syntax-flow": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-for-of": { + "version": "7.18.8", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.18.8.tgz", + "integrity": "sha512-yEfTRnjuskWYo0k1mHUqrVWaZwrdq8AYbfrpqULOJOaucGSp4mNMVps+YtA8byoevxS/urwU75vyhQIxcCgiBQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-function-name": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.18.9.tgz", + "integrity": "sha512-WvIBoRPaJQ5yVHzcnJFor7oS5Ls0PYixlTYE63lCj2RtdQEl15M68FXQlxnG6wdraJIXRdR7KI+hQ7q/9QjrCQ==", + "dependencies": { + "@babel/helper-compilation-targets": "^7.18.9", + "@babel/helper-function-name": "^7.18.9", + "@babel/helper-plugin-utils": "^7.18.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-literals": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.18.9.tgz", + "integrity": "sha512-IFQDSRoTPnrAIrI5zoZv73IFeZu2dhu6irxQjY9rNjTT53VmKg9fenjvoiOWOkJ6mm4jKVPtdMzBY98Fp4Z4cg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-member-expression-literals": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.18.6.tgz", + "integrity": "sha512-qSF1ihLGO3q+/g48k85tUjD033C29TNTVB2paCwZPVmOsjn9pClvYYrM2VeJpBY2bcNkuny0YUyTNRyRxJ54KA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-amd": { + "version": "7.20.11", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.20.11.tgz", + "integrity": "sha512-NuzCt5IIYOW0O30UvqktzHYR2ud5bOWbY0yaxWZ6G+aFzOMJvrs5YHNikrbdaT15+KNO31nPOy5Fim3ku6Zb5g==", + "dependencies": { + "@babel/helper-module-transforms": "^7.20.11", + "@babel/helper-plugin-utils": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-commonjs": { + "version": "7.20.11", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.20.11.tgz", + "integrity": "sha512-S8e1f7WQ7cimJQ51JkAaDrEtohVEitXjgCGAS2N8S31Y42E+kWwfSz83LYz57QdBm7q9diARVqanIaH2oVgQnw==", + "dependencies": { + "@babel/helper-module-transforms": "^7.20.11", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-simple-access": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-systemjs": { + "version": "7.20.11", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.20.11.tgz", + "integrity": "sha512-vVu5g9BPQKSFEmvt2TA4Da5N+QVS66EX21d8uoOihC+OCpUoGvzVsXeqFdtAEfVa5BILAeFt+U7yVmLbQnAJmw==", + "dependencies": { + "@babel/helper-hoist-variables": "^7.18.6", + "@babel/helper-module-transforms": "^7.20.11", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-validator-identifier": "^7.19.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-umd": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.18.6.tgz", + "integrity": "sha512-dcegErExVeXcRqNtkRU/z8WlBLnvD4MRnHgNs3MytRO1Mn1sHRyhbcpYbVMGclAqOjdW+9cfkdZno9dFdfKLfQ==", + "dependencies": { + "@babel/helper-module-transforms": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.20.5.tgz", + "integrity": "sha512-mOW4tTzi5iTLnw+78iEq3gr8Aoq4WNRGpmSlrogqaiCBoR1HFhpU4JkpQFOHfeYx3ReVIFWOQJS4aZBRvuZ6mA==", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.20.5", + "@babel/helper-plugin-utils": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-new-target": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.18.6.tgz", + "integrity": "sha512-DjwFA/9Iu3Z+vrAn+8pBUGcjhxKguSMlsFqeCKbhb9BAV756v0krzVK04CRDi/4aqmk8BsHb4a/gFcaA5joXRw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-object-super": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.18.6.tgz", + "integrity": "sha512-uvGz6zk+pZoS1aTZrOvrbj6Pp/kK2mp45t2B+bTDre2UgsZZ8EZLSJtUg7m/no0zOJUWgFONpB7Zv9W2tSaFlA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/helper-replace-supers": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-parameters": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.20.7.tgz", + "integrity": "sha512-WiWBIkeHKVOSYPO0pWkxGPfKeWrCJyD3NJ53+Lrp/QMSZbsVPovrVl2aWZ19D/LTVnaDv5Ap7GJ/B2CTOZdrfA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-property-literals": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.18.6.tgz", + "integrity": "sha512-cYcs6qlgafTud3PAzrrRNbQtfpQ8+y/+M5tKmksS9+M1ckbH6kzY8MrexEM9mcA6JDsukE19iIRvAyYl463sMg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-constant-elements": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.20.2.tgz", + "integrity": "sha512-KS/G8YI8uwMGKErLFOHS/ekhqdHhpEloxs43NecQHVgo2QuQSyJhGIY1fL8UGl9wy5ItVwwoUL4YxVqsplGq2g==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-display-name": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.18.6.tgz", + "integrity": "sha512-TV4sQ+T013n61uMoygyMRm+xf04Bd5oqFpv2jAEQwSZ8NwQA7zeRPg1LMVg2PWi3zWBz+CLKD+v5bcpZ/BS0aA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.20.7.tgz", + "integrity": "sha512-Tfq7qqD+tRj3EoDhY00nn2uP2hsRxgYGi5mLQ5TimKav0a9Lrpd4deE+fcLXU8zFYRjlKPHZhpCvfEA6qnBxqQ==", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.18.6", + "@babel/helper-module-imports": "^7.18.6", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/plugin-syntax-jsx": "^7.18.6", + "@babel/types": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-development": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.18.6.tgz", + "integrity": "sha512-SA6HEjwYFKF7WDjWcMcMGUimmw/nhNRDWxr+KaLSCrkD/LMDBvWRmHAYgE1HDeF8KUuI8OAu+RT6EOtKxSW2qA==", + "dependencies": { + "@babel/plugin-transform-react-jsx": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-pure-annotations": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.18.6.tgz", + "integrity": "sha512-I8VfEPg9r2TRDdvnHgPepTKvuRomzA8+u+nhY7qSI1fR2hRNebasZEETLyM5mAUr0Ku56OkXJ0I7NHJnO6cJiQ==", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-regenerator": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.20.5.tgz", + "integrity": "sha512-kW/oO7HPBtntbsahzQ0qSE3tFvkFwnbozz3NWFhLGqH75vLEg+sCGngLlhVkePlCs3Jv0dBBHDzCHxNiFAQKCQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2", + "regenerator-transform": "^0.15.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-reserved-words": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.18.6.tgz", + "integrity": "sha512-oX/4MyMoypzHjFrT1CdivfKZ+XvIPMFXwwxHp/r0Ddy2Vuomt4HDFGmft1TAY2yiTKiNSsh3kjBAzcM8kSdsjA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-runtime": { + "version": "7.19.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.19.6.tgz", + "integrity": "sha512-PRH37lz4JU156lYFW1p8OxE5i7d6Sl/zV58ooyr+q1J1lnQPyg5tIiXlIwNVhJaY4W3TmOtdc8jqdXQcB1v5Yw==", + "dependencies": { + "@babel/helper-module-imports": "^7.18.6", + "@babel/helper-plugin-utils": "^7.19.0", + "babel-plugin-polyfill-corejs2": "^0.3.3", + "babel-plugin-polyfill-corejs3": "^0.6.0", + "babel-plugin-polyfill-regenerator": "^0.4.1", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-runtime/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/plugin-transform-shorthand-properties": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.18.6.tgz", + "integrity": "sha512-eCLXXJqv8okzg86ywZJbRn19YJHU4XUa55oz2wbHhaQVn/MM+XhukiT7SYqp/7o00dg52Rj51Ny+Ecw4oyoygw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-spread": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.20.7.tgz", + "integrity": "sha512-ewBbHQ+1U/VnH1fxltbJqDeWBU1oNLG8Dj11uIv3xVf7nrQu0bPGe5Rf716r7K5Qz+SqtAOVswoVunoiBtGhxw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-skip-transparent-expression-wrappers": "^7.20.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-sticky-regex": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.18.6.tgz", + "integrity": "sha512-kfiDrDQ+PBsQDO85yj1icueWMfGfJFKN1KCkndygtu/C9+XUfydLC8Iv5UYJqRwy4zk8EcplRxEOeLyjq1gm6Q==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-template-literals": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.18.9.tgz", + "integrity": "sha512-S8cOWfT82gTezpYOiVaGHrCbhlHgKhQt8XH5ES46P2XWmX92yisoZywf5km75wv5sYcXDUCLMmMxOLCtthDgMA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-typeof-symbol": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.18.9.tgz", + "integrity": "sha512-SRfwTtF11G2aemAZWivL7PD+C9z52v9EvMqH9BuYbabyPuKUvSWks3oCg6041pT925L4zVFqaVBeECwsmlguEw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-typescript": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.20.7.tgz", + "integrity": "sha512-m3wVKEvf6SoszD8pu4NZz3PvfKRCMgk6D6d0Qi9hNnlM5M6CFS92EgF4EiHVLKbU0r/r7ty1hg7NPZwE7WRbYw==", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.20.7", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/plugin-syntax-typescript": "^7.20.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-escapes": { + "version": "7.18.10", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.18.10.tgz", + "integrity": "sha512-kKAdAI+YzPgGY/ftStBFXTI1LZFju38rYThnfMykS+IXy8BVx+res7s2fxf1l8I35DV2T97ezo6+SGrXz6B3iQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-regex": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.18.6.tgz", + "integrity": "sha512-gE7A6Lt7YLnNOL3Pb9BNeZvi+d8l7tcRrG4+pwJjK9hD2xX4mEvjlQW60G9EEmfXVYRPv9VRQcyegIVHCql/AA==", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-env": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.20.2.tgz", + "integrity": "sha512-1G0efQEWR1EHkKvKHqbG+IN/QdgwfByUpM5V5QroDzGV2t3S/WXNQd693cHiHTlCFMpr9B6FkPFXDA2lQcKoDg==", + "dependencies": { + "@babel/compat-data": "^7.20.1", + "@babel/helper-compilation-targets": "^7.20.0", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-validator-option": "^7.18.6", + "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.18.6", + "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.18.9", + "@babel/plugin-proposal-async-generator-functions": "^7.20.1", + "@babel/plugin-proposal-class-properties": "^7.18.6", + "@babel/plugin-proposal-class-static-block": "^7.18.6", + "@babel/plugin-proposal-dynamic-import": "^7.18.6", + "@babel/plugin-proposal-export-namespace-from": "^7.18.9", + "@babel/plugin-proposal-json-strings": "^7.18.6", + "@babel/plugin-proposal-logical-assignment-operators": "^7.18.9", + "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6", + "@babel/plugin-proposal-numeric-separator": "^7.18.6", + "@babel/plugin-proposal-object-rest-spread": "^7.20.2", + "@babel/plugin-proposal-optional-catch-binding": "^7.18.6", + "@babel/plugin-proposal-optional-chaining": "^7.18.9", + "@babel/plugin-proposal-private-methods": "^7.18.6", + "@babel/plugin-proposal-private-property-in-object": "^7.18.6", + "@babel/plugin-proposal-unicode-property-regex": "^7.18.6", + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-class-properties": "^7.12.13", + "@babel/plugin-syntax-class-static-block": "^7.14.5", + "@babel/plugin-syntax-dynamic-import": "^7.8.3", + "@babel/plugin-syntax-export-namespace-from": "^7.8.3", + "@babel/plugin-syntax-import-assertions": "^7.20.0", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.10.4", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5", + "@babel/plugin-syntax-top-level-await": "^7.14.5", + "@babel/plugin-transform-arrow-functions": "^7.18.6", + "@babel/plugin-transform-async-to-generator": "^7.18.6", + "@babel/plugin-transform-block-scoped-functions": "^7.18.6", + "@babel/plugin-transform-block-scoping": "^7.20.2", + "@babel/plugin-transform-classes": "^7.20.2", + "@babel/plugin-transform-computed-properties": "^7.18.9", + "@babel/plugin-transform-destructuring": "^7.20.2", + "@babel/plugin-transform-dotall-regex": "^7.18.6", + "@babel/plugin-transform-duplicate-keys": "^7.18.9", + "@babel/plugin-transform-exponentiation-operator": "^7.18.6", + "@babel/plugin-transform-for-of": "^7.18.8", + "@babel/plugin-transform-function-name": "^7.18.9", + "@babel/plugin-transform-literals": "^7.18.9", + "@babel/plugin-transform-member-expression-literals": "^7.18.6", + "@babel/plugin-transform-modules-amd": "^7.19.6", + "@babel/plugin-transform-modules-commonjs": "^7.19.6", + "@babel/plugin-transform-modules-systemjs": "^7.19.6", + "@babel/plugin-transform-modules-umd": "^7.18.6", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.19.1", + "@babel/plugin-transform-new-target": "^7.18.6", + "@babel/plugin-transform-object-super": "^7.18.6", + "@babel/plugin-transform-parameters": "^7.20.1", + "@babel/plugin-transform-property-literals": "^7.18.6", + "@babel/plugin-transform-regenerator": "^7.18.6", + "@babel/plugin-transform-reserved-words": "^7.18.6", + "@babel/plugin-transform-shorthand-properties": "^7.18.6", + "@babel/plugin-transform-spread": "^7.19.0", + "@babel/plugin-transform-sticky-regex": "^7.18.6", + "@babel/plugin-transform-template-literals": "^7.18.9", + "@babel/plugin-transform-typeof-symbol": "^7.18.9", + "@babel/plugin-transform-unicode-escapes": "^7.18.10", + "@babel/plugin-transform-unicode-regex": "^7.18.6", + "@babel/preset-modules": "^0.1.5", + "@babel/types": "^7.20.2", + "babel-plugin-polyfill-corejs2": "^0.3.3", + "babel-plugin-polyfill-corejs3": "^0.6.0", + "babel-plugin-polyfill-regenerator": "^0.4.1", + "core-js-compat": "^3.25.1", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-env/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/preset-modules": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.5.tgz", + "integrity": "sha512-A57th6YRG7oR3cq/yt/Y84MvGgE0eJG2F1JLhKuyG+jFxEgrd/HAMJatiFtmOiZurz+0DkrvbheCLaV5f2JfjA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@babel/plugin-proposal-unicode-property-regex": "^7.4.4", + "@babel/plugin-transform-dotall-regex": "^7.4.4", + "@babel/types": "^7.4.4", + "esutils": "^2.0.2" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-react": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.18.6.tgz", + "integrity": "sha512-zXr6atUmyYdiWRVLOZahakYmOBHtWc2WGCkP8PYTgZi0iJXDY2CN180TdrIW4OGOAdLc7TifzDIvtx6izaRIzg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/helper-validator-option": "^7.18.6", + "@babel/plugin-transform-react-display-name": "^7.18.6", + "@babel/plugin-transform-react-jsx": "^7.18.6", + "@babel/plugin-transform-react-jsx-development": "^7.18.6", + "@babel/plugin-transform-react-pure-annotations": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-typescript": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.18.6.tgz", + "integrity": "sha512-s9ik86kXBAnD760aybBucdpnLsAt0jK1xqJn2juOn9lkOvSHV60os5hxoVJsPzMQxvnUJFAlkont2DvvaYEBtQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/helper-validator-option": "^7.18.6", + "@babel/plugin-transform-typescript": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.20.7.tgz", + "integrity": "sha512-UF0tvkUtxwAgZ5W/KrkHf0Rn0fdnLDU9ScxBrEVNUprE/MzirjK4MJUX1/BVDv00Sv8cljtukVK1aky++X1SjQ==", + "dependencies": { + "regenerator-runtime": "^0.13.11" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/runtime-corejs3": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.20.7.tgz", + "integrity": "sha512-jr9lCZ4RbRQmCR28Q8U8Fu49zvFqLxTY9AMOUz+iyMohMoAgpEcVxY+wJNay99oXOpOcCTODkk70NDN2aaJEeg==", + "dependencies": { + "core-js-pure": "^3.25.1", + "regenerator-runtime": "^0.13.11" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/template": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.20.7.tgz", + "integrity": "sha512-8SegXApWe6VoNw0r9JHpSteLKTpTiLZ4rMlGIm9JQ18KiCtyQiAMEazujAHrUS5flrcqYZa75ukev3P6QmUwUw==", + "dependencies": { + "@babel/code-frame": "^7.18.6", + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.20.10", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.20.10.tgz", + "integrity": "sha512-oSf1juCgymrSez8NI4A2sr4+uB/mFd9MXplYGPEBnfAuWmmyeVcHa6xLPiaRBcXkcb/28bgxmQLTVwFKE1yfsg==", + "dependencies": { + "@babel/code-frame": "^7.18.6", + "@babel/generator": "^7.20.7", + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-function-name": "^7.19.0", + "@babel/helper-hoist-variables": "^7.18.6", + "@babel/helper-split-export-declaration": "^7.18.6", + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "debug": "^4.1.0", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.20.7.tgz", + "integrity": "sha512-69OnhBxSSgK0OzTJai4kyPDiKTIe3j+ctaHdIGVbRahTLAT7L3R9oeXHC2aVSuGYt3cVnoAMDmOCgJ2yaiLMvg==", + "dependencies": { + "@babel/helper-string-parser": "^7.19.4", + "@babel/helper-validator-identifier": "^7.19.1", + "to-fast-properties": "^2.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==" + }, + "node_modules/@bpmn-io/diagram-js-ui": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/@bpmn-io/diagram-js-ui/-/diagram-js-ui-0.2.1.tgz", + "integrity": "sha512-8opVJ0MTc2T6T0/8mVSmnBvdIyYjygSahLZ394A9YprjuCoqnfhxQ4TKZ/M/oN2ynvGt6N2mQv6SOGnRhqUovA==", + "dependencies": { + "htm": "^3.1.1", + "preact": "^10.11.2" + } + }, + "node_modules/@bpmn-io/feel-editor": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/@bpmn-io/feel-editor/-/feel-editor-0.7.0.tgz", + "integrity": "sha512-I2rDQKkOKAZil8DeE4OQcb34DdhG8A3R7k//1ol0VpDiX/d2rhFASWmV5Jt35zpgBFJz42HzGT7DvafrdB78OA==", + "dependencies": { + "@babel/core": "^7.20.2", + "@bpmn-io/feel-lint": "^0.1.1", + "@codemirror/autocomplete": "^6.3.2", + "@codemirror/commands": "^6.1.2", + "@codemirror/language": "^6.3.1", + "@codemirror/lint": "^6.1.0", + "@codemirror/state": "^6.1.4", + "@codemirror/view": "^6.5.1", + "@lezer/highlight": "^1.1.2", + "babel-loader": "^9.1.0", + "babel-plugin-istanbul": "^6.1.1", + "lang-feel": "^0.1.0", + "min-dom": "^4.0.1" + } + }, + "node_modules/@bpmn-io/feel-editor/node_modules/ajv": { + "version": "8.12.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", + "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/@bpmn-io/feel-editor/node_modules/ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/@bpmn-io/feel-editor/node_modules/babel-loader": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/babel-loader/-/babel-loader-9.1.0.tgz", + "integrity": "sha512-Antt61KJPinUMwHwIIz9T5zfMgevnfZkEVWYDWlG888fgdvRRGD0JTuf/fFozQnfT+uq64sk1bmdHDy/mOEWnA==", + "dependencies": { + "find-cache-dir": "^3.3.2", + "schema-utils": "^4.0.0" + }, + "engines": { + "node": ">= 14.15.0" + }, + "peerDependencies": { + "@babel/core": "^7.12.0", + "webpack": ">=5" + } + }, + "node_modules/@bpmn-io/feel-editor/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + }, + "node_modules/@bpmn-io/feel-editor/node_modules/schema-utils": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", + "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", + "dependencies": { + "@types/json-schema": "^7.0.9", + "ajv": "^8.8.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/@bpmn-io/feel-lint": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@bpmn-io/feel-lint/-/feel-lint-0.1.1.tgz", + "integrity": "sha512-MUuBHtKJhvDifnQmPZhvFpr/ps3eT5M7+g792OYOy17lGgSVrW7NlFu1JugWCKueZSFv0loj1Xy6LmEZG2PUQg==", + "dependencies": { + "@codemirror/language": "^6.2.1", + "lezer-feel": "^0.15.0" + } + }, + "node_modules/@bpmn-io/form-js": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/@bpmn-io/form-js/-/form-js-0.10.1.tgz", + "integrity": "sha512-EBhkDB46JDroy49YFvb9WN83BYKrM3Q1TjDXryQ1C7hdBfGjqlOdw0g00SOJzDx0esM1zj8Rs8Pxs7PZUBoiOQ==", + "dependencies": { + "@bpmn-io/form-js-editor": "^0.10.1", + "@bpmn-io/form-js-playground": "^0.10.1", + "@bpmn-io/form-js-viewer": "^0.10.1" + } + }, + "node_modules/@bpmn-io/form-js-editor": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/@bpmn-io/form-js-editor/-/form-js-editor-0.10.1.tgz", + "integrity": "sha512-LyGXlSN1c8zKJeIFL8X48EYBfDdnT+4RigE2o/DvK0Wo3lvnUqhaag2y3vogTeDI1yzdB7agrCuZ9l9iZzIwmA==", + "dependencies": { + "@bpmn-io/form-js-viewer": "^0.10.1", + "@bpmn-io/properties-panel": "^1.0.0", + "array-move": "^3.0.1", + "big.js": "^6.2.1", + "dragula": "^3.7.3", + "ids": "^1.0.0", + "min-dash": "^4.0.0", + "min-dom": "^4.0.0", + "preact": "^10.5.14" + } + }, + "node_modules/@bpmn-io/form-js-editor/node_modules/big.js": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/big.js/-/big.js-6.2.1.tgz", + "integrity": "sha512-bCtHMwL9LeDIozFn+oNhhFoq+yQ3BNdnsLSASUxLciOb1vgvpHsIO1dsENiGMgbb4SkP5TrzWzRiLddn8ahVOQ==", + "engines": { + "node": "*" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/bigjs" + } + }, + "node_modules/@bpmn-io/form-js-playground": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/@bpmn-io/form-js-playground/-/form-js-playground-0.10.1.tgz", + "integrity": "sha512-LdGBQrhAAbDaRg4hcSxgsioJn62vLqko3bRHogc76EmBEp/2kUyFGCl7BA/ZOD8djc3AQP0oJ+HmsI0y+KsEYg==", + "dependencies": { + "@bpmn-io/form-js-editor": "^0.10.1", + "@bpmn-io/form-js-viewer": "^0.10.1", + "@codemirror/lang-json": "^6.0.0", + "@codemirror/lint": "^6.0.0", + "@codemirror/state": "^6.1.1", + "@codemirror/view": "^6.2.0", + "classnames": "^2.3.1", + "codemirror": "^6.0.1", + "downloadjs": "^1.4.7", + "file-drops": "^0.4.0", + "mitt": "^3.0.0", + "preact": "^10.5.14" + } + }, + "node_modules/@bpmn-io/form-js-viewer": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/@bpmn-io/form-js-viewer/-/form-js-viewer-0.10.1.tgz", + "integrity": "sha512-1PO5XVBGRIydCWxVh8hN5CPmEbSTptqzHjtiwgWnpBABSGxiSMyXId3SHuGejvsS0zn/k77Wpf6CW0657MMu9A==", + "dependencies": { + "@bpmn-io/snarkdown": "^2.1.0", + "big.js": "^6.2.1", + "classnames": "^2.3.1", + "didi": "^9.0.0", + "feelin": "^0.41.0", + "flatpickr": "^4.6.13", + "ids": "^1.0.0", + "min-dash": "^4.0.0", + "preact": "^10.5.14", + "preact-markup": "^2.1.1" + } + }, + "node_modules/@bpmn-io/form-js-viewer/node_modules/big.js": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/big.js/-/big.js-6.2.1.tgz", + "integrity": "sha512-bCtHMwL9LeDIozFn+oNhhFoq+yQ3BNdnsLSASUxLciOb1vgvpHsIO1dsENiGMgbb4SkP5TrzWzRiLddn8ahVOQ==", + "engines": { + "node": "*" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/bigjs" + } + }, + "node_modules/@bpmn-io/properties-panel": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@bpmn-io/properties-panel/-/properties-panel-1.1.1.tgz", + "integrity": "sha512-8fkZZrGIBThr3BjiRf6++N/2x4grhXt2Lgci17qXlZDMSgrbztAkJABq9Lanq9gHrBIwpNS9KfZihREPWQVbqQ==", + "dependencies": { + "@bpmn-io/feel-editor": "^0.7.0", + "classnames": "^2.3.1", + "min-dash": "^4.0.0", + "min-dom": "^4.0.3" + } + }, + "node_modules/@bpmn-io/snarkdown": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@bpmn-io/snarkdown/-/snarkdown-2.1.0.tgz", + "integrity": "sha512-OWe9YQx3Vtnopz0trJCJVI3y7k2EfeR4QkKHfRhukcB7yxG4PD1FGaB5LAxc1wxp66V1S3LU4bqUpJdVhQhIww==" + }, + "node_modules/@codemirror/autocomplete": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.4.0.tgz", + "integrity": "sha512-HLF2PnZAm1s4kGs30EiqKMgD7XsYaQ0XJnMR0rofEWQ5t5D60SfqpDIkIh1ze5tiEbyUWm8+VJ6W1/erVvBMIA==", + "dependencies": { + "@codemirror/language": "^6.0.0", + "@codemirror/state": "^6.0.0", + "@codemirror/view": "^6.6.0", + "@lezer/common": "^1.0.0" + }, + "peerDependencies": { + "@codemirror/language": "^6.0.0", + "@codemirror/state": "^6.0.0", + "@codemirror/view": "^6.0.0", + "@lezer/common": "^1.0.0" + } + }, + "node_modules/@codemirror/commands": { + "version": "6.1.3", + "resolved": "https://registry.npmjs.org/@codemirror/commands/-/commands-6.1.3.tgz", + "integrity": "sha512-wUw1+vb34Ultv0Q9m/OVB7yizGXgtoDbkI5f5ErM8bebwLyUYjicdhJTKhTvPTpgkv8dq/BK0lQ3K5pRf2DAJw==", + "dependencies": { + "@codemirror/language": "^6.0.0", + "@codemirror/state": "^6.2.0", + "@codemirror/view": "^6.0.0", + "@lezer/common": "^1.0.0" + } + }, + "node_modules/@codemirror/lang-json": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/@codemirror/lang-json/-/lang-json-6.0.1.tgz", + "integrity": "sha512-+T1flHdgpqDDlJZ2Lkil/rLiRy684WMLc74xUnjJH48GQdfJo/pudlTRreZmKwzP8/tGdKf83wlbAdOCzlJOGQ==", + "dependencies": { + "@codemirror/language": "^6.0.0", + "@lezer/json": "^1.0.0" + } + }, + "node_modules/@codemirror/language": { + "version": "6.3.2", + "resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.3.2.tgz", + "integrity": "sha512-g42uHhOcEMAXjmozGG+rdom5UsbyfMxQFh7AbkeoaNImddL6Xt4cQDL0+JxmG7+as18rUAvZaqzP/TjsciVIrA==", + "dependencies": { + "@codemirror/state": "^6.0.0", + "@codemirror/view": "^6.0.0", + "@lezer/common": "^1.0.0", + "@lezer/highlight": "^1.0.0", + "@lezer/lr": "^1.0.0", + "style-mod": "^4.0.0" + } + }, + "node_modules/@codemirror/lint": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/@codemirror/lint/-/lint-6.1.0.tgz", + "integrity": "sha512-mdvDQrjRmYPvQ3WrzF6Ewaao+NWERYtpthJvoQ3tK3t/44Ynhk8ZGjTSL9jMEv8CgSMogmt75X8ceOZRDSXHtQ==", + "dependencies": { + "@codemirror/state": "^6.0.0", + "@codemirror/view": "^6.0.0", + "crelt": "^1.0.5" + } + }, + "node_modules/@codemirror/search": { + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/@codemirror/search/-/search-6.2.3.tgz", + "integrity": "sha512-V9n9233lopQhB1dyjsBK2Wc1i+8hcCqxl1wQ46c5HWWLePoe4FluV3TGHoZ04rBRlGjNyz9DTmpJErig8UE4jw==", + "dependencies": { + "@codemirror/state": "^6.0.0", + "@codemirror/view": "^6.0.0", + "crelt": "^1.0.5" + } + }, + "node_modules/@codemirror/state": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.2.0.tgz", + "integrity": "sha512-69QXtcrsc3RYtOtd+GsvczJ319udtBf1PTrr2KbLWM/e2CXUPnh0Nz9AUo8WfhSQ7GeL8dPVNUmhQVgpmuaNGA==" + }, + "node_modules/@codemirror/view": { + "version": "6.7.2", + "resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.7.2.tgz", + "integrity": "sha512-HeK2GyycxceaQVyvYVYXmn1vUKYYBsHCcfGRSsFO+3fRRtwXx2STK0YiFBmiWx2vtU9gUAJgIUXUN8a0osI8Ng==", + "dependencies": { + "@codemirror/state": "^6.1.4", + "style-mod": "^4.0.0", + "w3c-keyname": "^2.2.4" + } + }, + "node_modules/@csstools/normalize.css": { + "version": "12.0.0", + "resolved": "https://registry.npmjs.org/@csstools/normalize.css/-/normalize.css-12.0.0.tgz", + "integrity": "sha512-M0qqxAcwCsIVfpFQSlGN5XjXWu8l5JDZN+fPt1LeW5SZexQTgnaEvgXAY+CeygRw0EeppWHi12JxESWiWrB0Sg==" + }, + "node_modules/@csstools/postcss-cascade-layers": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-cascade-layers/-/postcss-cascade-layers-1.1.1.tgz", + "integrity": "sha512-+KdYrpKC5TgomQr2DlZF4lDEpHcoxnj5IGddYYfBWJAKfj1JtuHUIqMa+E1pJJ+z3kvDViWMqyqPlG4Ja7amQA==", + "dependencies": { + "@csstools/selector-specificity": "^2.0.2", + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-color-function": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-color-function/-/postcss-color-function-1.1.1.tgz", + "integrity": "sha512-Bc0f62WmHdtRDjf5f3e2STwRAl89N2CLb+9iAwzrv4L2hncrbDwnQD9PCq0gtAt7pOI2leIV08HIBUd4jxD8cw==", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-font-format-keywords": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-font-format-keywords/-/postcss-font-format-keywords-1.0.1.tgz", + "integrity": "sha512-ZgrlzuUAjXIOc2JueK0X5sZDjCtgimVp/O5CEqTcs5ShWBa6smhWYbS0x5cVc/+rycTDbjjzoP0KTDnUneZGOg==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-hwb-function": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@csstools/postcss-hwb-function/-/postcss-hwb-function-1.0.2.tgz", + "integrity": "sha512-YHdEru4o3Rsbjmu6vHy4UKOXZD+Rn2zmkAmLRfPet6+Jz4Ojw8cbWxe1n42VaXQhD3CQUXXTooIy8OkVbUcL+w==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-ic-unit": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-ic-unit/-/postcss-ic-unit-1.0.1.tgz", + "integrity": "sha512-Ot1rcwRAaRHNKC9tAqoqNZhjdYBzKk1POgWfhN4uCOE47ebGcLRqXjKkApVDpjifL6u2/55ekkpnFcp+s/OZUw==", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-is-pseudo-class": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/@csstools/postcss-is-pseudo-class/-/postcss-is-pseudo-class-2.0.7.tgz", + "integrity": "sha512-7JPeVVZHd+jxYdULl87lvjgvWldYu+Bc62s9vD/ED6/QTGjy0jy0US/f6BG53sVMTBJ1lzKZFpYmofBN9eaRiA==", + "dependencies": { + "@csstools/selector-specificity": "^2.0.0", + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-nested-calc": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-nested-calc/-/postcss-nested-calc-1.0.0.tgz", + "integrity": "sha512-JCsQsw1wjYwv1bJmgjKSoZNvf7R6+wuHDAbi5f/7MbFhl2d/+v+TvBTU4BJH3G1X1H87dHl0mh6TfYogbT/dJQ==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-normalize-display-values": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-1.0.1.tgz", + "integrity": "sha512-jcOanIbv55OFKQ3sYeFD/T0Ti7AMXc9nM1hZWu8m/2722gOTxFg7xYu4RDLJLeZmPUVQlGzo4jhzvTUq3x4ZUw==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-oklab-function": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-oklab-function/-/postcss-oklab-function-1.1.1.tgz", + "integrity": "sha512-nJpJgsdA3dA9y5pgyb/UfEzE7W5Ka7u0CX0/HIMVBNWzWemdcTH3XwANECU6anWv/ao4vVNLTMxhiPNZsTK6iA==", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-progressive-custom-properties": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-1.3.0.tgz", + "integrity": "sha512-ASA9W1aIy5ygskZYuWams4BzafD12ULvSypmaLJT2jvQ8G0M3I8PRQhC0h7mG0Z3LI05+agZjqSR9+K9yaQQjA==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.3" + } + }, + "node_modules/@csstools/postcss-stepped-value-functions": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-stepped-value-functions/-/postcss-stepped-value-functions-1.0.1.tgz", + "integrity": "sha512-dz0LNoo3ijpTOQqEJLY8nyaapl6umbmDcgj4AD0lgVQ572b2eqA1iGZYTTWhrcrHztWDDRAX2DGYyw2VBjvCvQ==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-text-decoration-shorthand": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-1.0.0.tgz", + "integrity": "sha512-c1XwKJ2eMIWrzQenN0XbcfzckOLLJiczqy+YvfGmzoVXd7pT9FfObiSEfzs84bpE/VqfpEuAZ9tCRbZkZxxbdw==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-trigonometric-functions": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-1.0.2.tgz", + "integrity": "sha512-woKaLO///4bb+zZC2s80l+7cm07M7268MsyG3M0ActXXEFi6SuhvriQYcb58iiKGbjwwIU7n45iRLEHypB47Og==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-unset-value": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@csstools/postcss-unset-value/-/postcss-unset-value-1.0.2.tgz", + "integrity": "sha512-c8J4roPBILnelAsdLr4XOAR/GsTm0GJi4XpcfvoWk3U6KiTCqiFYc63KhRMQQX35jYMp4Ao8Ij9+IZRgMfJp1g==", + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/selector-specificity": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@csstools/selector-specificity/-/selector-specificity-2.0.2.tgz", + "integrity": "sha512-IkpVW/ehM1hWKln4fCA3NzJU8KwD+kIOvPZA4cqxoJHtE21CCzjyp+Kxbu0i5I4tBNOlXPL9mjwnWlL0VEG4Fg==", + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2", + "postcss-selector-parser": "^6.0.10" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-1.4.0.tgz", + "integrity": "sha512-7yfvXy6MWLgWSFsLhz5yH3iQ52St8cdUY6FoGieKkRDVxuxmrNuUetIuu6cmjNWwniUHiWXjxCr5tTXDrbYS5A==", + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.4.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + }, + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "13.19.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.19.0.tgz", + "integrity": "sha512-dkQ957uSRWHw7CFXLUtUHQI3g3aWApYhfNR2O6jn/907riyTYKVBmxYVROkBcY614FSSeSJh7Xm7SrUWCxvJMQ==", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/eslintrc/node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/@eslint/eslintrc/node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@graphql-typed-document-node/core": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@graphql-typed-document-node/core/-/core-3.1.1.tgz", + "integrity": "sha512-NQ17ii0rK1b34VZonlmT2QMJFI70m0TRwbknO/ihlbatXyaktDhN/98vBiUU6kNBPljqGqyIrl2T4nY2RpFANg==", + "peerDependencies": { + "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0" + } + }, + "node_modules/@humanwhocodes/config-array": { + "version": "0.11.8", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.8.tgz", + "integrity": "sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g==", + "dependencies": { + "@humanwhocodes/object-schema": "^1.2.1", + "debug": "^4.1.1", + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=10.10.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/object-schema": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", + "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==" + }, + "node_modules/@istanbuljs/load-nyc-config": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", + "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==", + "dependencies": { + "camelcase": "^5.3.1", + "find-up": "^4.1.0", + "get-package-type": "^0.1.0", + "js-yaml": "^3.13.1", + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "engines": { + "node": ">=6" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dependencies": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dependencies": { + "p-locate": "^4.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dependencies": { + "p-limit": "^2.2.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/schema": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", + "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/console": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/console/-/console-27.5.1.tgz", + "integrity": "sha512-kZ/tNpS3NXn0mlXXXPNuDZnb4c0oZ20r4K5eemM2k30ZC3G0T02nXUvyhf5YdbXWHPEJLc9qGLxEZ216MdL+Zg==", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^27.5.1", + "jest-util": "^27.5.1", + "slash": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/console/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@jest/console/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/@jest/console/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@jest/console/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/@jest/console/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/console/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/core": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/core/-/core-27.5.1.tgz", + "integrity": "sha512-AK6/UTrvQD0Cd24NSqmIA6rKsu0tKIxfiCducZvqxYdmMisOYAsdItspT+fQDQYARPf8XgjAFZi0ogW2agH5nQ==", + "dependencies": { + "@jest/console": "^27.5.1", + "@jest/reporters": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "emittery": "^0.8.1", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "jest-changed-files": "^27.5.1", + "jest-config": "^27.5.1", + "jest-haste-map": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-resolve-dependencies": "^27.5.1", + "jest-runner": "^27.5.1", + "jest-runtime": "^27.5.1", + "jest-snapshot": "^27.5.1", + "jest-util": "^27.5.1", + "jest-validate": "^27.5.1", + "jest-watcher": "^27.5.1", + "micromatch": "^4.0.4", + "rimraf": "^3.0.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/@jest/core/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@jest/core/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/@jest/core/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@jest/core/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/@jest/core/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/core/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/environment": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-27.5.1.tgz", + "integrity": "sha512-/WQjhPJe3/ghaol/4Bq480JKXV/Rfw8nQdN7f41fM8VDHLcxKXou6QyXAh3EFr9/bVG3x74z1NWDkP87EiY8gA==", + "dependencies": { + "@jest/fake-timers": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "jest-mock": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/expect-utils": { + "version": "29.3.1", + "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-29.3.1.tgz", + "integrity": "sha512-wlrznINZI5sMjwvUoLVk617ll/UYfGIZNxmbU+Pa7wmkL4vYzhV9R2pwVqUh4NWWuLQWkI8+8mOkxs//prKQ3g==", + "dependencies": { + "jest-get-type": "^29.2.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/expect-utils/node_modules/jest-get-type": { + "version": "29.2.0", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", + "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/fake-timers": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-27.5.1.tgz", + "integrity": "sha512-/aPowoolwa07k7/oM3aASneNeBGCmGQsc3ugN4u6s4C/+s5M64MFo/+djTdiwcbQlRfFElGuDXWzaWj6QgKObQ==", + "dependencies": { + "@jest/types": "^27.5.1", + "@sinonjs/fake-timers": "^8.0.1", + "@types/node": "*", + "jest-message-util": "^27.5.1", + "jest-mock": "^27.5.1", + "jest-util": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/globals": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-27.5.1.tgz", + "integrity": "sha512-ZEJNB41OBQQgGzgyInAv0UUfDDj3upmHydjieSxFvTRuZElrx7tXg/uVQ5hYVEwiXs3+aMsAeEc9X7xiSKCm4Q==", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/types": "^27.5.1", + "expect": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/reporters": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-27.5.1.tgz", + "integrity": "sha512-cPXh9hWIlVJMQkVk84aIvXuBB4uQQmFqZiacloFuGiP3ah1sbCxCosidXFDfqG8+6fO1oR2dTJTlsOy4VFmUfw==", + "dependencies": { + "@bcoe/v8-coverage": "^0.2.3", + "@jest/console": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "collect-v8-coverage": "^1.0.0", + "exit": "^0.1.2", + "glob": "^7.1.2", + "graceful-fs": "^4.2.9", + "istanbul-lib-coverage": "^3.0.0", + "istanbul-lib-instrument": "^5.1.0", + "istanbul-lib-report": "^3.0.0", + "istanbul-lib-source-maps": "^4.0.0", + "istanbul-reports": "^3.1.3", + "jest-haste-map": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-util": "^27.5.1", + "jest-worker": "^27.5.1", + "slash": "^3.0.0", + "source-map": "^0.6.0", + "string-length": "^4.0.1", + "terminal-link": "^2.0.0", + "v8-to-istanbul": "^8.1.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/@jest/reporters/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@jest/reporters/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/@jest/reporters/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@jest/reporters/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/@jest/reporters/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/reporters/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@jest/reporters/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/schemas": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-28.1.3.tgz", + "integrity": "sha512-/l/VWsdt/aBXgjshLWOFyFt3IVdYypu5y2Wn2rOO1un6nkqIn8SLXzgIMYXFyYsRWDyF5EthmKJMIdJvk08grg==", + "dependencies": { + "@sinclair/typebox": "^0.24.1" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/@jest/source-map": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-27.5.1.tgz", + "integrity": "sha512-y9NIHUYF3PJRlHk98NdC/N1gl88BL08aQQgu4k4ZopQkCw9t9cV8mtl3TV8b/YCB8XaVTFrmUTAJvjsntDireg==", + "dependencies": { + "callsites": "^3.0.0", + "graceful-fs": "^4.2.9", + "source-map": "^0.6.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/source-map/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@jest/test-result": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-27.5.1.tgz", + "integrity": "sha512-EW35l2RYFUcUQxFJz5Cv5MTOxlJIQs4I7gxzi2zVU7PJhOwfYq1MdC5nhSmYjX1gmMmLPvB3sIaC+BkcHRBfag==", + "dependencies": { + "@jest/console": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/test-sequencer": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-27.5.1.tgz", + "integrity": "sha512-LCheJF7WB2+9JuCS7VB/EmGIdQuhtqjRNI9A43idHv3E4KltCTsPsLxvdaubFHSYwY/fNjMWjl6vNRhDiN7vpQ==", + "dependencies": { + "@jest/test-result": "^27.5.1", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^27.5.1", + "jest-runtime": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/transform": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-27.5.1.tgz", + "integrity": "sha512-ipON6WtYgl/1329g5AIJVbUuEh0wZVbdpGwC99Jw4LwuoBNS95MVphU6zOeD9pDkon+LLbFL7lOQRapbB8SCHw==", + "dependencies": { + "@babel/core": "^7.1.0", + "@jest/types": "^27.5.1", + "babel-plugin-istanbul": "^6.1.1", + "chalk": "^4.0.0", + "convert-source-map": "^1.4.0", + "fast-json-stable-stringify": "^2.0.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-util": "^27.5.1", + "micromatch": "^4.0.4", + "pirates": "^4.0.4", + "slash": "^3.0.0", + "source-map": "^0.6.1", + "write-file-atomic": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/transform/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@jest/transform/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/@jest/transform/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@jest/transform/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/@jest/transform/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/transform/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@jest/transform/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/types/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@jest/types/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/@jest/types/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@jest/types/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/@jest/types/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/types/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz", + "integrity": "sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==", + "dependencies": { + "@jridgewell/set-array": "^1.0.0", + "@jridgewell/sourcemap-codec": "^1.4.10" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz", + "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/set-array": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", + "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/source-map": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz", + "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.0", + "@jridgewell/trace-mapping": "^0.3.9" + } + }, + "node_modules/@jridgewell/source-map/node_modules/@jridgewell/gen-mapping": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz", + "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==", + "dependencies": { + "@jridgewell/set-array": "^1.0.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.14", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz", + "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.17", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.17.tgz", + "integrity": "sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g==", + "dependencies": { + "@jridgewell/resolve-uri": "3.1.0", + "@jridgewell/sourcemap-codec": "1.4.14" + } + }, + "node_modules/@leichtgewicht/ip-codec": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@leichtgewicht/ip-codec/-/ip-codec-2.0.4.tgz", + "integrity": "sha512-Hcv+nVC0kZnQ3tD9GVu5xSMR4VVYOteQIr/hwFPVEvPdlXqgGEuRjiheChHgdM+JyqdgNcmzZOX/tnl0JOiI7A==" + }, + "node_modules/@lezer/common": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@lezer/common/-/common-1.0.2.tgz", + "integrity": "sha512-SVgiGtMnMnW3ActR8SXgsDhw7a0w0ChHSYAyAUxxrOiJ1OqYWEKk/xJd84tTSPo1mo6DXLObAJALNnd0Hrv7Ng==" + }, + "node_modules/@lezer/highlight": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@lezer/highlight/-/highlight-1.1.3.tgz", + "integrity": "sha512-3vLKLPThO4td43lYRBygmMY18JN3CPh9w+XS2j8WC30vR4yZeFG4z1iFe4jXE43NtGqe//zHW5q8ENLlHvz9gw==", + "dependencies": { + "@lezer/common": "^1.0.0" + } + }, + "node_modules/@lezer/json": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@lezer/json/-/json-1.0.0.tgz", + "integrity": "sha512-zbAuUY09RBzCoCA3lJ1+ypKw5WSNvLqGMtasdW6HvVOqZoCpPr8eWrsGnOVWGKGn8Rh21FnrKRVlJXrGAVUqRw==", + "dependencies": { + "@lezer/highlight": "^1.0.0", + "@lezer/lr": "^1.0.0" + } + }, + "node_modules/@lezer/lr": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@lezer/lr/-/lr-1.2.5.tgz", + "integrity": "sha512-f9319YG1A/3ysgUE3bqCHEd7g+3ZZ71MWlwEc42mpnLVYXgfJJgtu1XAyBB4Kz8FmqmnFe9caopDqKeMMMAU6g==", + "dependencies": { + "@lezer/common": "^1.0.0" + } + }, + "node_modules/@nicolo-ribaudo/eslint-scope-5-internals": { + "version": "5.1.1-v1", + "resolved": "https://registry.npmjs.org/@nicolo-ribaudo/eslint-scope-5-internals/-/eslint-scope-5-internals-5.1.1-v1.tgz", + "integrity": "sha512-54/JRvkLIzzDWshCWfuhadfrfZVPiElY8Fcgmg1HroEly/EDSszzhBAsarCux+D/kOslTRquNzuyGSmUSTTHGg==", + "dependencies": { + "eslint-scope": "5.1.1" + } + }, + "node_modules/@nicolo-ribaudo/eslint-scope-5-internals/node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@nicolo-ribaudo/eslint-scope-5-internals/node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@pmmmwh/react-refresh-webpack-plugin": { + "version": "0.5.10", + "resolved": "https://registry.npmjs.org/@pmmmwh/react-refresh-webpack-plugin/-/react-refresh-webpack-plugin-0.5.10.tgz", + "integrity": "sha512-j0Ya0hCFZPd4x40qLzbhGsh9TMtdb+CJQiso+WxLOPNasohq9cc5SNUcwsZaRH6++Xh91Xkm/xHCkuIiIu0LUA==", + "dependencies": { + "ansi-html-community": "^0.0.8", + "common-path-prefix": "^3.0.0", + "core-js-pure": "^3.23.3", + "error-stack-parser": "^2.0.6", + "find-up": "^5.0.0", + "html-entities": "^2.1.0", + "loader-utils": "^2.0.4", + "schema-utils": "^3.0.0", + "source-map": "^0.7.3" + }, + "engines": { + "node": ">= 10.13" + }, + "peerDependencies": { + "@types/webpack": "4.x || 5.x", + "react-refresh": ">=0.10.0 <1.0.0", + "sockjs-client": "^1.4.0", + "type-fest": ">=0.17.0 <4.0.0", + "webpack": ">=4.43.0 <6.0.0", + "webpack-dev-server": "3.x || 4.x", + "webpack-hot-middleware": "2.x", + "webpack-plugin-serve": "0.x || 1.x" + }, + "peerDependenciesMeta": { + "@types/webpack": { + "optional": true + }, + "sockjs-client": { + "optional": true + }, + "type-fest": { + "optional": true + }, + "webpack-dev-server": { + "optional": true + }, + "webpack-hot-middleware": { + "optional": true + }, + "webpack-plugin-serve": { + "optional": true + } + } + }, + "node_modules/@popperjs/core": { + "version": "2.11.6", + "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.6.tgz", + "integrity": "sha512-50/17A98tWUfQ176raKiOGXuYpLyyVMkxxG6oylzL3BPOlA6ADGdK7EYunSa4I064xerltq9TGXs8HmOk5E+vw==", + "peer": true, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/popperjs" + } + }, + "node_modules/@rollup/plugin-babel": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-5.3.1.tgz", + "integrity": "sha512-WFfdLWU/xVWKeRQnKmIAQULUI7Il0gZnBIH/ZFO069wYIfPu+8zrfp/KMW0atmELoRDq8FbiP3VCss9MhCut7Q==", + "dependencies": { + "@babel/helper-module-imports": "^7.10.4", + "@rollup/pluginutils": "^3.1.0" + }, + "engines": { + "node": ">= 10.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0", + "@types/babel__core": "^7.1.9", + "rollup": "^1.20.0||^2.0.0" + }, + "peerDependenciesMeta": { + "@types/babel__core": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-node-resolve": { + "version": "11.2.1", + "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.1.tgz", + "integrity": "sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==", + "dependencies": { + "@rollup/pluginutils": "^3.1.0", + "@types/resolve": "1.17.1", + "builtin-modules": "^3.1.0", + "deepmerge": "^4.2.2", + "is-module": "^1.0.0", + "resolve": "^1.19.0" + }, + "engines": { + "node": ">= 10.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0" + } + }, + "node_modules/@rollup/plugin-replace": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/@rollup/plugin-replace/-/plugin-replace-2.4.2.tgz", + "integrity": "sha512-IGcu+cydlUMZ5En85jxHH4qj2hta/11BHq95iHEyb2sbgiN0eCdzvUcHw5gt9pBL5lTi4JDYJ1acCoMGpTvEZg==", + "dependencies": { + "@rollup/pluginutils": "^3.1.0", + "magic-string": "^0.25.7" + }, + "peerDependencies": { + "rollup": "^1.20.0 || ^2.0.0" + } + }, + "node_modules/@rollup/pluginutils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.1.0.tgz", + "integrity": "sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==", + "dependencies": { + "@types/estree": "0.0.39", + "estree-walker": "^1.0.1", + "picomatch": "^2.2.2" + }, + "engines": { + "node": ">= 8.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0" + } + }, + "node_modules/@rollup/pluginutils/node_modules/@types/estree": { + "version": "0.0.39", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz", + "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==" + }, + "node_modules/@rushstack/eslint-patch": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@rushstack/eslint-patch/-/eslint-patch-1.2.0.tgz", + "integrity": "sha512-sXo/qW2/pAcmT43VoRKOJbDOfV3cYpq3szSVfIThQXNt+E4DfKj361vaAt3c88U5tPUxzEswam7GW48PJqtKAg==" + }, + "node_modules/@sinclair/typebox": { + "version": "0.24.51", + "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.24.51.tgz", + "integrity": "sha512-1P1OROm/rdubP5aFDSZQILU0vrLCJ4fvHt6EoqHEM+2D/G5MK3bIaymUKLit8Js9gbns5UyJnkP/TZROLw4tUA==" + }, + "node_modules/@sinonjs/commons": { + "version": "1.8.6", + "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.6.tgz", + "integrity": "sha512-Ky+XkAkqPZSm3NLBeUng77EBQl3cmeJhITaGHdYH8kjVB+aun3S4XBRti2zt17mtt0mIUDiNxYeoJm6drVvBJQ==", + "dependencies": { + "type-detect": "4.0.8" + } + }, + "node_modules/@sinonjs/fake-timers": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-8.1.0.tgz", + "integrity": "sha512-OAPJUAtgeINhh/TAlUID4QTs53Njm7xzddaVlEs/SXwgtiD1tW22zAB/W1wdqfrpmikgaWQ9Fw6Ws+hsiRm5Vg==", + "dependencies": { + "@sinonjs/commons": "^1.7.0" + } + }, + "node_modules/@surma/rollup-plugin-off-main-thread": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/@surma/rollup-plugin-off-main-thread/-/rollup-plugin-off-main-thread-2.2.3.tgz", + "integrity": "sha512-lR8q/9W7hZpMWweNiAKU7NQerBnzQQLvi8qnTDU/fxItPhtZVMbPV3lbCwjhIlNBe9Bbr5V+KHshvWmVSG9cxQ==", + "dependencies": { + "ejs": "^3.1.6", + "json5": "^2.2.0", + "magic-string": "^0.25.0", + "string.prototype.matchall": "^4.0.6" + } + }, + "node_modules/@svgr/babel-plugin-add-jsx-attribute": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-5.4.0.tgz", + "integrity": "sha512-ZFf2gs/8/6B8PnSofI0inYXr2SDNTDScPXhN7k5EqD4aZ3gi6u+rbmZHVB8IM3wDyx8ntKACZbtXSm7oZGRqVg==", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-remove-jsx-attribute": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-5.4.0.tgz", + "integrity": "sha512-yaS4o2PgUtwLFGTKbsiAy6D0o3ugcUhWK0Z45umJ66EPWunAz9fuFw2gJuje6wqQvQWOTJvIahUwndOXb7QCPg==", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-remove-jsx-empty-expression": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-5.0.1.tgz", + "integrity": "sha512-LA72+88A11ND/yFIMzyuLRSMJ+tRKeYKeQ+mR3DcAZ5I4h5CPWN9AHyUzJbWSYp/u2u0xhmgOe0+E41+GjEueA==", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-replace-jsx-attribute-value": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-5.0.1.tgz", + "integrity": "sha512-PoiE6ZD2Eiy5mK+fjHqwGOS+IXX0wq/YDtNyIgOrc6ejFnxN4b13pRpiIPbtPwHEc+NT2KCjteAcq33/F1Y9KQ==", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-svg-dynamic-title": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-5.4.0.tgz", + "integrity": "sha512-zSOZH8PdZOpuG1ZVx/cLVePB2ibo3WPpqo7gFIjLV9a0QsuQAzJiwwqmuEdTaW2pegyBE17Uu15mOgOcgabQZg==", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-svg-em-dimensions": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-5.4.0.tgz", + "integrity": "sha512-cPzDbDA5oT/sPXDCUYoVXEmm3VIoAWAPT6mSPTJNbQaBNUuEKVKyGH93oDY4e42PYHRW67N5alJx/eEol20abw==", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-transform-react-native-svg": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-5.4.0.tgz", + "integrity": "sha512-3eYP/SaopZ41GHwXma7Rmxcv9uRslRDTY1estspeB1w1ueZWd/tPlMfEOoccYpEMZU3jD4OU7YitnXcF5hLW2Q==", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-transform-svg-component": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-5.5.0.tgz", + "integrity": "sha512-q4jSH1UUvbrsOtlo/tKcgSeiCHRSBdXoIoqX1pgcKK/aU3JD27wmMKwGtpB8qRYUYoyXvfGxUVKchLuR5pB3rQ==", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-preset": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-5.5.0.tgz", + "integrity": "sha512-4FiXBjvQ+z2j7yASeGPEi8VD/5rrGQk4Xrq3EdJmoZgz/tpqChpo5hgXDvmEauwtvOc52q8ghhZK4Oy7qph4ig==", + "dependencies": { + "@svgr/babel-plugin-add-jsx-attribute": "^5.4.0", + "@svgr/babel-plugin-remove-jsx-attribute": "^5.4.0", + "@svgr/babel-plugin-remove-jsx-empty-expression": "^5.0.1", + "@svgr/babel-plugin-replace-jsx-attribute-value": "^5.0.1", + "@svgr/babel-plugin-svg-dynamic-title": "^5.4.0", + "@svgr/babel-plugin-svg-em-dimensions": "^5.4.0", + "@svgr/babel-plugin-transform-react-native-svg": "^5.4.0", + "@svgr/babel-plugin-transform-svg-component": "^5.5.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/core": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/core/-/core-5.5.0.tgz", + "integrity": "sha512-q52VOcsJPvV3jO1wkPtzTuKlvX7Y3xIcWRpCMtBF3MrteZJtBfQw/+u0B1BHy5ColpQc1/YVTrPEtSYIMNZlrQ==", + "dependencies": { + "@svgr/plugin-jsx": "^5.5.0", + "camelcase": "^6.2.0", + "cosmiconfig": "^7.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/hast-util-to-babel-ast": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-5.5.0.tgz", + "integrity": "sha512-cAaR/CAiZRB8GP32N+1jocovUtvlj0+e65TB50/6Lcime+EA49m/8l+P2ko+XPJ4dw3xaPS3jOL4F2X4KWxoeQ==", + "dependencies": { + "@babel/types": "^7.12.6" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/plugin-jsx": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-5.5.0.tgz", + "integrity": "sha512-V/wVh33j12hGh05IDg8GpIUXbjAPnTdPTKuP4VNLggnwaHMPNQNae2pRnyTAILWCQdz5GyMqtO488g7CKM8CBA==", + "dependencies": { + "@babel/core": "^7.12.3", + "@svgr/babel-preset": "^5.5.0", + "@svgr/hast-util-to-babel-ast": "^5.5.0", + "svg-parser": "^2.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/plugin-svgo": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-5.5.0.tgz", + "integrity": "sha512-r5swKk46GuQl4RrVejVwpeeJaydoxkdwkM1mBKOgJLBUJPGaLci6ylg/IjhrRsREKDkr4kbMWdgOtbXEh0fyLQ==", + "dependencies": { + "cosmiconfig": "^7.0.0", + "deepmerge": "^4.2.2", + "svgo": "^1.2.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/webpack": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/webpack/-/webpack-5.5.0.tgz", + "integrity": "sha512-DOBOK255wfQxguUta2INKkzPj6AIS6iafZYiYmHn6W3pHlycSRRlvWKCfLDG10fXfLWqE3DJHgRUOyJYmARa7g==", + "dependencies": { + "@babel/core": "^7.12.3", + "@babel/plugin-transform-react-constant-elements": "^7.12.1", + "@babel/preset-env": "^7.12.1", + "@babel/preset-react": "^7.12.5", + "@svgr/core": "^5.5.0", + "@svgr/plugin-jsx": "^5.5.0", + "@svgr/plugin-svgo": "^5.5.0", + "loader-utils": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@testing-library/dom": { + "version": "8.19.1", + "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-8.19.1.tgz", + "integrity": "sha512-P6iIPyYQ+qH8CvGauAqanhVnjrnRe0IZFSYCeGkSRW9q3u8bdVn2NPI+lasFyVsEQn1J/IFmp5Aax41+dAP9wg==", + "dependencies": { + "@babel/code-frame": "^7.10.4", + "@babel/runtime": "^7.12.5", + "@types/aria-query": "^5.0.1", + "aria-query": "^5.0.0", + "chalk": "^4.1.0", + "dom-accessibility-api": "^0.5.9", + "lz-string": "^1.4.4", + "pretty-format": "^27.0.2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@testing-library/dom/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@testing-library/dom/node_modules/aria-query": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.1.3.tgz", + "integrity": "sha512-R5iJ5lkuHybztUfuOAznmboyjWq8O6sqNqtK7CLOqdydi54VNbORp49mb14KbWgG1QD3JFO9hJdZ+y4KutfdOQ==", + "dependencies": { + "deep-equal": "^2.0.5" + } + }, + "node_modules/@testing-library/dom/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/@testing-library/dom/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@testing-library/dom/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/@testing-library/dom/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/@testing-library/dom/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@testing-library/jest-dom": { + "version": "5.16.5", + "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-5.16.5.tgz", + "integrity": "sha512-N5ixQ2qKpi5OLYfwQmUb/5mSV9LneAcaUfp32pn4yCnpb8r/Yz0pXFPck21dIicKmi+ta5WRAknkZCfA8refMA==", + "dependencies": { + "@adobe/css-tools": "^4.0.1", + "@babel/runtime": "^7.9.2", + "@types/testing-library__jest-dom": "^5.9.1", + "aria-query": "^5.0.0", + "chalk": "^3.0.0", + "css.escape": "^1.5.1", + "dom-accessibility-api": "^0.5.6", + "lodash": "^4.17.15", + "redent": "^3.0.0" + }, + "engines": { + "node": ">=8", + "npm": ">=6", + "yarn": ">=1" + } + }, + "node_modules/@testing-library/jest-dom/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@testing-library/jest-dom/node_modules/aria-query": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.1.3.tgz", + "integrity": "sha512-R5iJ5lkuHybztUfuOAznmboyjWq8O6sqNqtK7CLOqdydi54VNbORp49mb14KbWgG1QD3JFO9hJdZ+y4KutfdOQ==", + "dependencies": { + "deep-equal": "^2.0.5" + } + }, + "node_modules/@testing-library/jest-dom/node_modules/chalk": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz", + "integrity": "sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@testing-library/jest-dom/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@testing-library/jest-dom/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/@testing-library/jest-dom/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/@testing-library/jest-dom/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@testing-library/react": { + "version": "13.4.0", + "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-13.4.0.tgz", + "integrity": "sha512-sXOGON+WNTh3MLE9rve97ftaZukN3oNf2KjDy7YTx6hcTO2uuLHuCGynMDhFwGw/jYf4OJ2Qk0i4i79qMNNkyw==", + "dependencies": { + "@babel/runtime": "^7.12.5", + "@testing-library/dom": "^8.5.0", + "@types/react-dom": "^18.0.0" + }, + "engines": { + "node": ">=12" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@testing-library/user-event": { + "version": "13.5.0", + "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-13.5.0.tgz", + "integrity": "sha512-5Kwtbo3Y/NowpkbRuSepbyMFkZmHgD+vPzYB/RJ4oxt5Gj/avFFBYjhw27cqSVPVw/3a67NK1PbiIr9k4Gwmdg==", + "dependencies": { + "@babel/runtime": "^7.12.5" + }, + "engines": { + "node": ">=10", + "npm": ">=6" + }, + "peerDependencies": { + "@testing-library/dom": ">=7.21.4" + } + }, + "node_modules/@tootallnate/once": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-1.1.2.tgz", + "integrity": "sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==", + "engines": { + "node": ">= 6" + } + }, + "node_modules/@trysound/sax": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz", + "integrity": "sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==", + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/@types/aria-query": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.1.tgz", + "integrity": "sha512-XTIieEY+gvJ39ChLcB4If5zHtPxt3Syj5rgZR+e1ctpmK8NjPf0zFqsz4JpLJT0xla9GFDKjy8Cpu331nrmE1Q==" + }, + "node_modules/@types/babel__core": { + "version": "7.1.20", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.1.20.tgz", + "integrity": "sha512-PVb6Bg2QuscZ30FvOU7z4guG6c926D9YRvOxEaelzndpMsvP+YM74Q/dAFASpg2l6+XLalxSGxcq/lrgYWZtyQ==", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.6.4", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.4.tgz", + "integrity": "sha512-tFkciB9j2K755yrTALxD44McOrk+gfpIpvC3sxHjRawj6PfnQxrse4Clq5y/Rq+G3mrBurMax/lG8Qn2t9mSsg==", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.1.tgz", + "integrity": "sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g==", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.18.3.tgz", + "integrity": "sha512-1kbcJ40lLB7MHsj39U4Sh1uTd2E7rLEa79kmDpI6cy+XiXsteB3POdQomoq4FxszMrO3ZYchkhYJw7A2862b3w==", + "dependencies": { + "@babel/types": "^7.3.0" + } + }, + "node_modules/@types/body-parser": { + "version": "1.19.2", + "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.2.tgz", + "integrity": "sha512-ALYone6pm6QmwZoAgeyNksccT9Q4AWZQ6PvfwR37GT6r6FWUPguq6sUmNGSMV2Wr761oQoBxwGGa6DR5o1DC9g==", + "dependencies": { + "@types/connect": "*", + "@types/node": "*" + } + }, + "node_modules/@types/bonjour": { + "version": "3.5.10", + "resolved": "https://registry.npmjs.org/@types/bonjour/-/bonjour-3.5.10.tgz", + "integrity": "sha512-p7ienRMiS41Nu2/igbJxxLDWrSZ0WxM8UQgCeO9KhoVF7cOVFkrKsiDr1EsJIla8vV3oEEjGcz11jc5yimhzZw==", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/connect": { + "version": "3.4.35", + "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.35.tgz", + "integrity": "sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ==", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/connect-history-api-fallback": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.3.5.tgz", + "integrity": "sha512-h8QJa8xSb1WD4fpKBDcATDNGXghFj6/3GRWG6dhmRcu0RX1Ubasur2Uvx5aeEwlf0MwblEC2bMzzMQntxnw/Cw==", + "dependencies": { + "@types/express-serve-static-core": "*", + "@types/node": "*" + } + }, + "node_modules/@types/eslint": { + "version": "8.4.10", + "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.4.10.tgz", + "integrity": "sha512-Sl/HOqN8NKPmhWo2VBEPm0nvHnu2LL3v9vKo8MEq0EtbJ4eVzGPl41VNPvn5E1i5poMk4/XD8UriLHpJvEP/Nw==", + "dependencies": { + "@types/estree": "*", + "@types/json-schema": "*" + } + }, + "node_modules/@types/eslint-scope": { + "version": "3.7.4", + "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.4.tgz", + "integrity": "sha512-9K4zoImiZc3HlIp6AVUDE4CWYx22a+lhSZMYNpbjW04+YF0KWj4pJXnEMjdnFTiQibFFmElcsasJXDbdI/EPhA==", + "dependencies": { + "@types/eslint": "*", + "@types/estree": "*" + } + }, + "node_modules/@types/estree": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.0.tgz", + "integrity": "sha512-WulqXMDUTYAXCjZnk6JtIHPigp55cVtDgDrO2gHRwhyJto21+1zbVCtOYB2L1F9w4qCQ0rOGWBnBe0FNTiEJIQ==" + }, + "node_modules/@types/express": { + "version": "4.17.15", + "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.15.tgz", + "integrity": "sha512-Yv0k4bXGOH+8a+7bELd2PqHQsuiANB+A8a4gnQrkRWzrkKlb6KHaVvyXhqs04sVW/OWlbPyYxRgYlIXLfrufMQ==", + "dependencies": { + "@types/body-parser": "*", + "@types/express-serve-static-core": "^4.17.31", + "@types/qs": "*", + "@types/serve-static": "*" + } + }, + "node_modules/@types/express-serve-static-core": { + "version": "4.17.31", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.17.31.tgz", + "integrity": "sha512-DxMhY+NAsTwMMFHBTtJFNp5qiHKJ7TeqOo23zVEM9alT1Ml27Q3xcTH0xwxn7Q0BbMcVEJOs/7aQtUWupUQN3Q==", + "dependencies": { + "@types/node": "*", + "@types/qs": "*", + "@types/range-parser": "*" + } + }, + "node_modules/@types/graceful-fs": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.5.tgz", + "integrity": "sha512-anKkLmZZ+xm4p8JWBf4hElkM4XR+EZeA2M9BAkkTldmcyDY4mbdIJnRghDJH3Ov5ooY7/UAoENtmdMSkaAd7Cw==", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/html-minifier-terser": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz", + "integrity": "sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg==" + }, + "node_modules/@types/http-proxy": { + "version": "1.17.9", + "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.9.tgz", + "integrity": "sha512-QsbSjA/fSk7xB+UXlCT3wHBy5ai9wOcNDWwZAtud+jXhwOM3l+EYZh8Lng4+/6n8uar0J7xILzqftJdJ/Wdfkw==", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/istanbul-lib-coverage": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz", + "integrity": "sha512-z/QT1XN4K4KYuslS23k62yDIDLwLFkzxOuMplDtObz0+y7VqJCaO2o+SPwHCvLFZh7xazvvoor2tA/hPz9ee7g==" + }, + "node_modules/@types/istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg==", + "dependencies": { + "@types/istanbul-lib-coverage": "*" + } + }, + "node_modules/@types/istanbul-reports": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.1.tgz", + "integrity": "sha512-c3mAZEuK0lvBp8tmuL74XRKn1+y2dcwOUpH7x4WrF6gk1GIgiluDRgMYQtw2OFcBvAJWlt6ASU3tSqxp0Uu0Aw==", + "dependencies": { + "@types/istanbul-lib-report": "*" + } + }, + "node_modules/@types/jest": { + "version": "29.2.4", + "resolved": "https://registry.npmjs.org/@types/jest/-/jest-29.2.4.tgz", + "integrity": "sha512-PipFB04k2qTRPePduVLTRiPzQfvMeLwUN3Z21hsAKaB/W9IIzgB2pizCL466ftJlcyZqnHoC9ZHpxLGl3fS86A==", + "dependencies": { + "expect": "^29.0.0", + "pretty-format": "^29.0.0" + } + }, + "node_modules/@types/jest/node_modules/@jest/schemas": { + "version": "29.0.0", + "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.0.0.tgz", + "integrity": "sha512-3Ab5HgYIIAnS0HjqJHQYZS+zXc4tUmTmBH3z83ajI6afXp8X3ZtdLX+nXx+I7LNkJD7uN9LAVhgnjDgZa2z0kA==", + "dependencies": { + "@sinclair/typebox": "^0.24.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/@jest/types": { + "version": "29.3.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.3.1.tgz", + "integrity": "sha512-d0S0jmmTpjnhCmNpApgX3jrUZgZ22ivKJRvL2lli5hpCRoNnp1f85r2/wpKfXuYu8E7Jjh1hGfhPyup1NM5AmA==", + "dependencies": { + "@jest/schemas": "^29.0.0", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/@types/yargs": { + "version": "17.0.18", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.18.tgz", + "integrity": "sha512-eIJR1UER6ur3EpKM3d+2Pgd+ET+k6Kn9B4ZItX0oPjjVI5PrfaRjKyLT5UYendDpLuoiJMNJvovLQbEXqhsPaw==", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@types/jest/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@types/jest/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/@types/jest/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@types/jest/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/@types/jest/node_modules/diff-sequences": { + "version": "29.3.1", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.3.1.tgz", + "integrity": "sha512-hlM3QR272NXCi4pq+N4Kok4kOp6EsgOM3ZSpJI7Da3UAs+Ttsi8MRmB6trM/lhyzUxGfOgnpkHtgqm5Q/CTcfQ==", + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/expect": { + "version": "29.3.1", + "resolved": "https://registry.npmjs.org/expect/-/expect-29.3.1.tgz", + "integrity": "sha512-gGb1yTgU30Q0O/tQq+z30KBWv24ApkMgFUpvKBkyLUBL68Wv8dHdJxTBZFl/iT8K/bqDHvUYRH6IIN3rToopPA==", + "dependencies": { + "@jest/expect-utils": "^29.3.1", + "jest-get-type": "^29.2.0", + "jest-matcher-utils": "^29.3.1", + "jest-message-util": "^29.3.1", + "jest-util": "^29.3.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/@types/jest/node_modules/jest-diff": { + "version": "29.3.1", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-29.3.1.tgz", + "integrity": "sha512-vU8vyiO7568tmin2lA3r2DP8oRvzhvRcD4DjpXc6uGveQodyk7CKLhQlCSiwgx3g0pFaE88/KLZ0yaTWMc4Uiw==", + "dependencies": { + "chalk": "^4.0.0", + "diff-sequences": "^29.3.1", + "jest-get-type": "^29.2.0", + "pretty-format": "^29.3.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/jest-get-type": { + "version": "29.2.0", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.2.0.tgz", + "integrity": "sha512-uXNJlg8hKFEnDgFsrCjznB+sTxdkuqiCL6zMgA75qEbAJjJYTs9XPrvDctrEig2GDow22T/LvHgO57iJhXB/UA==", + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/jest-matcher-utils": { + "version": "29.3.1", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-29.3.1.tgz", + "integrity": "sha512-fkRMZUAScup3txIKfMe3AIZZmPEjWEdsPJFK3AIy5qRohWqQFg1qrmKfYXR9qEkNc7OdAu2N4KPHibEmy4HPeQ==", + "dependencies": { + "chalk": "^4.0.0", + "jest-diff": "^29.3.1", + "jest-get-type": "^29.2.0", + "pretty-format": "^29.3.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/jest-message-util": { + "version": "29.3.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-29.3.1.tgz", + "integrity": "sha512-lMJTbgNcDm5z+6KDxWtqOFWlGQxD6XaYwBqHR8kmpkP+WWWG90I35kdtQHY67Ay5CSuydkTBbJG+tH9JShFCyA==", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^29.3.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^29.3.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/jest-util": { + "version": "29.3.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.3.1.tgz", + "integrity": "sha512-7YOVZaiX7RJLv76ZfHt4nbNEzzTRiMW/IiOG7ZOKmTXmoGBxUDefgMAxQubu6WPVqP5zSzAdZG0FfLcC7HOIFQ==", + "dependencies": { + "@jest/types": "^29.3.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/pretty-format": { + "version": "29.3.1", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.3.1.tgz", + "integrity": "sha512-FyLnmb1cYJV8biEIiRyzRFvs2lry7PPIvOqKVe1GCUEYg4YGmlx1qG9EJNMxArYm7piII4qb8UV1Pncq5dxmcg==", + "dependencies": { + "@jest/schemas": "^29.0.0", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/pretty-format/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@types/jest/node_modules/react-is": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz", + "integrity": "sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==" + }, + "node_modules/@types/jest/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@types/json-schema": { + "version": "7.0.11", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz", + "integrity": "sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==" + }, + "node_modules/@types/json5": { + "version": "0.0.29", + "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz", + "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==" + }, + "node_modules/@types/mime": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@types/mime/-/mime-3.0.1.tgz", + "integrity": "sha512-Y4XFY5VJAuw0FgAqPNd6NNoV44jbq9Bz2L7Rh/J6jLTiHBSBJa9fxqQIvkIld4GsoDOcCbvzOUAbLPsSKKg+uA==" + }, + "node_modules/@types/node": { + "version": "18.11.18", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.18.tgz", + "integrity": "sha512-DHQpWGjyQKSHj3ebjFI/wRKcqQcdR+MoFBygntYOZytCqNfkd2ZC4ARDJ2DQqhjH5p85Nnd3jhUJIXrszFX/JA==" + }, + "node_modules/@types/parse-json": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.0.tgz", + "integrity": "sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==" + }, + "node_modules/@types/prettier": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.2.tgz", + "integrity": "sha512-KufADq8uQqo1pYKVIYzfKbJfBAc0sOeXqGbFaSpv8MRmC/zXgowNZmFcbngndGk922QDmOASEXUZCaY48gs4cg==" + }, + "node_modules/@types/prop-types": { + "version": "15.7.5", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.5.tgz", + "integrity": "sha512-JCB8C6SnDoQf0cNycqd/35A7MjcnK+ZTqE7judS6o7utxUCg6imJg3QK2qzHKszlTjcj2cn+NwMB2i96ubpj7w==" + }, + "node_modules/@types/q": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@types/q/-/q-1.5.5.tgz", + "integrity": "sha512-L28j2FcJfSZOnL1WBjDYp2vUHCeIFlyYI/53EwD/rKUBQ7MtUUfbQWiyKJGpcnv4/WgrhWsFKrcPstcAt/J0tQ==" + }, + "node_modules/@types/qs": { + "version": "6.9.7", + "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.7.tgz", + "integrity": "sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw==" + }, + "node_modules/@types/range-parser": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.4.tgz", + "integrity": "sha512-EEhsLsD6UsDM1yFhAvy0Cjr6VwmpMWqFBCb9w07wVugF7w9nfajxLuVmngTIpgS6svCnm6Vaw+MZhoDCKnOfsw==" + }, + "node_modules/@types/react": { + "version": "18.0.26", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.0.26.tgz", + "integrity": "sha512-hCR3PJQsAIXyxhTNSiDFY//LhnMZWpNNr5etoCqx/iUfGc5gXWtQR2Phl908jVR6uPXacojQWTg4qRpkxTuGug==", + "dependencies": { + "@types/prop-types": "*", + "@types/scheduler": "*", + "csstype": "^3.0.2" + } + }, + "node_modules/@types/react-dom": { + "version": "18.0.10", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.0.10.tgz", + "integrity": "sha512-E42GW/JA4Qv15wQdqJq8DL4JhNpB3prJgjgapN3qJT9K2zO5IIAQh4VXvCEDupoqAwnz0cY4RlXeC/ajX5SFHg==", + "dependencies": { + "@types/react": "*" + } + }, + "node_modules/@types/resolve": { + "version": "1.17.1", + "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.17.1.tgz", + "integrity": "sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/retry": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/@types/retry/-/retry-0.12.0.tgz", + "integrity": "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==" + }, + "node_modules/@types/scheduler": { + "version": "0.16.2", + "resolved": "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.16.2.tgz", + "integrity": "sha512-hppQEBDmlwhFAXKJX2KnWLYu5yMfi91yazPb2l+lbJiwW+wdo1gNeRA+3RgNSO39WYX2euey41KEwnqesU2Jew==" + }, + "node_modules/@types/semver": { + "version": "7.3.13", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.3.13.tgz", + "integrity": "sha512-21cFJr9z3g5dW8B0CVI9g2O9beqaThGQ6ZFBqHfwhzLDKUxaqTIy3vnfah/UPkfOiF2pLq+tGz+W8RyCskuslw==" + }, + "node_modules/@types/serve-index": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/@types/serve-index/-/serve-index-1.9.1.tgz", + "integrity": "sha512-d/Hs3nWDxNL2xAczmOVZNj92YZCS6RGxfBPjKzuu/XirCgXdpKEb88dYNbrYGint6IVWLNP+yonwVAuRC0T2Dg==", + "dependencies": { + "@types/express": "*" + } + }, + "node_modules/@types/serve-static": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.0.tgz", + "integrity": "sha512-z5xyF6uh8CbjAu9760KDKsH2FcDxZ2tFCsA4HIMWE6IkiYMXfVoa+4f9KX+FN0ZLsaMw1WNG2ETLA6N+/YA+cg==", + "dependencies": { + "@types/mime": "*", + "@types/node": "*" + } + }, + "node_modules/@types/sockjs": { + "version": "0.3.33", + "resolved": "https://registry.npmjs.org/@types/sockjs/-/sockjs-0.3.33.tgz", + "integrity": "sha512-f0KEEe05NvUnat+boPTZ0dgaLZ4SfSouXUgv5noUiefG2ajgKjmETo9ZJyuqsl7dfl2aHlLJUiki6B4ZYldiiw==", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/stack-utils": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.1.tgz", + "integrity": "sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==" + }, + "node_modules/@types/testing-library__jest-dom": { + "version": "5.14.5", + "resolved": "https://registry.npmjs.org/@types/testing-library__jest-dom/-/testing-library__jest-dom-5.14.5.tgz", + "integrity": "sha512-SBwbxYoyPIvxHbeHxTZX2Pe/74F/tX2/D3mMvzabdeJ25bBojfW0TyB8BHrbq/9zaaKICJZjLP+8r6AeZMFCuQ==", + "dependencies": { + "@types/jest": "*" + } + }, + "node_modules/@types/trusted-types": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.2.tgz", + "integrity": "sha512-F5DIZ36YVLE+PN+Zwws4kJogq47hNgX3Nx6WyDJ3kcplxyke3XIzB8uK5n/Lpm1HBsbGzd6nmGehL8cPekP+Tg==" + }, + "node_modules/@types/ws": { + "version": "8.5.4", + "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.4.tgz", + "integrity": "sha512-zdQDHKUgcX/zBc4GrwsE/7dVdAD8JR4EuiAXiiUhhfyIJXXb2+PrGshFyeXWQPMmmZ2XxgaqclgpIC7eTXc1mg==", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/yargs": { + "version": "16.0.4", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.4.tgz", + "integrity": "sha512-T8Yc9wt/5LbJyCaLiHPReJa0kApcIgJ7Bn735GjItUfh08Z1pJvu8QZqb9s+mMvKV6WUQRV7K2R46YbjMXTTJw==", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@types/yargs-parser": { + "version": "21.0.0", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.0.tgz", + "integrity": "sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA==" + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "5.47.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.47.1.tgz", + "integrity": "sha512-r4RZ2Jl9kcQN7K/dcOT+J7NAimbiis4sSM9spvWimsBvDegMhKLA5vri2jG19PmIPbDjPeWzfUPQ2hjEzA4Nmg==", + "dependencies": { + "@typescript-eslint/scope-manager": "5.47.1", + "@typescript-eslint/type-utils": "5.47.1", + "@typescript-eslint/utils": "5.47.1", + "debug": "^4.3.4", + "ignore": "^5.2.0", + "natural-compare-lite": "^1.4.0", + "regexpp": "^3.2.0", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^5.0.0", + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/experimental-utils": { + "version": "5.47.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-5.47.1.tgz", + "integrity": "sha512-zWHo/VbqAiRvhXP5byQqW7rGQtdanajHnItGqtmv8JaIi58zMPnmGZ1bW/drXIjU1fuOyfTVoDkNS7aEWGDSLg==", + "dependencies": { + "@typescript-eslint/utils": "5.47.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "5.47.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.47.1.tgz", + "integrity": "sha512-9Vb+KIv29r6GPu4EboWOnQM7T+UjpjXvjCPhNORlgm40a9Ia9bvaPJswvtae1gip2QEeVeGh6YquqAzEgoRAlw==", + "dependencies": { + "@typescript-eslint/scope-manager": "5.47.1", + "@typescript-eslint/types": "5.47.1", + "@typescript-eslint/typescript-estree": "5.47.1", + "debug": "^4.3.4" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "5.47.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.47.1.tgz", + "integrity": "sha512-9hsFDsgUwrdOoW1D97Ewog7DYSHaq4WKuNs0LHF9RiCmqB0Z+XRR4Pf7u7u9z/8CciHuJ6yxNws1XznI3ddjEw==", + "dependencies": { + "@typescript-eslint/types": "5.47.1", + "@typescript-eslint/visitor-keys": "5.47.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "5.47.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.47.1.tgz", + "integrity": "sha512-/UKOeo8ee80A7/GJA427oIrBi/Gd4osk/3auBUg4Rn9EahFpevVV1mUK8hjyQD5lHPqX397x6CwOk5WGh1E/1w==", + "dependencies": { + "@typescript-eslint/typescript-estree": "5.47.1", + "@typescript-eslint/utils": "5.47.1", + "debug": "^4.3.4", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/types": { + "version": "5.47.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.47.1.tgz", + "integrity": "sha512-CmALY9YWXEpwuu6377ybJBZdtSAnzXLSQcxLSqSQSbC7VfpMu/HLVdrnVJj7ycI138EHqocW02LPJErE35cE9A==", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "5.47.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.47.1.tgz", + "integrity": "sha512-4+ZhFSuISAvRi2xUszEj0xXbNTHceV9GbH9S8oAD2a/F9SW57aJNQVOCxG8GPfSWH/X4eOPdMEU2jYVuWKEpWA==", + "dependencies": { + "@typescript-eslint/types": "5.47.1", + "@typescript-eslint/visitor-keys": "5.47.1", + "debug": "^4.3.4", + "globby": "^11.1.0", + "is-glob": "^4.0.3", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "5.47.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.47.1.tgz", + "integrity": "sha512-l90SdwqfmkuIVaREZ2ykEfCezepCLxzWMo5gVfcJsJCaT4jHT+QjgSkYhs5BMQmWqE9k3AtIfk4g211z/sTMVw==", + "dependencies": { + "@types/json-schema": "^7.0.9", + "@types/semver": "^7.3.12", + "@typescript-eslint/scope-manager": "5.47.1", + "@typescript-eslint/types": "5.47.1", + "@typescript-eslint/typescript-estree": "5.47.1", + "eslint-scope": "^5.1.1", + "eslint-utils": "^3.0.0", + "semver": "^7.3.7" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@typescript-eslint/utils/node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@typescript-eslint/utils/node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "5.47.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.47.1.tgz", + "integrity": "sha512-rF3pmut2JCCjh6BLRhNKdYjULMb1brvoaiWDlHfLNVgmnZ0sBVJrs3SyaKE1XoDDnJuAx/hDQryHYmPUuNq0ig==", + "dependencies": { + "@typescript-eslint/types": "5.47.1", + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@webassemblyjs/ast": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.1.tgz", + "integrity": "sha512-ukBh14qFLjxTQNTXocdyksN5QdM28S1CxHt2rdskFyL+xFV7VremuBLVbmCePj+URalXBENx/9Lm7lnhihtCSw==", + "dependencies": { + "@webassemblyjs/helper-numbers": "1.11.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.1" + } + }, + "node_modules/@webassemblyjs/floating-point-hex-parser": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.1.tgz", + "integrity": "sha512-iGRfyc5Bq+NnNuX8b5hwBrRjzf0ocrJPI6GWFodBFzmFnyvrQ83SHKhmilCU/8Jv67i4GJZBMhEzltxzcNagtQ==" + }, + "node_modules/@webassemblyjs/helper-api-error": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.1.tgz", + "integrity": "sha512-RlhS8CBCXfRUR/cwo2ho9bkheSXG0+NwooXcc3PAILALf2QLdFyj7KGsKRbVc95hZnhnERon4kW/D3SZpp6Tcg==" + }, + "node_modules/@webassemblyjs/helper-buffer": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.1.tgz", + "integrity": "sha512-gwikF65aDNeeXa8JxXa2BAk+REjSyhrNC9ZwdT0f8jc4dQQeDQ7G4m0f2QCLPJiMTTO6wfDmRmj/pW0PsUvIcA==" + }, + "node_modules/@webassemblyjs/helper-numbers": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.1.tgz", + "integrity": "sha512-vDkbxiB8zfnPdNK9Rajcey5C0w+QJugEglN0of+kmO8l7lDb77AnlKYQF7aarZuCrv+l0UvqL+68gSDr3k9LPQ==", + "dependencies": { + "@webassemblyjs/floating-point-hex-parser": "1.11.1", + "@webassemblyjs/helper-api-error": "1.11.1", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/helper-wasm-bytecode": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.1.tgz", + "integrity": "sha512-PvpoOGiJwXeTrSf/qfudJhwlvDQxFgelbMqtq52WWiXC6Xgg1IREdngmPN3bs4RoO83PnL/nFrxucXj1+BX62Q==" + }, + "node_modules/@webassemblyjs/helper-wasm-section": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.1.tgz", + "integrity": "sha512-10P9No29rYX1j7F3EVPX3JvGPQPae+AomuSTPiF9eBQeChHI6iqjMIwR9JmOJXwpnn/oVGDk7I5IlskuMwU/pg==", + "dependencies": { + "@webassemblyjs/ast": "1.11.1", + "@webassemblyjs/helper-buffer": "1.11.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.1", + "@webassemblyjs/wasm-gen": "1.11.1" + } + }, + "node_modules/@webassemblyjs/ieee754": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.1.tgz", + "integrity": "sha512-hJ87QIPtAMKbFq6CGTkZYJivEwZDbQUgYd3qKSadTNOhVY7p+gfP6Sr0lLRVTaG1JjFj+r3YchoqRYxNH3M0GQ==", + "dependencies": { + "@xtuc/ieee754": "^1.2.0" + } + }, + "node_modules/@webassemblyjs/leb128": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.1.tgz", + "integrity": "sha512-BJ2P0hNZ0u+Th1YZXJpzW6miwqQUGcIHT1G/sf72gLVD9DZ5AdYTqPNbHZh6K1M5VmKvFXwGSWZADz+qBWxeRw==", + "dependencies": { + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/utf8": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.1.tgz", + "integrity": "sha512-9kqcxAEdMhiwQkHpkNiorZzqpGrodQQ2IGrHHxCy+Ozng0ofyMA0lTqiLkVs1uzTRejX+/O0EOT7KxqVPuXosQ==" + }, + "node_modules/@webassemblyjs/wasm-edit": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.1.tgz", + "integrity": "sha512-g+RsupUC1aTHfR8CDgnsVRVZFJqdkFHpsHMfJuWQzWU3tvnLC07UqHICfP+4XyL2tnr1amvl1Sdp06TnYCmVkA==", + "dependencies": { + "@webassemblyjs/ast": "1.11.1", + "@webassemblyjs/helper-buffer": "1.11.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.1", + "@webassemblyjs/helper-wasm-section": "1.11.1", + "@webassemblyjs/wasm-gen": "1.11.1", + "@webassemblyjs/wasm-opt": "1.11.1", + "@webassemblyjs/wasm-parser": "1.11.1", + "@webassemblyjs/wast-printer": "1.11.1" + } + }, + "node_modules/@webassemblyjs/wasm-gen": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.1.tgz", + "integrity": "sha512-F7QqKXwwNlMmsulj6+O7r4mmtAlCWfO/0HdgOxSklZfQcDu0TpLiD1mRt/zF25Bk59FIjEuGAIyn5ei4yMfLhA==", + "dependencies": { + "@webassemblyjs/ast": "1.11.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.1", + "@webassemblyjs/ieee754": "1.11.1", + "@webassemblyjs/leb128": "1.11.1", + "@webassemblyjs/utf8": "1.11.1" + } + }, + "node_modules/@webassemblyjs/wasm-opt": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.1.tgz", + "integrity": "sha512-VqnkNqnZlU5EB64pp1l7hdm3hmQw7Vgqa0KF/KCNO9sIpI6Fk6brDEiX+iCOYrvMuBWDws0NkTOxYEb85XQHHw==", + "dependencies": { + "@webassemblyjs/ast": "1.11.1", + "@webassemblyjs/helper-buffer": "1.11.1", + "@webassemblyjs/wasm-gen": "1.11.1", + "@webassemblyjs/wasm-parser": "1.11.1" + } + }, + "node_modules/@webassemblyjs/wasm-parser": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.1.tgz", + "integrity": "sha512-rrBujw+dJu32gYB7/Lup6UhdkPx9S9SnobZzRVL7VcBH9Bt9bCBLEuX/YXOOtBsOZ4NQrRykKhffRWHvigQvOA==", + "dependencies": { + "@webassemblyjs/ast": "1.11.1", + "@webassemblyjs/helper-api-error": "1.11.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.1", + "@webassemblyjs/ieee754": "1.11.1", + "@webassemblyjs/leb128": "1.11.1", + "@webassemblyjs/utf8": "1.11.1" + } + }, + "node_modules/@webassemblyjs/wast-printer": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.11.1.tgz", + "integrity": "sha512-IQboUWM4eKzWW+N/jij2sRatKMh99QEelo3Eb2q0qXkvPRISAj8Qxtmw5itwqK+TTkBuUIE45AxYPToqPtL5gg==", + "dependencies": { + "@webassemblyjs/ast": "1.11.1", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@wry/context": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/@wry/context/-/context-0.7.0.tgz", + "integrity": "sha512-LcDAiYWRtwAoSOArfk7cuYvFXytxfVrdX7yxoUmK7pPITLk5jYh2F8knCwS7LjgYL8u1eidPlKKV6Ikqq0ODqQ==", + "dependencies": { + "tslib": "^2.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@wry/equality": { + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/@wry/equality/-/equality-0.5.3.tgz", + "integrity": "sha512-avR+UXdSrsF2v8vIqIgmeTY0UR91UT+IyablCyKe/uk22uOJ8fusKZnH9JH9e1/EtLeNJBtagNmL3eJdnOV53g==", + "dependencies": { + "tslib": "^2.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@wry/trie": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/@wry/trie/-/trie-0.3.2.tgz", + "integrity": "sha512-yRTyhWSls2OY/pYLfwff867r8ekooZ4UI+/gxot5Wj8EFwSf2rG+n+Mo/6LoLQm1TKA4GRj2+LCpbfS937dClQ==", + "dependencies": { + "tslib": "^2.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@xtuc/ieee754": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz", + "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==" + }, + "node_modules/@xtuc/long": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz", + "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==" + }, + "node_modules/abab": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.6.tgz", + "integrity": "sha512-j2afSsaIENvHZN2B8GOpF566vZ5WVk5opAiMTvWgaQT8DkbOqsTfvNAvHoRGU2zzP8cPoqys+xHTRDWW8L+/BA==" + }, + "node_modules/accepts": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", + "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/acorn": { + "version": "8.8.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.1.tgz", + "integrity": "sha512-7zFpHzhnqYKrkYdUjF1HI1bzd0VygEGX8lFk4k5zVMqHEoES+P+7TKI+EvLO9WVMJ8eekdO0aDEK044xTXwPPA==", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-globals": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-6.0.0.tgz", + "integrity": "sha512-ZQl7LOWaF5ePqqcX4hLuv/bLXYQNfNWw2c0/yX/TsPRKamzHcTGQnlCjHT3TsmkOUVEPS3crCxiPfdzE/Trlhg==", + "dependencies": { + "acorn": "^7.1.1", + "acorn-walk": "^7.1.1" + } + }, + "node_modules/acorn-globals/node_modules/acorn": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz", + "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-import-assertions": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/acorn-import-assertions/-/acorn-import-assertions-1.8.0.tgz", + "integrity": "sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==", + "peerDependencies": { + "acorn": "^8" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/acorn-node": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/acorn-node/-/acorn-node-1.8.2.tgz", + "integrity": "sha512-8mt+fslDufLYntIoPAaIMUe/lrbrehIiwmR3t2k9LljIzoigEPF27eLk2hy8zSGzmR/ogr7zbRKINMo1u0yh5A==", + "dependencies": { + "acorn": "^7.0.0", + "acorn-walk": "^7.0.0", + "xtend": "^4.0.2" + } + }, + "node_modules/acorn-node/node_modules/acorn": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz", + "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-walk": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.2.0.tgz", + "integrity": "sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/address": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/address/-/address-1.2.2.tgz", + "integrity": "sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/adjust-sourcemap-loader": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/adjust-sourcemap-loader/-/adjust-sourcemap-loader-4.0.0.tgz", + "integrity": "sha512-OXwN5b9pCUXNQHJpwwD2qP40byEmSgzj8B4ydSN0uMNYWiFmJ6x6KwUllMmfk8Rwu/HJDFR7U8ubsWBoN0Xp0A==", + "dependencies": { + "loader-utils": "^2.0.0", + "regex-parser": "^2.2.11" + }, + "engines": { + "node": ">=8.9" + } + }, + "node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz", + "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==", + "dependencies": { + "ajv": "^8.0.0" + }, + "peerDependencies": { + "ajv": "^8.0.0" + }, + "peerDependenciesMeta": { + "ajv": { + "optional": true + } + } + }, + "node_modules/ajv-formats/node_modules/ajv": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz", + "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + }, + "node_modules/ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dependencies": { + "type-fest": "^0.21.3" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-html-community": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/ansi-html-community/-/ansi-html-community-0.0.8.tgz", + "integrity": "sha512-1APHAyr3+PCamwNw3bXCPp4HFLONZt/yIH0sZp0/469KWNTEy+qN5jQ3GVX6DMZ1UXAi34yVwtTeaG/HpBuuzw==", + "engines": [ + "node >= 0.8.0" + ], + "bin": { + "ansi-html": "bin/ansi-html" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/arg": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz", + "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==" + }, + "node_modules/argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/aria-query": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-4.2.2.tgz", + "integrity": "sha512-o/HelwhuKpTj/frsOsbNLNgnNGVIFsVP/SW2BSF14gVl7kAfMOJ6/8wUAUvG1R1NHKrfG+2sHZTu0yauT1qBrA==", + "dependencies": { + "@babel/runtime": "^7.10.2", + "@babel/runtime-corejs3": "^7.10.2" + }, + "engines": { + "node": ">=6.0" + } + }, + "node_modules/array-flatten": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-2.1.2.tgz", + "integrity": "sha512-hNfzcOV8W4NdualtqBFPyVO+54DSJuZGY9qT4pRroB6S9e3iiido2ISIC5h9R2sPJ8H3FHCIiEnsv1lPXO3KtQ==" + }, + "node_modules/array-includes": { + "version": "3.1.6", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.6.tgz", + "integrity": "sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "get-intrinsic": "^1.1.3", + "is-string": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-move": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/array-move/-/array-move-3.0.1.tgz", + "integrity": "sha512-H3Of6NIn2nNU1gsVDqDnYKY/LCdWvCMMOWifNGhKcVQgiZ6nOek39aESOvro6zmueP07exSl93YLvkN4fZOkSg==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "engines": { + "node": ">=8" + } + }, + "node_modules/array.prototype.flat": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz", + "integrity": "sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.flatmap": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.1.tgz", + "integrity": "sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.reduce": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/array.prototype.reduce/-/array.prototype.reduce-1.0.5.tgz", + "integrity": "sha512-kDdugMl7id9COE8R7MHF5jWk7Dqt/fs4Pv+JXoICnYwqpjjjbUurz6w5fT5IG6brLdJhv6/VoHB0H7oyIBXd+Q==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-array-method-boxes-properly": "^1.0.0", + "is-string": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.tosorted": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array.prototype.tosorted/-/array.prototype.tosorted-1.1.1.tgz", + "integrity": "sha512-pZYPXPRl2PqWcsUs6LOMn+1f1532nEoPTYowBtqLwAW+W8vSVhkIGnmOX1t/UQjD6YGI0vcD2B1U7ZFGQH9jnQ==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0", + "get-intrinsic": "^1.1.3" + } + }, + "node_modules/asap": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz", + "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==" + }, + "node_modules/ast-types-flow": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.7.tgz", + "integrity": "sha512-eBvWn1lvIApYMhzQMsu9ciLfkBY499mFZlNqG+/9WR7PVlroQw0vG30cOQQbaKz3sCEc44TAOu2ykzqXSNnwag==" + }, + "node_modules/async": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/async/-/async-3.2.4.tgz", + "integrity": "sha512-iAB+JbDEGXhyIUavoDl9WP/Jj106Kz9DEn1DPgYw5ruDn0e3Wgi3sKFm55sASdGBNOQB8F59d9qQ7deqrHA8wQ==" + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" + }, + "node_modules/at-least-node": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/atoa": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/atoa/-/atoa-1.0.0.tgz", + "integrity": "sha512-VVE1H6cc4ai+ZXo/CRWoJiHXrA1qfA31DPnx6D20+kSI547hQN5Greh51LQ1baMRMfxO5K5M4ImMtZbZt2DODQ==" + }, + "node_modules/autoprefixer": { + "version": "10.4.13", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.13.tgz", + "integrity": "sha512-49vKpMqcZYsJjwotvt4+h/BCjJVnhGwcLpDt5xkcaOG3eLrG/HUYLagrihYsQ+qrIBgIzX1Rw7a6L8I/ZA1Atg==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/autoprefixer" + } + ], + "dependencies": { + "browserslist": "^4.21.4", + "caniuse-lite": "^1.0.30001426", + "fraction.js": "^4.2.0", + "normalize-range": "^0.1.2", + "picocolors": "^1.0.0", + "postcss-value-parser": "^4.2.0" + }, + "bin": { + "autoprefixer": "bin/autoprefixer" + }, + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/available-typed-arrays": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", + "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/axe-core": { + "version": "4.6.1", + "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.6.1.tgz", + "integrity": "sha512-lCZN5XRuOnpG4bpMq8v0khrWtUOn+i8lZSb6wHZH56ZfbIEv6XwJV84AAueh9/zi7qPVJ/E4yz6fmsiyOmXR4w==", + "engines": { + "node": ">=4" + } + }, + "node_modules/axobject-query": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-2.2.0.tgz", + "integrity": "sha512-Td525n+iPOOyUQIeBfcASuG6uJsDOITl7Mds5gFyerkWiX7qhUTdYUBlSgNMyVqtSJqwpt1kXGLdUt6SykLMRA==" + }, + "node_modules/babel-jest": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-27.5.1.tgz", + "integrity": "sha512-cdQ5dXjGRd0IBRATiQ4mZGlGlRE8kJpjPOixdNRdT+m3UcNqmYWN6rK6nvtXYfY3D76cb8s/O1Ss8ea24PIwcg==", + "dependencies": { + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/babel__core": "^7.1.14", + "babel-plugin-istanbul": "^6.1.1", + "babel-preset-jest": "^27.5.1", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "slash": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.8.0" + } + }, + "node_modules/babel-jest/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/babel-jest/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/babel-jest/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/babel-jest/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/babel-jest/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/babel-jest/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/babel-loader": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/babel-loader/-/babel-loader-8.3.0.tgz", + "integrity": "sha512-H8SvsMF+m9t15HNLMipppzkC+Y2Yq+v3SonZyU70RBL/h1gxPkH08Ot8pEE9Z4Kd+czyWJClmFS8qzIP9OZ04Q==", + "dependencies": { + "find-cache-dir": "^3.3.1", + "loader-utils": "^2.0.0", + "make-dir": "^3.1.0", + "schema-utils": "^2.6.5" + }, + "engines": { + "node": ">= 8.9" + }, + "peerDependencies": { + "@babel/core": "^7.0.0", + "webpack": ">=2" + } + }, + "node_modules/babel-loader/node_modules/schema-utils": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.1.tgz", + "integrity": "sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==", + "dependencies": { + "@types/json-schema": "^7.0.5", + "ajv": "^6.12.4", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 8.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/babel-plugin-istanbul": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz", + "integrity": "sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^5.0.4", + "test-exclude": "^6.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/babel-plugin-jest-hoist": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-27.5.1.tgz", + "integrity": "sha512-50wCwD5EMNW4aRpOwtqzyZHIewTYNxLA4nhB+09d8BIssfNfzBRhkBIHiaPv1Si226TQSvp8gxAJm2iY2qs2hQ==", + "dependencies": { + "@babel/template": "^7.3.3", + "@babel/types": "^7.3.3", + "@types/babel__core": "^7.0.0", + "@types/babel__traverse": "^7.0.6" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/babel-plugin-macros": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/babel-plugin-macros/-/babel-plugin-macros-3.1.0.tgz", + "integrity": "sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==", + "dependencies": { + "@babel/runtime": "^7.12.5", + "cosmiconfig": "^7.0.0", + "resolve": "^1.19.0" + }, + "engines": { + "node": ">=10", + "npm": ">=6" + } + }, + "node_modules/babel-plugin-named-asset-import": { + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/babel-plugin-named-asset-import/-/babel-plugin-named-asset-import-0.3.8.tgz", + "integrity": "sha512-WXiAc++qo7XcJ1ZnTYGtLxmBCVbddAml3CEXgWaBzNzLNoxtQ8AiGEFDMOhot9XjTCQbvP5E77Fj9Gk924f00Q==", + "peerDependencies": { + "@babel/core": "^7.1.0" + } + }, + "node_modules/babel-plugin-polyfill-corejs2": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.3.3.tgz", + "integrity": "sha512-8hOdmFYFSZhqg2C/JgLUQ+t52o5nirNwaWM2B9LWteozwIvM14VSwdsCAUET10qT+kmySAlseadmfeeSWFCy+Q==", + "dependencies": { + "@babel/compat-data": "^7.17.7", + "@babel/helper-define-polyfill-provider": "^0.3.3", + "semver": "^6.1.1" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/babel-plugin-polyfill-corejs2/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/babel-plugin-polyfill-corejs3": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.6.0.tgz", + "integrity": "sha512-+eHqR6OPcBhJOGgsIar7xoAB1GcSwVUA3XjAd7HJNzOXT4wv6/H7KIdA/Nc60cvUlDbKApmqNvD1B1bzOt4nyA==", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.3.3", + "core-js-compat": "^3.25.1" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/babel-plugin-polyfill-regenerator": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.4.1.tgz", + "integrity": "sha512-NtQGmyQDXjQqQ+IzRkBVwEOz9lQ4zxAQZgoAYEtU9dJjnl1Oc98qnN7jcp+bE7O7aYzVpavXE3/VKXNzUbh7aw==", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.3.3" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/babel-plugin-transform-react-remove-prop-types": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-react-remove-prop-types/-/babel-plugin-transform-react-remove-prop-types-0.4.24.tgz", + "integrity": "sha512-eqj0hVcJUR57/Ug2zE1Yswsw4LhuqqHhD+8v120T1cl3kjg76QwtyBrdIk4WVwK+lAhBJVYCd/v+4nc4y+8JsA==" + }, + "node_modules/babel-preset-current-node-syntax": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz", + "integrity": "sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==", + "dependencies": { + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-bigint": "^7.8.3", + "@babel/plugin-syntax-class-properties": "^7.8.3", + "@babel/plugin-syntax-import-meta": "^7.8.3", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.8.3", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-top-level-await": "^7.8.3" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/babel-preset-jest": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-27.5.1.tgz", + "integrity": "sha512-Nptf2FzlPCWYuJg41HBqXVT8ym6bXOevuCTbhxlUpjwtysGaIWFvDEjp4y+G7fl13FgOdjs7P/DmErqH7da0Ag==", + "dependencies": { + "babel-plugin-jest-hoist": "^27.5.1", + "babel-preset-current-node-syntax": "^1.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/babel-preset-react-app": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/babel-preset-react-app/-/babel-preset-react-app-10.0.1.tgz", + "integrity": "sha512-b0D9IZ1WhhCWkrTXyFuIIgqGzSkRIH5D5AmB0bXbzYAB1OBAwHcUeyWW2LorutLWF5btNo/N7r/cIdmvvKJlYg==", + "dependencies": { + "@babel/core": "^7.16.0", + "@babel/plugin-proposal-class-properties": "^7.16.0", + "@babel/plugin-proposal-decorators": "^7.16.4", + "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.0", + "@babel/plugin-proposal-numeric-separator": "^7.16.0", + "@babel/plugin-proposal-optional-chaining": "^7.16.0", + "@babel/plugin-proposal-private-methods": "^7.16.0", + "@babel/plugin-transform-flow-strip-types": "^7.16.0", + "@babel/plugin-transform-react-display-name": "^7.16.0", + "@babel/plugin-transform-runtime": "^7.16.4", + "@babel/preset-env": "^7.16.4", + "@babel/preset-react": "^7.16.0", + "@babel/preset-typescript": "^7.16.0", + "@babel/runtime": "^7.16.3", + "babel-plugin-macros": "^3.1.0", + "babel-plugin-transform-react-remove-prop-types": "^0.4.24" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" + }, + "node_modules/batch": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/batch/-/batch-0.6.1.tgz", + "integrity": "sha512-x+VAiMRL6UPkx+kudNvxTl6hB2XNNCG2r+7wixVfIYwu/2HKRXimwQyaumLjMveWvT2Hkd/cAJw+QBMfJ/EKVw==" + }, + "node_modules/bfj": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/bfj/-/bfj-7.0.2.tgz", + "integrity": "sha512-+e/UqUzwmzJamNF50tBV6tZPTORow7gQ96iFow+8b562OdMpEK0BcJEq2OSPEDmAbSMBQ7PKZ87ubFkgxpYWgw==", + "dependencies": { + "bluebird": "^3.5.5", + "check-types": "^11.1.1", + "hoopy": "^0.1.4", + "tryer": "^1.0.1" + }, + "engines": { + "node": ">= 8.0.0" + } + }, + "node_modules/big.js": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz", + "integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==", + "engines": { + "node": "*" + } + }, + "node_modules/binary-extensions": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", + "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", + "engines": { + "node": ">=8" + } + }, + "node_modules/bluebird": { + "version": "3.7.2", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz", + "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==" + }, + "node_modules/body-parser": { + "version": "1.20.1", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.1.tgz", + "integrity": "sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==", + "dependencies": { + "bytes": "3.1.2", + "content-type": "~1.0.4", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "on-finished": "2.4.1", + "qs": "6.11.0", + "raw-body": "2.5.1", + "type-is": "~1.6.18", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/body-parser/node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/body-parser/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/body-parser/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/body-parser/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/bonjour-service": { + "version": "1.0.14", + "resolved": "https://registry.npmjs.org/bonjour-service/-/bonjour-service-1.0.14.tgz", + "integrity": "sha512-HIMbgLnk1Vqvs6B4Wq5ep7mxvj9sGz5d1JJyDNSGNIdA/w2MCz6GTjWTdjqOJV1bEPj+6IkxDvWNFKEBxNt4kQ==", + "dependencies": { + "array-flatten": "^2.1.2", + "dns-equal": "^1.0.0", + "fast-deep-equal": "^3.1.3", + "multicast-dns": "^7.2.5" + } + }, + "node_modules/boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==" + }, + "node_modules/bootstrap": { + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.2.3.tgz", + "integrity": "sha512-cEKPM+fwb3cT8NzQZYEu4HilJ3anCrWqh3CHAok1p9jXqMPsPTBhU25fBckEJHJ/p+tTxTFTsFQGM+gaHpi3QQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/twbs" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/bootstrap" + } + ], + "peerDependencies": { + "@popperjs/core": "^2.11.6" + } + }, + "node_modules/bootstrap-icons": { + "version": "1.10.3", + "resolved": "https://registry.npmjs.org/bootstrap-icons/-/bootstrap-icons-1.10.3.tgz", + "integrity": "sha512-7Qvj0j0idEm/DdX9Q0CpxAnJYqBCFCiUI6qzSPYfERMcokVuV9Mdm/AJiVZI8+Gawe4h/l6zFcOzvV7oXCZArw==" + }, + "node_modules/bpmn-js": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/bpmn-js/-/bpmn-js-11.1.0.tgz", + "integrity": "sha512-E4jepvYHxEwCVBppi6DYidwvCa0yu94Ho22js5H5a/AKuC4xBf2uoTSzCrEgQP0vwRD3nDMuvsO2B/vLDeEc0w==", + "dependencies": { + "bpmn-moddle": "^8.0.0", + "css.escape": "^1.5.1", + "diagram-js": "^11.4.1", + "diagram-js-direct-editing": "^2.0.0", + "ids": "^1.0.0", + "inherits-browser": "^0.1.0", + "min-dash": "^4.0.0", + "min-dom": "^4.0.2", + "object-refs": "^0.3.0", + "tiny-svg": "^3.0.0" + } + }, + "node_modules/bpmn-moddle": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/bpmn-moddle/-/bpmn-moddle-8.0.0.tgz", + "integrity": "sha512-mHmtIVzUyZcPMKKl/REq151gYxEtZxvivKnIEp/RtuRm8SOgxAK58uYBkP+jQQBy6XudwObRTH0pwyeKLALWrA==", + "dependencies": { + "min-dash": "^4.0.0", + "moddle": "^6.0.0", + "moddle-xml": "^10.0.0" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browser-process-hrtime": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz", + "integrity": "sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow==" + }, + "node_modules/browserslist": { + "version": "4.21.4", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.4.tgz", + "integrity": "sha512-CBHJJdDmgjl3daYjN5Cp5kbTf1mUhZoS+beLklHIvkOWscs83YAhLlF3Wsh/lciQYAcbBJgTOD44VtG31ZM4Hw==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + } + ], + "dependencies": { + "caniuse-lite": "^1.0.30001400", + "electron-to-chromium": "^1.4.251", + "node-releases": "^2.0.6", + "update-browserslist-db": "^1.0.9" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/bser": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz", + "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==", + "dependencies": { + "node-int64": "^0.4.0" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==" + }, + "node_modules/builtin-modules": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.3.0.tgz", + "integrity": "sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/bytes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz", + "integrity": "sha512-pMhOfFDPiv9t5jjIXkHosWmkSyQbvsgEVNkz0ERHbuLh2T/7j4Mqqpz523Fe8MVY89KC6Sh/QfS2sM+SjgFDcw==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", + "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "dependencies": { + "function-bind": "^1.1.1", + "get-intrinsic": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "engines": { + "node": ">=6" + } + }, + "node_modules/camel-case": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz", + "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==", + "dependencies": { + "pascal-case": "^3.1.2", + "tslib": "^2.0.3" + } + }, + "node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/camelcase-css": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz", + "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==", + "engines": { + "node": ">= 6" + } + }, + "node_modules/caniuse-api": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/caniuse-api/-/caniuse-api-3.0.0.tgz", + "integrity": "sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==", + "dependencies": { + "browserslist": "^4.0.0", + "caniuse-lite": "^1.0.0", + "lodash.memoize": "^4.1.2", + "lodash.uniq": "^4.5.0" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001441", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001441.tgz", + "integrity": "sha512-OyxRR4Vof59I3yGWXws6i908EtGbMzVUi3ganaZQHmydk1iwDhRnvaPG2WaR0KcqrDFKrxVZHULT396LEPhXfg==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + } + ] + }, + "node_modules/case-sensitive-paths-webpack-plugin": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/case-sensitive-paths-webpack-plugin/-/case-sensitive-paths-webpack-plugin-2.4.0.tgz", + "integrity": "sha512-roIFONhcxog0JSSWbvVAh3OocukmSgpqOH6YpMkCvav/ySIV3JKg4Dc8vYtQjYi/UxpNE36r/9v+VqTQqgkYmw==", + "engines": { + "node": ">=4" + } + }, + "node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/char-regex": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", + "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", + "engines": { + "node": ">=10" + } + }, + "node_modules/check-types": { + "version": "11.2.2", + "resolved": "https://registry.npmjs.org/check-types/-/check-types-11.2.2.tgz", + "integrity": "sha512-HBiYvXvn9Z70Z88XKjz3AEKd4HJhBXsa3j7xFnITAzoS8+q6eIGi8qDB8FKPBAjtuxjI/zFpwuiCb8oDtKOYrA==" + }, + "node_modules/chokidar": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", + "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/chokidar/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/chrome-trace-event": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz", + "integrity": "sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==", + "engines": { + "node": ">=6.0" + } + }, + "node_modules/ci-info": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.7.0.tgz", + "integrity": "sha512-2CpRNYmImPx+RXKLq6jko/L07phmS9I02TyqkcNU20GCF/GgaWvc58hPtjxDX8lPpkdwc9sNh72V9k00S7ezog==", + "engines": { + "node": ">=8" + } + }, + "node_modules/cjs-module-lexer": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.2.2.tgz", + "integrity": "sha512-cOU9usZw8/dXIXKtwa8pM0OTJQuJkxMN6w30csNRUerHfeQ5R6U3kkU/FtJeIf3M202OHfY2U8ccInBG7/xogA==" + }, + "node_modules/classnames": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/classnames/-/classnames-2.3.2.tgz", + "integrity": "sha512-CSbhY4cFEJRe6/GQzIk5qXZ4Jeg5pcsP7b5peFSDpffpe1cqjASH/n9UTjBwOp6XpMSTwQ8Za2K5V02ueA7Tmw==" + }, + "node_modules/clean-css": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.1.tgz", + "integrity": "sha512-lCr8OHhiWCTw4v8POJovCoh4T7I9U11yVsPjMWWnnMmp9ZowCxyad1Pathle/9HjaDp+fdQKjO9fQydE6RHTZg==", + "dependencies": { + "source-map": "~0.6.0" + }, + "engines": { + "node": ">= 10.0" + } + }, + "node_modules/clean-css/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "node_modules/clsx": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-1.2.1.tgz", + "integrity": "sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==", + "engines": { + "node": ">=6" + } + }, + "node_modules/co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==", + "engines": { + "iojs": ">= 1.0.0", + "node": ">= 0.12.0" + } + }, + "node_modules/coa": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/coa/-/coa-2.0.2.tgz", + "integrity": "sha512-q5/jG+YQnSy4nRTV4F7lPepBJZ8qBNJJDBuJdoejDyLXgmL7IEo+Le2JDZudFTFt7mrCqIRaSjws4ygRCTCAXA==", + "dependencies": { + "@types/q": "^1.5.1", + "chalk": "^2.4.1", + "q": "^1.1.2" + }, + "engines": { + "node": ">= 4.0" + } + }, + "node_modules/codemirror": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/codemirror/-/codemirror-6.0.1.tgz", + "integrity": "sha512-J8j+nZ+CdWmIeFIGXEFbFPtpiYacFMDR8GlHK3IyHQJMCaVRfGx9NT+Hxivv1ckLWPvNdZqndbr/7lVhrf/Svg==", + "dependencies": { + "@codemirror/autocomplete": "^6.0.0", + "@codemirror/commands": "^6.0.0", + "@codemirror/language": "^6.0.0", + "@codemirror/lint": "^6.0.0", + "@codemirror/search": "^6.0.0", + "@codemirror/state": "^6.0.0", + "@codemirror/view": "^6.0.0" + } + }, + "node_modules/collect-v8-coverage": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz", + "integrity": "sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg==" + }, + "node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==" + }, + "node_modules/colord": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/colord/-/colord-2.9.3.tgz", + "integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==" + }, + "node_modules/colorette": { + "version": "2.0.19", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.19.tgz", + "integrity": "sha512-3tlv/dIP7FWvj3BsbHrGLJ6l/oKh1O3TcgBqMn+yyCagOxc23fyzDS6HypQbgxWbkpDnf52p1LuR4eWDQ/K9WQ==" + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/commander": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz", + "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==", + "engines": { + "node": ">= 12" + } + }, + "node_modules/common-path-prefix": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/common-path-prefix/-/common-path-prefix-3.0.0.tgz", + "integrity": "sha512-QE33hToZseCH3jS0qN96O/bSh3kaw/h+Tq7ngyY9eWDUnTlTNUyqfqvCXioLe5Na5jFsL78ra/wuBU4iuEgd4w==" + }, + "node_modules/common-tags": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/common-tags/-/common-tags-1.8.2.tgz", + "integrity": "sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==", + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/commondir": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz", + "integrity": "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==" + }, + "node_modules/component-event": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/component-event/-/component-event-0.1.4.tgz", + "integrity": "sha512-GMwOG8MnUHP1l8DZx1ztFO0SJTFnIzZnBDkXAj8RM2ntV2A6ALlDxgbMY1Fvxlg6WPQ+5IM/a6vg4PEYbjg/Rw==" + }, + "node_modules/compressible": { + "version": "2.0.18", + "resolved": "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz", + "integrity": "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==", + "dependencies": { + "mime-db": ">= 1.43.0 < 2" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/compression": { + "version": "1.7.4", + "resolved": "https://registry.npmjs.org/compression/-/compression-1.7.4.tgz", + "integrity": "sha512-jaSIDzP9pZVS4ZfQ+TzvtiWhdpFhE2RDHz8QJkpX9SIpLq88VueF5jJw6t+6CUQcAoA6t+x89MLrWAqpfDE8iQ==", + "dependencies": { + "accepts": "~1.3.5", + "bytes": "3.0.0", + "compressible": "~2.0.16", + "debug": "2.6.9", + "on-headers": "~1.0.2", + "safe-buffer": "5.1.2", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/compression/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/compression/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/compression/node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==" + }, + "node_modules/confusing-browser-globals": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/confusing-browser-globals/-/confusing-browser-globals-1.0.11.tgz", + "integrity": "sha512-JsPKdmh8ZkmnHxDk55FZ1TqVLvEQTvoByJZRN9jzI0UjxK/QgAmsphz7PGtqgPieQZ/CQcHWXCR7ATDNhGe+YA==" + }, + "node_modules/connect-history-api-fallback": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/connect-history-api-fallback/-/connect-history-api-fallback-2.0.0.tgz", + "integrity": "sha512-U73+6lQFmfiNPrYbXqr6kZ1i1wiRqXnp2nhMsINseWXO8lDau0LGEffJ8kQi4EjLZympVgRdvqjAgiZ1tgzDDA==", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/content-disposition": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", + "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz", + "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/contra": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/contra/-/contra-1.9.4.tgz", + "integrity": "sha512-N9ArHAqwR/lhPq4OdIAwH4e1btn6EIZMAz4TazjnzCiVECcWUPTma+dRAM38ERImEJBh8NiCCpjoQruSZ+agYg==", + "dependencies": { + "atoa": "1.0.0", + "ticky": "1.0.1" + } + }, + "node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==" + }, + "node_modules/cookie": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz", + "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==" + }, + "node_modules/core-js": { + "version": "3.27.1", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.27.1.tgz", + "integrity": "sha512-GutwJLBChfGCpwwhbYoqfv03LAfmiz7e7D/BNxzeMxwQf10GRSzqiOjx7AmtEk+heiD/JWmBuyBPgFtx0Sg1ww==", + "hasInstallScript": true, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/core-js-compat": { + "version": "3.27.1", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.27.1.tgz", + "integrity": "sha512-Dg91JFeCDA17FKnneN7oCMz4BkQ4TcffkgHP4OWwp9yx3pi7ubqMDXXSacfNak1PQqjc95skyt+YBLHQJnkJwA==", + "dependencies": { + "browserslist": "^4.21.4" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/core-js-pure": { + "version": "3.27.1", + "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.27.1.tgz", + "integrity": "sha512-BS2NHgwwUppfeoqOXqi08mUqS5FiZpuRuJJpKsaME7kJz0xxuk0xkhDdfMIlP/zLa80krBqss1LtD7f889heAw==", + "hasInstallScript": true, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/core-util-is": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", + "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==" + }, + "node_modules/cosmiconfig": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz", + "integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==", + "dependencies": { + "@types/parse-json": "^4.0.0", + "import-fresh": "^3.2.1", + "parse-json": "^5.0.0", + "path-type": "^4.0.0", + "yaml": "^1.10.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/crelt": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/crelt/-/crelt-1.0.5.tgz", + "integrity": "sha512-+BO9wPPi+DWTDcNYhr/W90myha8ptzftZT+LwcmUbbok0rcP/fequmFYCw8NMoH7pkAZQzU78b3kYrlua5a9eA==" + }, + "node_modules/cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/crossvent": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/crossvent/-/crossvent-1.5.5.tgz", + "integrity": "sha512-MY4xhBYEnVi+pmTpHCOCsCLYczc0PVtGdPBz6NXNXxikLaUZo4HdAeUb1UqAo3t3yXAloSelTmfxJ+/oUqkW5w==", + "dependencies": { + "custom-event": "^1.0.0" + } + }, + "node_modules/crypto-random-string": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-2.0.0.tgz", + "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==", + "engines": { + "node": ">=8" + } + }, + "node_modules/css-blank-pseudo": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/css-blank-pseudo/-/css-blank-pseudo-3.0.3.tgz", + "integrity": "sha512-VS90XWtsHGqoM0t4KpH053c4ehxZ2E6HtGI7x68YFV0pTo/QmkV/YFA+NnlvK8guxZVNWGQhVNJGC39Q8XF4OQ==", + "dependencies": { + "postcss-selector-parser": "^6.0.9" + }, + "bin": { + "css-blank-pseudo": "dist/cli.cjs" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/css-declaration-sorter": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-6.3.1.tgz", + "integrity": "sha512-fBffmak0bPAnyqc/HO8C3n2sHrp9wcqQz6ES9koRF2/mLOVAx9zIQ3Y7R29sYCteTPqMCwns4WYQoCX91Xl3+w==", + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.0.9" + } + }, + "node_modules/css-has-pseudo": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/css-has-pseudo/-/css-has-pseudo-3.0.4.tgz", + "integrity": "sha512-Vse0xpR1K9MNlp2j5w1pgWIJtm1a8qS0JwS9goFYcImjlHEmywP9VUF05aGBXzGpDJF86QXk4L0ypBmwPhGArw==", + "dependencies": { + "postcss-selector-parser": "^6.0.9" + }, + "bin": { + "css-has-pseudo": "dist/cli.cjs" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/css-loader": { + "version": "6.7.3", + "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-6.7.3.tgz", + "integrity": "sha512-qhOH1KlBMnZP8FzRO6YCH9UHXQhVMcEGLyNdb7Hv2cpcmJbW0YrddO+tG1ab5nT41KpHIYGsbeHqxB9xPu1pKQ==", + "dependencies": { + "icss-utils": "^5.1.0", + "postcss": "^8.4.19", + "postcss-modules-extract-imports": "^3.0.0", + "postcss-modules-local-by-default": "^4.0.0", + "postcss-modules-scope": "^3.0.0", + "postcss-modules-values": "^4.0.0", + "postcss-value-parser": "^4.2.0", + "semver": "^7.3.8" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/css-minimizer-webpack-plugin": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-3.4.1.tgz", + "integrity": "sha512-1u6D71zeIfgngN2XNRJefc/hY7Ybsxd74Jm4qngIXyUEk7fss3VUzuHxLAq/R8NAba4QU9OUSaMZlbpRc7bM4Q==", + "dependencies": { + "cssnano": "^5.0.6", + "jest-worker": "^27.0.2", + "postcss": "^8.3.5", + "schema-utils": "^4.0.0", + "serialize-javascript": "^6.0.0", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + }, + "peerDependenciesMeta": { + "@parcel/css": { + "optional": true + }, + "clean-css": { + "optional": true + }, + "csso": { + "optional": true + }, + "esbuild": { + "optional": true + } + } + }, + "node_modules/css-minimizer-webpack-plugin/node_modules/ajv": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz", + "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/css-minimizer-webpack-plugin/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + }, + "node_modules/css-minimizer-webpack-plugin/node_modules/schema-utils": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", + "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", + "dependencies": { + "@types/json-schema": "^7.0.9", + "ajv": "^8.8.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/css-minimizer-webpack-plugin/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/css-prefers-color-scheme": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/css-prefers-color-scheme/-/css-prefers-color-scheme-6.0.3.tgz", + "integrity": "sha512-4BqMbZksRkJQx2zAjrokiGMd07RqOa2IxIrrN10lyBe9xhn9DEvjUK79J6jkeiv9D9hQFXKb6g1jwU62jziJZA==", + "bin": { + "css-prefers-color-scheme": "dist/cli.cjs" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/css-select": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", + "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.0.1", + "domhandler": "^4.3.1", + "domutils": "^2.8.0", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-select-base-adapter": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/css-select-base-adapter/-/css-select-base-adapter-0.1.1.tgz", + "integrity": "sha512-jQVeeRG70QI08vSTwf1jHxp74JoZsr2XSgETae8/xC8ovSnL2WF87GTLO86Sbwdt2lK4Umg4HnnwMO4YF3Ce7w==" + }, + "node_modules/css-tree": { + "version": "1.0.0-alpha.37", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-1.0.0-alpha.37.tgz", + "integrity": "sha512-DMxWJg0rnz7UgxKT0Q1HU/L9BeJI0M6ksor0OgqOnF+aRCDWg/N2641HmVyU9KVIu0OVVWOb2IpC9A+BJRnejg==", + "dependencies": { + "mdn-data": "2.0.4", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/css-tree/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/css-what": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz", + "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==", + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css.escape": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz", + "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==" + }, + "node_modules/cssdb": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/cssdb/-/cssdb-7.2.0.tgz", + "integrity": "sha512-JYlIsE7eKHSi0UNuCyo96YuIDFqvhGgHw4Ck6lsN+DP0Tp8M64UTDT2trGbkMDqnCoEjks7CkS0XcjU0rkvBdg==", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + }, + "node_modules/cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/cssnano": { + "version": "5.1.14", + "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-5.1.14.tgz", + "integrity": "sha512-Oou7ihiTocbKqi0J1bB+TRJIQX5RMR3JghA8hcWSw9mjBLQ5Y3RWqEDoYG3sRNlAbCIXpqMoZGbq5KDR3vdzgw==", + "dependencies": { + "cssnano-preset-default": "^5.2.13", + "lilconfig": "^2.0.3", + "yaml": "^1.10.2" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/cssnano" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/cssnano-preset-default": { + "version": "5.2.13", + "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-5.2.13.tgz", + "integrity": "sha512-PX7sQ4Pb+UtOWuz8A1d+Rbi+WimBIxJTRyBdgGp1J75VU0r/HFQeLnMYgHiCAp6AR4rqrc7Y4R+1Rjk3KJz6DQ==", + "dependencies": { + "css-declaration-sorter": "^6.3.1", + "cssnano-utils": "^3.1.0", + "postcss-calc": "^8.2.3", + "postcss-colormin": "^5.3.0", + "postcss-convert-values": "^5.1.3", + "postcss-discard-comments": "^5.1.2", + "postcss-discard-duplicates": "^5.1.0", + "postcss-discard-empty": "^5.1.1", + "postcss-discard-overridden": "^5.1.0", + "postcss-merge-longhand": "^5.1.7", + "postcss-merge-rules": "^5.1.3", + "postcss-minify-font-values": "^5.1.0", + "postcss-minify-gradients": "^5.1.1", + "postcss-minify-params": "^5.1.4", + "postcss-minify-selectors": "^5.2.1", + "postcss-normalize-charset": "^5.1.0", + "postcss-normalize-display-values": "^5.1.0", + "postcss-normalize-positions": "^5.1.1", + "postcss-normalize-repeat-style": "^5.1.1", + "postcss-normalize-string": "^5.1.0", + "postcss-normalize-timing-functions": "^5.1.0", + "postcss-normalize-unicode": "^5.1.1", + "postcss-normalize-url": "^5.1.0", + "postcss-normalize-whitespace": "^5.1.1", + "postcss-ordered-values": "^5.1.3", + "postcss-reduce-initial": "^5.1.1", + "postcss-reduce-transforms": "^5.1.0", + "postcss-svgo": "^5.1.0", + "postcss-unique-selectors": "^5.1.1" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/cssnano-utils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-3.1.0.tgz", + "integrity": "sha512-JQNR19/YZhz4psLX/rQ9M83e3z2Wf/HdJbryzte4a3NSuafyp9w/I4U+hx5C2S9g41qlstH7DEWnZaaj83OuEA==", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/csso": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/csso/-/csso-4.2.0.tgz", + "integrity": "sha512-wvlcdIbf6pwKEk7vHj8/Bkc0B4ylXZruLvOgs9doS5eOsOpuodOV2zJChSpkp+pRpYQLQMeF04nr3Z68Sta9jA==", + "dependencies": { + "css-tree": "^1.1.2" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/csso/node_modules/css-tree": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-1.1.3.tgz", + "integrity": "sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==", + "dependencies": { + "mdn-data": "2.0.14", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/csso/node_modules/mdn-data": { + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.14.tgz", + "integrity": "sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==" + }, + "node_modules/csso/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/cssom": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.4.4.tgz", + "integrity": "sha512-p3pvU7r1MyyqbTk+WbNJIgJjG2VmTIaB10rI93LzVPrmDJKkzKYMtxxyAvQXR/NS6otuzveI7+7BBq3SjBS2mw==" + }, + "node_modules/cssstyle": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-2.3.0.tgz", + "integrity": "sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A==", + "dependencies": { + "cssom": "~0.3.6" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cssstyle/node_modules/cssom": { + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.8.tgz", + "integrity": "sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==" + }, + "node_modules/csstype": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.1.tgz", + "integrity": "sha512-DJR/VvkAvSZW9bTouZue2sSxDwdTN92uHjqeKVm+0dAqdfNykRzQ95tay8aXMBAAPpUiq4Qcug2L7neoRh2Egw==" + }, + "node_modules/custom-event": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/custom-event/-/custom-event-1.0.1.tgz", + "integrity": "sha512-GAj5FOq0Hd+RsCGVJxZuKaIDXDf3h6GQoNEjFgbLLI/trgtavwUbSnZ5pVfg27DVCaWjIohryS0JFwIJyT2cMg==" + }, + "node_modules/damerau-levenshtein": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz", + "integrity": "sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==" + }, + "node_modules/data-urls": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-2.0.0.tgz", + "integrity": "sha512-X5eWTSXO/BJmpdIKCRuKUgSCgAN0OwliVK3yPKbwIWU1Tdw5BRajxlzMidvh+gwko9AfQ9zIj52pzF91Q3YAvQ==", + "dependencies": { + "abab": "^2.0.3", + "whatwg-mimetype": "^2.3.0", + "whatwg-url": "^8.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decimal.js": { + "version": "10.4.3", + "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.4.3.tgz", + "integrity": "sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA==" + }, + "node_modules/dedent": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz", + "integrity": "sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA==" + }, + "node_modules/deep-equal": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-2.1.0.tgz", + "integrity": "sha512-2pxgvWu3Alv1PoWEyVg7HS8YhGlUFUV7N5oOvfL6d+7xAmLSemMwv/c8Zv/i9KFzxV5Kt5CAvQc70fLwVuf4UA==", + "dependencies": { + "call-bind": "^1.0.2", + "es-get-iterator": "^1.1.2", + "get-intrinsic": "^1.1.3", + "is-arguments": "^1.1.1", + "is-date-object": "^1.0.5", + "is-regex": "^1.1.4", + "isarray": "^2.0.5", + "object-is": "^1.1.5", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "side-channel": "^1.0.4", + "which-boxed-primitive": "^1.0.2", + "which-collection": "^1.0.1", + "which-typed-array": "^1.1.8" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/deep-equal/node_modules/isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==" + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==" + }, + "node_modules/deepmerge": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz", + "integrity": "sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/default-gateway": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/default-gateway/-/default-gateway-6.0.3.tgz", + "integrity": "sha512-fwSOJsbbNzZ/CUFpqFBqYfYNLj1NbMPm8MMCIzHjC83iSJRBEGmDUxU+WP661BaBQImeC2yHwXtz+P/O9o+XEg==", + "dependencies": { + "execa": "^5.0.0" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/define-lazy-prop": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz", + "integrity": "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==", + "engines": { + "node": ">=8" + } + }, + "node_modules/define-properties": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.4.tgz", + "integrity": "sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA==", + "dependencies": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/defined": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.1.tgz", + "integrity": "sha512-hsBd2qSVCRE+5PmNdHt1uzyrFu5d3RwmFDKzyNZMFq/EwDNJF7Ee5+D5oEKF0hU6LhtoUF1macFvOe4AskQC1Q==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", + "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/detect-newline": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", + "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", + "engines": { + "node": ">=8" + } + }, + "node_modules/detect-node": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz", + "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==" + }, + "node_modules/detect-port-alt": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/detect-port-alt/-/detect-port-alt-1.1.6.tgz", + "integrity": "sha512-5tQykt+LqfJFBEYaDITx7S7cR7mJ/zQmLXZ2qt5w04ainYZw6tBf9dBunMjVeVOdYVRUzUOE4HkY5J7+uttb5Q==", + "dependencies": { + "address": "^1.0.1", + "debug": "^2.6.0" + }, + "bin": { + "detect": "bin/detect-port", + "detect-port": "bin/detect-port" + }, + "engines": { + "node": ">= 4.2.1" + } + }, + "node_modules/detect-port-alt/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/detect-port-alt/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/detective": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/detective/-/detective-5.2.1.tgz", + "integrity": "sha512-v9XE1zRnz1wRtgurGu0Bs8uHKFSTdteYZNbIPFVhUZ39L/S79ppMpdmVOZAnoz1jfEFodc48n6MX483Xo3t1yw==", + "dependencies": { + "acorn-node": "^1.8.2", + "defined": "^1.0.0", + "minimist": "^1.2.6" + }, + "bin": { + "detective": "bin/detective.js" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/diagram-js": { + "version": "11.4.1", + "resolved": "https://registry.npmjs.org/diagram-js/-/diagram-js-11.4.1.tgz", + "integrity": "sha512-JYVNwoGZY1Zi/2LoXpPUBLu9dGgEzWNqK4yH6nnGNDfqrtfALK3RaMXFMVrKdmX5XV/DmSMf4qFpu/U/8s7VDw==", + "dependencies": { + "@bpmn-io/diagram-js-ui": "^0.2.0", + "clsx": "^1.2.1", + "css.escape": "^1.5.1", + "didi": "^9.0.0", + "hammerjs": "^2.0.1", + "inherits-browser": "^0.1.0", + "min-dash": "^4.0.0", + "min-dom": "^4.0.2", + "object-refs": "^0.3.0", + "path-intersection": "^2.2.1", + "tiny-svg": "^3.0.0" + } + }, + "node_modules/diagram-js-direct-editing": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/diagram-js-direct-editing/-/diagram-js-direct-editing-2.0.0.tgz", + "integrity": "sha512-/12OWL0B0RMCfaT1w3723c729MD42r5fay4wtm2DvxNFNBMdPaEvOHCTA/khLKjFzOzMVKxSzbAp7IEwBGonVw==", + "dependencies": { + "min-dash": "^4.0.0", + "min-dom": "^4.0.2" + }, + "peerDependencies": { + "diagram-js": "*" + } + }, + "node_modules/didi": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/didi/-/didi-9.0.0.tgz", + "integrity": "sha512-bOZ7WAah3t8TxKV81pbIivHjWyABot49YXG1M3QztnUlZDHz3MRNJ1nZO87JbqrkqNI/2GR4ncHfXdGIP9LX+w==" + }, + "node_modules/didyoumean": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz", + "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==" + }, + "node_modules/diff-sequences": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-27.5.1.tgz", + "integrity": "sha512-k1gCAXAsNgLwEL+Y8Wvl+M6oEFj5bgazfZULpS5CneoPPXRaCCW7dm+q21Ky2VEE5X+VeRDBVg1Pcvvsr4TtNQ==", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/dlv": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz", + "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==" + }, + "node_modules/dns-equal": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/dns-equal/-/dns-equal-1.0.0.tgz", + "integrity": "sha512-z+paD6YUQsk+AbGCEM4PrOXSss5gd66QfcVBFTKR/HpFL9jCqikS94HYwKww6fQyO7IxrIIyUu+g0Ka9tUS2Cg==" + }, + "node_modules/dns-packet": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/dns-packet/-/dns-packet-5.4.0.tgz", + "integrity": "sha512-EgqGeaBB8hLiHLZtp/IbaDQTL8pZ0+IvwzSHA6d7VyMDM+B9hgddEMa9xjK5oYnw0ci0JQ6g2XCD7/f6cafU6g==", + "dependencies": { + "@leichtgewicht/ip-codec": "^2.0.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/dom-accessibility-api": { + "version": "0.5.14", + "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.14.tgz", + "integrity": "sha512-NMt+m9zFMPZe0JcY9gN224Qvk6qLIdqex29clBvc/y75ZBX9YA9wNK3frsYvu2DI1xcCIwxwnX+TlsJ2DSOADg==" + }, + "node_modules/dom-converter": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/dom-converter/-/dom-converter-0.2.0.tgz", + "integrity": "sha512-gd3ypIPfOMr9h5jIKq8E3sHOTCjeirnl0WK5ZdS1AW0Odt0b1PaWaHdJ4Qk4klv+YB9aJBS7mESXjFoDQPu6DA==", + "dependencies": { + "utila": "~0.4" + } + }, + "node_modules/dom-serializer": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", + "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", + "dependencies": { + "domelementtype": "^2.0.1", + "domhandler": "^4.2.0", + "entities": "^2.0.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/domelementtype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz", + "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ] + }, + "node_modules/domexception": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/domexception/-/domexception-2.0.1.tgz", + "integrity": "sha512-yxJ2mFy/sibVQlu5qHjOkf9J3K6zgmCxgJ94u2EdvDOV09H+32LtRswEcUsmUWN72pVLOEnTSRaIVVzVQgS0dg==", + "dependencies": { + "webidl-conversions": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/domexception/node_modules/webidl-conversions": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-5.0.0.tgz", + "integrity": "sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA==", + "engines": { + "node": ">=8" + } + }, + "node_modules/domhandler": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", + "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", + "dependencies": { + "domelementtype": "^2.2.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/domify": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/domify/-/domify-1.4.1.tgz", + "integrity": "sha512-x18nuiDHMCZGXr4KJSRMf/TWYtiaRo6RX8KN9fEbW54mvbQ6pieUuerC2ahBg+kEp1wycFj8MPUI0WkIOw5E9w==" + }, + "node_modules/domutils": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", + "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", + "dependencies": { + "dom-serializer": "^1.0.1", + "domelementtype": "^2.2.0", + "domhandler": "^4.2.0" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/dot-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz", + "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/dotenv": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-10.0.0.tgz", + "integrity": "sha512-rlBi9d8jpv9Sf1klPjNfFAuWDjKLwTIJJ/VxtoTwIR6hnZxcEOQCZg2oIL3MWBYw5GpUDKOEnND7LXTbIpQ03Q==", + "engines": { + "node": ">=10" + } + }, + "node_modules/dotenv-expand": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-5.1.0.tgz", + "integrity": "sha512-YXQl1DSa4/PQyRfgrv6aoNjhasp/p4qs9FjJ4q4cQk+8m4r6k4ZSiEyytKG8f8W9gi8WsQtIObNmKd+tMzNTmA==" + }, + "node_modules/downloadjs": { + "version": "1.4.7", + "resolved": "https://registry.npmjs.org/downloadjs/-/downloadjs-1.4.7.tgz", + "integrity": "sha512-LN1gO7+u9xjU5oEScGFKvXhYf7Y/empUIIEAGBs1LzUq/rg5duiDrkuH5A2lQGd5jfMOb9X9usDa2oVXwJ0U/Q==" + }, + "node_modules/dragula": { + "version": "3.7.3", + "resolved": "https://registry.npmjs.org/dragula/-/dragula-3.7.3.tgz", + "integrity": "sha512-/rRg4zRhcpf81TyDhaHLtXt6sEywdfpv1cRUMeFFy7DuypH2U0WUL0GTdyAQvXegviT4PJK4KuMmOaIDpICseQ==", + "dependencies": { + "contra": "1.9.4", + "crossvent": "1.5.5" + } + }, + "node_modules/duplexer": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz", + "integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==" + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==" + }, + "node_modules/ejs": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.8.tgz", + "integrity": "sha512-/sXZeMlhS0ArkfX2Aw780gJzXSMPnKjtspYZv+f3NiKLlubezAHDU5+9xz6gd3/NhG3txQCo6xlglmTS+oTGEQ==", + "dependencies": { + "jake": "^10.8.5" + }, + "bin": { + "ejs": "bin/cli.js" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.4.284", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.284.tgz", + "integrity": "sha512-M8WEXFuKXMYMVr45fo8mq0wUrrJHheiKZf6BArTKk9ZBYCKJEOU5H8cdWgDT+qCVZf7Na4lVUaZsA+h6uA9+PA==" + }, + "node_modules/emittery": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.8.1.tgz", + "integrity": "sha512-uDfvUjVrfGJJhymx/kz6prltenw1u7WrCg1oa94zYY8xxVpLLUu045LAT0dhDZdXG58/EpPL/5kA180fQ/qudg==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/emittery?sponsor=1" + } + }, + "node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "node_modules/emojis-list": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz", + "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==", + "engines": { + "node": ">= 4" + } + }, + "node_modules/encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/enhanced-resolve": { + "version": "5.12.0", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.12.0.tgz", + "integrity": "sha512-QHTXI/sZQmko1cbDoNAa3mJ5qhWUUNAq3vR0/YiD379fWQrcfuoX1+HW2S0MTt7XmoPLapdaDKUtelUSPic7hQ==", + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.2.0" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/entities": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", + "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==", + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dependencies": { + "is-arrayish": "^0.2.1" + } + }, + "node_modules/error-stack-parser": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/error-stack-parser/-/error-stack-parser-2.1.4.tgz", + "integrity": "sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ==", + "dependencies": { + "stackframe": "^1.3.4" + } + }, + "node_modules/es-abstract": { + "version": "1.20.5", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.20.5.tgz", + "integrity": "sha512-7h8MM2EQhsCA7pU/Nv78qOXFpD8Rhqd12gYiSJVkrH9+e8VuA8JlPJK/hQjjlLv6pJvx/z1iRFKzYb0XT/RuAQ==", + "dependencies": { + "call-bind": "^1.0.2", + "es-to-primitive": "^1.2.1", + "function-bind": "^1.1.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.1.3", + "get-symbol-description": "^1.0.0", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.3", + "is-callable": "^1.2.7", + "is-negative-zero": "^2.0.2", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.2", + "is-string": "^1.0.7", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.2", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "unbox-primitive": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-array-method-boxes-properly": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz", + "integrity": "sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==" + }, + "node_modules/es-get-iterator": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/es-get-iterator/-/es-get-iterator-1.1.2.tgz", + "integrity": "sha512-+DTO8GYwbMCwbywjimwZMHp8AuYXOS2JZFWoi2AlPOS3ebnII9w/NLpNZtA7A0YLaVDw+O7KFCeoIV7OPvM7hQ==", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.0", + "has-symbols": "^1.0.1", + "is-arguments": "^1.1.0", + "is-map": "^2.0.2", + "is-set": "^2.0.2", + "is-string": "^1.0.5", + "isarray": "^2.0.5" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-get-iterator/node_modules/isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==" + }, + "node_modules/es-module-lexer": { + "version": "0.9.3", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-0.9.3.tgz", + "integrity": "sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==" + }, + "node_modules/es-shim-unscopables": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz", + "integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==", + "dependencies": { + "has": "^1.0.3" + } + }, + "node_modules/es-to-primitive": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", + "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "dependencies": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==" + }, + "node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/escodegen": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.0.0.tgz", + "integrity": "sha512-mmHKys/C8BFUGI+MAWNcSYoORYLMdPzjrknd2Vc+bUsjN5bXcr8EhrNB+UTqfL1y3I9c4fw2ihgtMPQLBRiQxw==", + "dependencies": { + "esprima": "^4.0.1", + "estraverse": "^5.2.0", + "esutils": "^2.0.2", + "optionator": "^0.8.1" + }, + "bin": { + "escodegen": "bin/escodegen.js", + "esgenerate": "bin/esgenerate.js" + }, + "engines": { + "node": ">=6.0" + }, + "optionalDependencies": { + "source-map": "~0.6.1" + } + }, + "node_modules/escodegen/node_modules/levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==", + "dependencies": { + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/escodegen/node_modules/optionator": { + "version": "0.8.3", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz", + "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==", + "dependencies": { + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.6", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "word-wrap": "~1.2.3" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/escodegen/node_modules/prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/escodegen/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "optional": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/escodegen/node_modules/type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==", + "dependencies": { + "prelude-ls": "~1.1.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/eslint": { + "version": "8.30.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.30.0.tgz", + "integrity": "sha512-MGADB39QqYuzEGov+F/qb18r4i7DohCDOfatHaxI2iGlPuC65bwG2gxgO+7DkyL38dRFaRH7RaRAgU6JKL9rMQ==", + "dependencies": { + "@eslint/eslintrc": "^1.4.0", + "@humanwhocodes/config-array": "^0.11.8", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "ajv": "^6.10.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.1.1", + "eslint-utils": "^3.0.0", + "eslint-visitor-keys": "^3.3.0", + "espree": "^9.4.0", + "esquery": "^1.4.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "grapheme-splitter": "^1.0.4", + "ignore": "^5.2.0", + "import-fresh": "^3.0.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-sdsl": "^4.1.4", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.1", + "regexpp": "^3.2.0", + "strip-ansi": "^6.0.1", + "strip-json-comments": "^3.1.0", + "text-table": "^0.2.0" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-config-react-app": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/eslint-config-react-app/-/eslint-config-react-app-7.0.1.tgz", + "integrity": "sha512-K6rNzvkIeHaTd8m/QEh1Zko0KI7BACWkkneSs6s9cKZC/J27X3eZR6Upt1jkmZ/4FK+XUOPPxMEN7+lbUXfSlA==", + "dependencies": { + "@babel/core": "^7.16.0", + "@babel/eslint-parser": "^7.16.3", + "@rushstack/eslint-patch": "^1.1.0", + "@typescript-eslint/eslint-plugin": "^5.5.0", + "@typescript-eslint/parser": "^5.5.0", + "babel-preset-react-app": "^10.0.1", + "confusing-browser-globals": "^1.0.11", + "eslint-plugin-flowtype": "^8.0.3", + "eslint-plugin-import": "^2.25.3", + "eslint-plugin-jest": "^25.3.0", + "eslint-plugin-jsx-a11y": "^6.5.1", + "eslint-plugin-react": "^7.27.1", + "eslint-plugin-react-hooks": "^4.3.0", + "eslint-plugin-testing-library": "^5.0.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "eslint": "^8.0.0" + } + }, + "node_modules/eslint-import-resolver-node": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.6.tgz", + "integrity": "sha512-0En0w03NRVMn9Uiyn8YRPDKvWjxCWkslUEhGNTdGx15RvPJYQ+lbOlqrlNI2vEAs4pDYK4f/HN2TbDmk5TP0iw==", + "dependencies": { + "debug": "^3.2.7", + "resolve": "^1.20.0" + } + }, + "node_modules/eslint-import-resolver-node/node_modules/debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "dependencies": { + "ms": "^2.1.1" + } + }, + "node_modules/eslint-module-utils": { + "version": "2.7.4", + "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.7.4.tgz", + "integrity": "sha512-j4GT+rqzCoRKHwURX7pddtIPGySnX9Si/cgMI5ztrcqOPtk5dDEeZ34CQVPphnqkJytlc97Vuk05Um2mJ3gEQA==", + "dependencies": { + "debug": "^3.2.7" + }, + "engines": { + "node": ">=4" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + } + } + }, + "node_modules/eslint-module-utils/node_modules/debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "dependencies": { + "ms": "^2.1.1" + } + }, + "node_modules/eslint-plugin-flowtype": { + "version": "8.0.3", + "resolved": "https://registry.npmjs.org/eslint-plugin-flowtype/-/eslint-plugin-flowtype-8.0.3.tgz", + "integrity": "sha512-dX8l6qUL6O+fYPtpNRideCFSpmWOUVx5QcaGLVqe/vlDiBSe4vYljDWDETwnyFzpl7By/WVIu6rcrniCgH9BqQ==", + "dependencies": { + "lodash": "^4.17.21", + "string-natural-compare": "^3.0.1" + }, + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "@babel/plugin-syntax-flow": "^7.14.5", + "@babel/plugin-transform-react-jsx": "^7.14.9", + "eslint": "^8.1.0" + } + }, + "node_modules/eslint-plugin-import": { + "version": "2.26.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.26.0.tgz", + "integrity": "sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA==", + "dependencies": { + "array-includes": "^3.1.4", + "array.prototype.flat": "^1.2.5", + "debug": "^2.6.9", + "doctrine": "^2.1.0", + "eslint-import-resolver-node": "^0.3.6", + "eslint-module-utils": "^2.7.3", + "has": "^1.0.3", + "is-core-module": "^2.8.1", + "is-glob": "^4.0.3", + "minimatch": "^3.1.2", + "object.values": "^1.1.5", + "resolve": "^1.22.0", + "tsconfig-paths": "^3.14.1" + }, + "engines": { + "node": ">=4" + }, + "peerDependencies": { + "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8" + } + }, + "node_modules/eslint-plugin-import/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/eslint-plugin-import/node_modules/doctrine": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eslint-plugin-import/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/eslint-plugin-jest": { + "version": "25.7.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-jest/-/eslint-plugin-jest-25.7.0.tgz", + "integrity": "sha512-PWLUEXeeF7C9QGKqvdSbzLOiLTx+bno7/HC9eefePfEb257QFHg7ye3dh80AZVkaa/RQsBB1Q/ORQvg2X7F0NQ==", + "dependencies": { + "@typescript-eslint/experimental-utils": "^5.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + }, + "peerDependencies": { + "@typescript-eslint/eslint-plugin": "^4.0.0 || ^5.0.0", + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "@typescript-eslint/eslint-plugin": { + "optional": true + }, + "jest": { + "optional": true + } + } + }, + "node_modules/eslint-plugin-jsx-a11y": { + "version": "6.6.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.6.1.tgz", + "integrity": "sha512-sXgFVNHiWffBq23uiS/JaP6eVR622DqwB4yTzKvGZGcPq6/yZ3WmOZfuBks/vHWo9GaFOqC2ZK4i6+C35knx7Q==", + "dependencies": { + "@babel/runtime": "^7.18.9", + "aria-query": "^4.2.2", + "array-includes": "^3.1.5", + "ast-types-flow": "^0.0.7", + "axe-core": "^4.4.3", + "axobject-query": "^2.2.0", + "damerau-levenshtein": "^1.0.8", + "emoji-regex": "^9.2.2", + "has": "^1.0.3", + "jsx-ast-utils": "^3.3.2", + "language-tags": "^1.0.5", + "minimatch": "^3.1.2", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=4.0" + }, + "peerDependencies": { + "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8" + } + }, + "node_modules/eslint-plugin-jsx-a11y/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/eslint-plugin-react": { + "version": "7.31.11", + "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.31.11.tgz", + "integrity": "sha512-TTvq5JsT5v56wPa9OYHzsrOlHzKZKjV+aLgS+55NJP/cuzdiQPC7PfYoUjMoxlffKtvijpk7vA/jmuqRb9nohw==", + "dependencies": { + "array-includes": "^3.1.6", + "array.prototype.flatmap": "^1.3.1", + "array.prototype.tosorted": "^1.1.1", + "doctrine": "^2.1.0", + "estraverse": "^5.3.0", + "jsx-ast-utils": "^2.4.1 || ^3.0.0", + "minimatch": "^3.1.2", + "object.entries": "^1.1.6", + "object.fromentries": "^2.0.6", + "object.hasown": "^1.1.2", + "object.values": "^1.1.6", + "prop-types": "^15.8.1", + "resolve": "^2.0.0-next.3", + "semver": "^6.3.0", + "string.prototype.matchall": "^4.0.8" + }, + "engines": { + "node": ">=4" + }, + "peerDependencies": { + "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8" + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.0.tgz", + "integrity": "sha512-oFc7Itz9Qxh2x4gNHStv3BqJq54ExXmfC+a1NjAta66IAN87Wu0R/QArgIS9qKzX3dXKPI9H5crl9QchNMY9+g==", + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0" + } + }, + "node_modules/eslint-plugin-react/node_modules/doctrine": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eslint-plugin-react/node_modules/resolve": { + "version": "2.0.0-next.4", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.4.tgz", + "integrity": "sha512-iMDbmAWtfU+MHpxt/I5iWI7cY6YVEZUQ3MBgPQ++XD1PELuJHIl82xBmObyP2KyQmkNB2dsqF7seoQQiAn5yDQ==", + "dependencies": { + "is-core-module": "^2.9.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/eslint-plugin-react/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/eslint-plugin-testing-library": { + "version": "5.9.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-testing-library/-/eslint-plugin-testing-library-5.9.1.tgz", + "integrity": "sha512-6BQp3tmb79jLLasPHJmy8DnxREe+2Pgf7L+7o09TSWPfdqqtQfRZmZNetr5mOs3yqZk/MRNxpN3RUpJe0wB4LQ==", + "dependencies": { + "@typescript-eslint/utils": "^5.13.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0", + "npm": ">=6" + }, + "peerDependencies": { + "eslint": "^7.5.0 || ^8.0.0" + } + }, + "node_modules/eslint-scope": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz", + "integrity": "sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/eslint-utils": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-3.0.0.tgz", + "integrity": "sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==", + "dependencies": { + "eslint-visitor-keys": "^2.0.0" + }, + "engines": { + "node": "^10.0.0 || ^12.0.0 || >= 14.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/mysticatea" + }, + "peerDependencies": { + "eslint": ">=5" + } + }, + "node_modules/eslint-utils/node_modules/eslint-visitor-keys": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz", + "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==", + "engines": { + "node": ">=10" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz", + "integrity": "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/eslint-webpack-plugin": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/eslint-webpack-plugin/-/eslint-webpack-plugin-3.2.0.tgz", + "integrity": "sha512-avrKcGncpPbPSUHX6B3stNGzkKFto3eL+DKM4+VyMrVnhPc3vRczVlCq3uhuFOdRvDHTVXuzwk1ZKUrqDQHQ9w==", + "dependencies": { + "@types/eslint": "^7.29.0 || ^8.4.1", + "jest-worker": "^28.0.2", + "micromatch": "^4.0.5", + "normalize-path": "^3.0.0", + "schema-utils": "^4.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0", + "webpack": "^5.0.0" + } + }, + "node_modules/eslint-webpack-plugin/node_modules/ajv": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz", + "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/eslint-webpack-plugin/node_modules/ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/eslint-webpack-plugin/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/eslint-webpack-plugin/node_modules/jest-worker": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-28.1.3.tgz", + "integrity": "sha512-CqRA220YV/6jCo8VWvAt1KKx6eek1VIHMPeLEbpcfSfkEeWyBNppynM/o6q+Wmw+sOhos2ml34wZbSX3G13//g==", + "dependencies": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/eslint-webpack-plugin/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + }, + "node_modules/eslint-webpack-plugin/node_modules/schema-utils": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", + "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", + "dependencies": { + "@types/json-schema": "^7.0.9", + "ajv": "^8.8.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/eslint-webpack-plugin/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/eslint/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/eslint/node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + }, + "node_modules/eslint/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/eslint/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/eslint/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/eslint/node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/globals": { + "version": "13.19.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.19.0.tgz", + "integrity": "sha512-dkQ957uSRWHw7CFXLUtUHQI3g3aWApYhfNR2O6jn/907riyTYKVBmxYVROkBcY614FSSeSJh7Xm7SrUWCxvJMQ==", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/eslint/node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/eslint/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/eslint/node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/espree": { + "version": "9.4.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.4.1.tgz", + "integrity": "sha512-XwctdmTO6SIvCzd9810yyNzIrOrqNYV9Koizx4C/mRhf9uq0o4yHoCEU/670pOxOL/MSraektvSAji79kX90Vg==", + "dependencies": { + "acorn": "^8.8.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/esquery": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.4.0.tgz", + "integrity": "sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estree-walker": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-1.0.1.tgz", + "integrity": "sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==" + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==" + }, + "node_modules/events": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", + "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", + "engines": { + "node": ">=0.8.x" + } + }, + "node_modules/execa": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", + "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==", + "dependencies": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.0", + "human-signals": "^2.1.0", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.1", + "onetime": "^5.1.2", + "signal-exit": "^3.0.3", + "strip-final-newline": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/exit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", + "integrity": "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/expect": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/expect/-/expect-27.5.1.tgz", + "integrity": "sha512-E1q5hSUG2AmYQwQJ041nvgpkODHQvB+RKlB4IYdru6uJsyFTRyZAP463M+1lINorwbqAmUggi6+WwkD8lCS/Dw==", + "dependencies": { + "@jest/types": "^27.5.1", + "jest-get-type": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/express": { + "version": "4.18.2", + "resolved": "https://registry.npmjs.org/express/-/express-4.18.2.tgz", + "integrity": "sha512-5/PsL6iGPdfQ/lKM1UuielYgv3BUoJfz1aUwU9vHZ+J7gyvwdQXFEBIEIaxeGf0GIcreATNyBExtalisDbuMqQ==", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "1.20.1", + "content-disposition": "0.5.4", + "content-type": "~1.0.4", + "cookie": "0.5.0", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.2.0", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "merge-descriptors": "1.0.1", + "methods": "~1.1.2", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "0.1.7", + "proxy-addr": "~2.0.7", + "qs": "6.11.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "0.18.0", + "serve-static": "1.15.0", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + } + }, + "node_modules/express/node_modules/array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==" + }, + "node_modules/express/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/express/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==" + }, + "node_modules/fast-glob": { + "version": "3.2.12", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz", + "integrity": "sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.4" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==" + }, + "node_modules/fastq": { + "version": "1.14.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.14.0.tgz", + "integrity": "sha512-eR2D+V9/ExcbF9ls441yIuN6TI2ED1Y2ZcA5BmMtJsOkWOFRJQ0Jt0g1UwqXJJVAb+V+umH5Dfr8oh4EVP7VVg==", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/faye-websocket": { + "version": "0.11.4", + "resolved": "https://registry.npmjs.org/faye-websocket/-/faye-websocket-0.11.4.tgz", + "integrity": "sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==", + "dependencies": { + "websocket-driver": ">=0.5.1" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/fb-watchman": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz", + "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==", + "dependencies": { + "bser": "2.1.1" + } + }, + "node_modules/feelin": { + "version": "0.41.0", + "resolved": "https://registry.npmjs.org/feelin/-/feelin-0.41.0.tgz", + "integrity": "sha512-jJTJ1xIGl/hkEuuLffgt1LCMd1mSi5w0Sa0wyrfY7aYoFkb369s7LHhfW8vb6hL/khzl8XBWBKhpC7augKgy1A==", + "dependencies": { + "@lezer/lr": "^1.2.0", + "lezer-feel": "^0.13.0", + "luxon": "^3.0.1" + } + }, + "node_modules/feelin/node_modules/lezer-feel": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/lezer-feel/-/lezer-feel-0.13.1.tgz", + "integrity": "sha512-IDN3H/364fgOTKdhgLTv5gGkciWGT19BEBR2nJpr8V63S6srCXnLGtMA3WmDb1qSOmfvEOE6v9eDl28SECcCcg==", + "dependencies": { + "@lezer/highlight": "^1.0.0", + "@lezer/lr": "^1.2.3" + } + }, + "node_modules/file-drops": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/file-drops/-/file-drops-0.4.0.tgz", + "integrity": "sha512-dPLRxrQ/sWHyU1DMf72doyyFuqeR/T8hJ97coJHXmdeHvqMTdOMJ/PLsHKjQzDHC8TBQO0rDUinDEXz3WGTnQA==", + "dependencies": { + "min-dom": "^3.1.1" + } + }, + "node_modules/file-drops/node_modules/min-dash": { + "version": "3.8.1", + "resolved": "https://registry.npmjs.org/min-dash/-/min-dash-3.8.1.tgz", + "integrity": "sha512-evumdlmIlg9mbRVPbC4F5FuRhNmcMS5pvuBUbqb1G9v09Ro0ImPEgz5n3khir83lFok1inKqVDjnKEg3GpDxQg==" + }, + "node_modules/file-drops/node_modules/min-dom": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/min-dom/-/min-dom-3.2.1.tgz", + "integrity": "sha512-v6YCmnDzxk4rRJntWTUiwggLupPw/8ZSRqUq0PDaBwVZEO/wYzCH4SKVBV+KkEvf3u0XaWHly5JEosPtqRATZA==", + "dependencies": { + "component-event": "^0.1.4", + "domify": "^1.3.1", + "indexof": "0.0.1", + "matches-selector": "^1.2.0", + "min-dash": "^3.8.1" + } + }, + "node_modules/file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dependencies": { + "flat-cache": "^3.0.4" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/file-loader": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/file-loader/-/file-loader-6.2.0.tgz", + "integrity": "sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==", + "dependencies": { + "loader-utils": "^2.0.0", + "schema-utils": "^3.0.0" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^4.0.0 || ^5.0.0" + } + }, + "node_modules/filelist": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.4.tgz", + "integrity": "sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==", + "dependencies": { + "minimatch": "^5.0.1" + } + }, + "node_modules/filelist/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/filelist/node_modules/minimatch": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.2.tgz", + "integrity": "sha512-bNH9mmM9qsJ2X4r2Nat1B//1dJVcn3+iBLa3IgqJ7EbGaDNepL9QSHOxN4ng33s52VMMhhIfgCYDk3C4ZmlDAg==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/filesize": { + "version": "8.0.7", + "resolved": "https://registry.npmjs.org/filesize/-/filesize-8.0.7.tgz", + "integrity": "sha512-pjmC+bkIF8XI7fWaH8KxHcZL3DPybs1roSKP4rKDvy20tAWwIObE4+JIseG2byfGKhud5ZnM4YSGKBz7Sh0ndQ==", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/finalhandler": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz", + "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "statuses": "2.0.1", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/finalhandler/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/finalhandler/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/find-cache-dir": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-3.3.2.tgz", + "integrity": "sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==", + "dependencies": { + "commondir": "^1.0.1", + "make-dir": "^3.0.2", + "pkg-dir": "^4.1.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/avajs/find-cache-dir?sponsor=1" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz", + "integrity": "sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==", + "dependencies": { + "flatted": "^3.1.0", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/flatpickr": { + "version": "4.6.13", + "resolved": "https://registry.npmjs.org/flatpickr/-/flatpickr-4.6.13.tgz", + "integrity": "sha512-97PMG/aywoYpB4IvbvUJi0RQi8vearvU0oov1WW3k0WZPBMrTQVqekSX5CjSG/M4Q3i6A/0FKXC7RyAoAUUSPw==" + }, + "node_modules/flatted": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz", + "integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==" + }, + "node_modules/follow-redirects": { + "version": "1.15.2", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz", + "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dependencies": { + "is-callable": "^1.1.3" + } + }, + "node_modules/fork-ts-checker-webpack-plugin": { + "version": "6.5.2", + "resolved": "https://registry.npmjs.org/fork-ts-checker-webpack-plugin/-/fork-ts-checker-webpack-plugin-6.5.2.tgz", + "integrity": "sha512-m5cUmF30xkZ7h4tWUgTAcEaKmUW7tfyUyTqNNOz7OxWJ0v1VWKTcOvH8FWHUwSjlW/356Ijc9vi3XfcPstpQKA==", + "dependencies": { + "@babel/code-frame": "^7.8.3", + "@types/json-schema": "^7.0.5", + "chalk": "^4.1.0", + "chokidar": "^3.4.2", + "cosmiconfig": "^6.0.0", + "deepmerge": "^4.2.2", + "fs-extra": "^9.0.0", + "glob": "^7.1.6", + "memfs": "^3.1.2", + "minimatch": "^3.0.4", + "schema-utils": "2.7.0", + "semver": "^7.3.2", + "tapable": "^1.0.0" + }, + "engines": { + "node": ">=10", + "yarn": ">=1.0.0" + }, + "peerDependencies": { + "eslint": ">= 6", + "typescript": ">= 2.7", + "vue-template-compiler": "*", + "webpack": ">= 4" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + }, + "vue-template-compiler": { + "optional": true + } + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/cosmiconfig": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-6.0.0.tgz", + "integrity": "sha512-xb3ZL6+L8b9JLLCx3ZdoZy4+2ECphCMo2PwqgP1tlfVq6M6YReyzBJtvWWtbDSpNr9hn96pkCiZqUcFEc+54Qg==", + "dependencies": { + "@types/parse-json": "^4.0.0", + "import-fresh": "^3.1.0", + "parse-json": "^5.0.0", + "path-type": "^4.0.0", + "yaml": "^1.7.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/schema-utils": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.0.tgz", + "integrity": "sha512-0ilKFI6QQF5nxDZLFn2dMjvc4hjg/Wkg7rHd3jK6/A4a1Hl9VFdQWvgB1UMGoU94pad1P/8N7fMcEnLnSiju8A==", + "dependencies": { + "@types/json-schema": "^7.0.4", + "ajv": "^6.12.2", + "ajv-keywords": "^3.4.1" + }, + "engines": { + "node": ">= 8.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/tapable": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-1.1.3.tgz", + "integrity": "sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==", + "engines": { + "node": ">=6" + } + }, + "node_modules/form-data": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-3.0.1.tgz", + "integrity": "sha512-RHkBKtLWUVwd7SqRIvCZMEvAMoGUp0XU+seQiZejj0COz3RI3hWP4sCv3gZWWLjJTd7rGwcsF5eKZGii0r/hbg==", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fraction.js": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.2.0.tgz", + "integrity": "sha512-MhLuK+2gUcnZe8ZHlaaINnQLl0xRIGRfcGk2yl8xoQAfHrSsL3rYu6FCmBdkdbhc9EPlwyGHewaRsvwRMJtAlA==", + "engines": { + "node": "*" + }, + "funding": { + "type": "patreon", + "url": "https://www.patreon.com/infusion" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/fs-monkey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/fs-monkey/-/fs-monkey-1.0.3.tgz", + "integrity": "sha512-cybjIfiiE+pTWicSCLFHSrXZ6EilF30oh91FDP9S2B051prEa7QWfrVTQm10/dDpswBDXZugPa1Ogu8Yh+HV0Q==" + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==" + }, + "node_modules/fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==" + }, + "node_modules/function.prototype.name": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", + "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "es-abstract": "^1.19.0", + "functions-have-names": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/functions-have-names": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", + "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.3.tgz", + "integrity": "sha512-QJVz1Tj7MS099PevUG5jvnt9tSkXN8K14dxQlikJuPt4uD9hHAHjLyLBiLR5zELelBdD9QNRAXZzsJx0WaDL9A==", + "dependencies": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-own-enumerable-property-symbols": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz", + "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==" + }, + "node_modules/get-package-type": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", + "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/get-symbol-description": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", + "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/glob-to-regexp": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz", + "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==" + }, + "node_modules/global-modules": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz", + "integrity": "sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==", + "dependencies": { + "global-prefix": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/global-prefix": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-3.0.0.tgz", + "integrity": "sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==", + "dependencies": { + "ini": "^1.3.5", + "kind-of": "^6.0.2", + "which": "^1.3.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/global-prefix/node_modules/which": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "which": "bin/which" + } + }, + "node_modules/globals": { + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", + "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "engines": { + "node": ">=4" + } + }, + "node_modules/globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "dependencies": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dependencies": { + "get-intrinsic": "^1.1.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.10", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", + "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==" + }, + "node_modules/grapheme-splitter": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz", + "integrity": "sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==" + }, + "node_modules/graphql": { + "version": "16.6.0", + "resolved": "https://registry.npmjs.org/graphql/-/graphql-16.6.0.tgz", + "integrity": "sha512-KPIBPDlW7NxrbT/eh4qPXz5FiFdL5UbaA0XUNz2Rp3Z3hqBSkbj0GVjwFDztsWVauZUWsbKHgMg++sk8UX0bkw==", + "engines": { + "node": "^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0" + } + }, + "node_modules/graphql-tag": { + "version": "2.12.6", + "resolved": "https://registry.npmjs.org/graphql-tag/-/graphql-tag-2.12.6.tgz", + "integrity": "sha512-FdSNcu2QQcWnM2VNvSCCDCVS5PpPqpzgFT8+GXzqJuoDd0CBncxCY278u4mhRO7tMgo2JjgJA5aZ+nWSQ/Z+xg==", + "dependencies": { + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "graphql": "^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0" + } + }, + "node_modules/gzip-size": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/gzip-size/-/gzip-size-6.0.0.tgz", + "integrity": "sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==", + "dependencies": { + "duplexer": "^0.1.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/hammerjs": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/hammerjs/-/hammerjs-2.0.8.tgz", + "integrity": "sha512-tSQXBXS/MWQOn/RKckawJ61vvsDpCom87JgxiYdGwHdOa0ht0vzUWDlfioofFCRU0L+6NGDt6XzbgoJvZkMeRQ==", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/handle-thing": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/handle-thing/-/handle-thing-2.0.1.tgz", + "integrity": "sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg==" + }, + "node_modules/harmony-reflect": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/harmony-reflect/-/harmony-reflect-1.6.2.tgz", + "integrity": "sha512-HIp/n38R9kQjDEziXyDTuW3vvoxxyxjxFzXLrBr18uB47GnSt+G9D29fqrpM5ZkspMcPICud3XsBJQ4Y2URg8g==" + }, + "node_modules/has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dependencies": { + "function-bind": "^1.1.1" + }, + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/has-bigints": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", + "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "engines": { + "node": ">=4" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", + "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "dependencies": { + "get-intrinsic": "^1.1.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", + "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "bin": { + "he": "bin/he" + } + }, + "node_modules/hoist-non-react-statics": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz", + "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==", + "dependencies": { + "react-is": "^16.7.0" + } + }, + "node_modules/hoist-non-react-statics/node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==" + }, + "node_modules/hoopy": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/hoopy/-/hoopy-0.1.4.tgz", + "integrity": "sha512-HRcs+2mr52W0K+x8RzcLzuPPmVIKMSv97RGHy0Ea9y/mpcaK+xTrjICA04KAHi4GRzxliNqNJEFYWHghy3rSfQ==", + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/hpack.js": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/hpack.js/-/hpack.js-2.1.6.tgz", + "integrity": "sha512-zJxVehUdMGIKsRaNt7apO2Gqp0BdqW5yaiGHXXmbpvxgBYVZnAql+BJb4RO5ad2MgpbZKn5G6nMnegrH1FcNYQ==", + "dependencies": { + "inherits": "^2.0.1", + "obuf": "^1.0.0", + "readable-stream": "^2.0.1", + "wbuf": "^1.1.0" + } + }, + "node_modules/hpack.js/node_modules/readable-stream": { + "version": "2.3.7", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", + "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==", + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "node_modules/hpack.js/node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" + }, + "node_modules/hpack.js/node_modules/string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/htm": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/htm/-/htm-3.1.1.tgz", + "integrity": "sha512-983Vyg8NwUE7JkZ6NmOqpCZ+sh1bKv2iYTlUkzlWmA5JD2acKoxd4KVxbMmxX/85mtfdnDmTFoNKcg5DGAvxNQ==" + }, + "node_modules/html-encoding-sniffer": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-2.0.1.tgz", + "integrity": "sha512-D5JbOMBIR/TVZkubHT+OyT2705QvogUW4IBn6nHd756OwieSF9aDYFj4dv6HHEVGYbHaLETa3WggZYWWMyy3ZQ==", + "dependencies": { + "whatwg-encoding": "^1.0.5" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/html-entities": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.3.3.tgz", + "integrity": "sha512-DV5Ln36z34NNTDgnz0EWGBLZENelNAtkiFA4kyNOG2tDI6Mz1uSWiq1wAKdyjnJwyDiDO7Fa2SO1CTxPXL8VxA==" + }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==" + }, + "node_modules/html-minifier-terser": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz", + "integrity": "sha512-YXxSlJBZTP7RS3tWnQw74ooKa6L9b9i9QYXY21eUEvhZ3u9XLfv6OnFsQq6RxkhHygsaUMvYsZRV5rU/OVNZxw==", + "dependencies": { + "camel-case": "^4.1.2", + "clean-css": "^5.2.2", + "commander": "^8.3.0", + "he": "^1.2.0", + "param-case": "^3.0.4", + "relateurl": "^0.2.7", + "terser": "^5.10.0" + }, + "bin": { + "html-minifier-terser": "cli.js" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/html-webpack-plugin": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.5.0.tgz", + "integrity": "sha512-sy88PC2cRTVxvETRgUHFrL4No3UxvcH8G1NepGhqaTT+GXN2kTamqasot0inS5hXeg1cMbFDt27zzo9p35lZVw==", + "dependencies": { + "@types/html-minifier-terser": "^6.0.0", + "html-minifier-terser": "^6.0.2", + "lodash": "^4.17.21", + "pretty-error": "^4.0.0", + "tapable": "^2.0.0" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/html-webpack-plugin" + }, + "peerDependencies": { + "webpack": "^5.20.0" + } + }, + "node_modules/htmlparser2": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz", + "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==", + "funding": [ + "https://github.com/fb55/htmlparser2?sponsor=1", + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "dependencies": { + "domelementtype": "^2.0.1", + "domhandler": "^4.0.0", + "domutils": "^2.5.2", + "entities": "^2.0.0" + } + }, + "node_modules/http-deceiver": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/http-deceiver/-/http-deceiver-1.2.7.tgz", + "integrity": "sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw==" + }, + "node_modules/http-errors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", + "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "dependencies": { + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/http-parser-js": { + "version": "0.5.8", + "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.8.tgz", + "integrity": "sha512-SGeBX54F94Wgu5RH3X5jsDtf4eHyRogWX1XGT3b4HuW3tQPM4AaBzoUji/4AAJNXCEOWZ5O0DgZmJw1947gD5Q==" + }, + "node_modules/http-proxy": { + "version": "1.18.1", + "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz", + "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==", + "dependencies": { + "eventemitter3": "^4.0.0", + "follow-redirects": "^1.0.0", + "requires-port": "^1.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/http-proxy-agent": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-4.0.1.tgz", + "integrity": "sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==", + "dependencies": { + "@tootallnate/once": "1", + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/http-proxy-middleware": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.6.tgz", + "integrity": "sha512-ya/UeJ6HVBYxrgYotAZo1KvPWlgB48kUJLDePFeneHsVujFaW5WNj2NgWCAE//B1Dl02BIfYlpNgBy8Kf8Rjmw==", + "dependencies": { + "@types/http-proxy": "^1.17.8", + "http-proxy": "^1.18.1", + "is-glob": "^4.0.1", + "is-plain-obj": "^3.0.0", + "micromatch": "^4.0.2" + }, + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "@types/express": "^4.17.13" + }, + "peerDependenciesMeta": { + "@types/express": { + "optional": true + } + } + }, + "node_modules/https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "dependencies": { + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/human-signals": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", + "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", + "engines": { + "node": ">=10.17.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/icss-utils": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-5.1.0.tgz", + "integrity": "sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==", + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/idb": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/idb/-/idb-7.1.1.tgz", + "integrity": "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ==" + }, + "node_modules/identity-obj-proxy": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/identity-obj-proxy/-/identity-obj-proxy-3.0.0.tgz", + "integrity": "sha512-00n6YnVHKrinT9t0d9+5yZC6UBNJANpYEQvL2LlX6Ab9lnmxzIRcEmTPuyGScvl1+jKuCICX1Z0Ab1pPKKdikA==", + "dependencies": { + "harmony-reflect": "^1.4.6" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/ids": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/ids/-/ids-1.0.0.tgz", + "integrity": "sha512-Zvtq1xUto4LttpstyOlFum8lKx+i1OmRfg+6A9drFS9iSZsDPMHG4Sof/qwNR4kCU7jBeWFPrY2ocHxiz7cCRw==" + }, + "node_modules/ignore": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", + "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", + "engines": { + "node": ">= 4" + } + }, + "node_modules/immer": { + "version": "9.0.16", + "resolved": "https://registry.npmjs.org/immer/-/immer-9.0.16.tgz", + "integrity": "sha512-qenGE7CstVm1NrHQbMh8YaSzTZTFNP3zPqr3YU0S0UY441j4bJTg4A2Hh5KAhwgaiU6ZZ1Ar6y/2f4TblnMReQ==", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/immer" + } + }, + "node_modules/import-fresh": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", + "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-fresh/node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "engines": { + "node": ">=4" + } + }, + "node_modules/import-local": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz", + "integrity": "sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==", + "dependencies": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + }, + "bin": { + "import-local-fixture": "fixtures/cli.js" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "engines": { + "node": ">=8" + } + }, + "node_modules/indexof": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz", + "integrity": "sha512-i0G7hLJ1z0DE8dsqJa2rycj9dBmNKgXBvotXtZYXakU9oivfB9Uj2ZBC27qqef2U58/ZLwalxa1X/RDCdkHtVg==" + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "node_modules/inherits-browser": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/inherits-browser/-/inherits-browser-0.1.0.tgz", + "integrity": "sha512-CJHHvW3jQ6q7lzsXPpapLdMx5hDpSF3FSh45pwsj6bKxJJ8Nl8v43i5yXnr3BdfOimGHKyniewQtnAIp3vyJJw==" + }, + "node_modules/ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==" + }, + "node_modules/internal-slot": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.4.tgz", + "integrity": "sha512-tA8URYccNzMo94s5MQZgH8NB/XTa6HsOo0MLfXTKKEnHVVdegzaQoFZ7Jp44bdvLvY2waT5dc+j5ICEswhi7UQ==", + "dependencies": { + "get-intrinsic": "^1.1.3", + "has": "^1.0.3", + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ipaddr.js": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.0.1.tgz", + "integrity": "sha512-1qTgH9NG+IIJ4yfKs2e6Pp1bZg8wbDbKHT21HrLIeYBTRLgMYKnMTPAuI3Lcs61nfx5h1xlXnbJtH1kX5/d/ng==", + "engines": { + "node": ">= 10" + } + }, + "node_modules/is-arguments": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.1.tgz", + "integrity": "sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==", + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==" + }, + "node_modules/is-bigint": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", + "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "dependencies": { + "has-bigints": "^1.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-boolean-object": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", + "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-core-module": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz", + "integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==", + "dependencies": { + "has": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-date-object": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", + "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-docker": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz", + "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==", + "bin": { + "is-docker": "cli.js" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-generator-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz", + "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==", + "engines": { + "node": ">=6" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-map": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.2.tgz", + "integrity": "sha512-cOZFQQozTha1f4MxLFzlgKYPTyj26picdZTx82hbc/Xf4K/tZOOXSCkMvU4pKioRXGDLJRn0GM7Upe7kR721yg==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz", + "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==" + }, + "node_modules/is-negative-zero": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", + "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-number-object": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", + "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz", + "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-plain-obj": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz", + "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-potential-custom-element-name": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz", + "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==" + }, + "node_modules/is-regex": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", + "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-regexp": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz", + "integrity": "sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-root": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-root/-/is-root-2.1.0.tgz", + "integrity": "sha512-AGOriNp96vNBd3HtU+RzFEc75FfR5ymiYv8E553I71SCeXBiMsVDUtdio1OEFvrPyLIQ9tVR5RxXIFe5PUFjMg==", + "engines": { + "node": ">=6" + } + }, + "node_modules/is-set": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.2.tgz", + "integrity": "sha512-+2cnTEZeY5z/iXGbLhPrOAaK/Mau5k5eXq9j14CpRTftq0pAJu2MwVRSZhyZWBzx3o6X795Lz6Bpb6R0GKf37g==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-shared-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", + "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "dependencies": { + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-string": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", + "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-symbol": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", + "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.10.tgz", + "integrity": "sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==", + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==" + }, + "node_modules/is-weakmap": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.1.tgz", + "integrity": "sha512-NSBR4kH5oVj1Uwvv970ruUkCV7O1mzgVFO4/rev2cLRda9Tm9HrL70ZPut4rOHgY0FNrUu9BCbXA2sdQ+x0chA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakref": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", + "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "dependencies": { + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakset": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.2.tgz", + "integrity": "sha512-t2yVvttHkQktwnNNmBQ98AhENLdPUTDTE21uPqAQ0ARwQfGeQKRVS0NNurH7bTf7RrvcVn1OOge45CnBeHCSmg==", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-wsl": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz", + "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==", + "dependencies": { + "is-docker": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==" + }, + "node_modules/istanbul-lib-coverage": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz", + "integrity": "sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-instrument": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz", + "integrity": "sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==", + "dependencies": { + "@babel/core": "^7.12.3", + "@babel/parser": "^7.14.7", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.2.0", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-instrument/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==", + "dependencies": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^3.0.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-source-maps": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz", + "integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==", + "dependencies": { + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-lib-source-maps/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/istanbul-reports": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.5.tgz", + "integrity": "sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w==", + "dependencies": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jake": { + "version": "10.8.5", + "resolved": "https://registry.npmjs.org/jake/-/jake-10.8.5.tgz", + "integrity": "sha512-sVpxYeuAhWt0OTWITwT98oyV0GsXyMlXCF+3L1SuafBVUIr/uILGRB+NqwkzhgXKvoJpDIpQvqkUALgdmQsQxw==", + "dependencies": { + "async": "^3.2.3", + "chalk": "^4.0.2", + "filelist": "^1.0.1", + "minimatch": "^3.0.4" + }, + "bin": { + "jake": "bin/cli.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jake/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jake/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jake/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jake/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jake/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jake/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest/-/jest-27.5.1.tgz", + "integrity": "sha512-Yn0mADZB89zTtjkPJEXwrac3LHudkQMR+Paqa8uxJHCBr9agxztUifWCyiYrjhMPBoUVBjyny0I7XH6ozDr7QQ==", + "dependencies": { + "@jest/core": "^27.5.1", + "import-local": "^3.0.2", + "jest-cli": "^27.5.1" + }, + "bin": { + "jest": "bin/jest.js" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/jest-changed-files": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-27.5.1.tgz", + "integrity": "sha512-buBLMiByfWGCoMsLLzGUUSpAmIAGnbR2KJoMN10ziLhOLvP4e0SlypHnAel8iqQXTrcbmfEY9sSqae5sgUsTvw==", + "dependencies": { + "@jest/types": "^27.5.1", + "execa": "^5.0.0", + "throat": "^6.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-27.5.1.tgz", + "integrity": "sha512-D95R7x5UtlMA5iBYsOHFFbMD/GVA4R/Kdq15f7xYWUfWHBto9NYRsOvnSauTgdF+ogCpJ4tyKOXhUifxS65gdw==", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "co": "^4.6.0", + "dedent": "^0.7.0", + "expect": "^27.5.1", + "is-generator-fn": "^2.0.0", + "jest-each": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-runtime": "^27.5.1", + "jest-snapshot": "^27.5.1", + "jest-util": "^27.5.1", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3", + "throat": "^6.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-circus/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-circus/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-circus/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-circus/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-circus/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-cli": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-27.5.1.tgz", + "integrity": "sha512-Hc6HOOwYq4/74/c62dEE3r5elx8wjYqxY0r0G/nFrLDPMFRu6RA/u8qINOIkvhxG7mMQ5EJsOGfRpI8L6eFUVw==", + "dependencies": { + "@jest/core": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/types": "^27.5.1", + "chalk": "^4.0.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "import-local": "^3.0.2", + "jest-config": "^27.5.1", + "jest-util": "^27.5.1", + "jest-validate": "^27.5.1", + "prompts": "^2.0.1", + "yargs": "^16.2.0" + }, + "bin": { + "jest": "bin/jest.js" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/jest-cli/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-cli/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-cli/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-cli/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-cli/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-cli/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-config": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-27.5.1.tgz", + "integrity": "sha512-5sAsjm6tGdsVbW9ahcChPAFCk4IlkQUknH5AvKjuLTSlcO/wCZKyFdn7Rg0EkC+OGgWODEy2hDpWB1PgzH0JNA==", + "dependencies": { + "@babel/core": "^7.8.0", + "@jest/test-sequencer": "^27.5.1", + "@jest/types": "^27.5.1", + "babel-jest": "^27.5.1", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "deepmerge": "^4.2.2", + "glob": "^7.1.1", + "graceful-fs": "^4.2.9", + "jest-circus": "^27.5.1", + "jest-environment-jsdom": "^27.5.1", + "jest-environment-node": "^27.5.1", + "jest-get-type": "^27.5.1", + "jest-jasmine2": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-runner": "^27.5.1", + "jest-util": "^27.5.1", + "jest-validate": "^27.5.1", + "micromatch": "^4.0.4", + "parse-json": "^5.2.0", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "ts-node": ">=9.0.0" + }, + "peerDependenciesMeta": { + "ts-node": { + "optional": true + } + } + }, + "node_modules/jest-config/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-config/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-config/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-config/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-config/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-config/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-diff": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-27.5.1.tgz", + "integrity": "sha512-m0NvkX55LDt9T4mctTEgnZk3fmEg3NRYutvMPWM/0iPnkFj2wIeF45O1718cMSOFO1vINkqmxqD8vE37uTEbqw==", + "dependencies": { + "chalk": "^4.0.0", + "diff-sequences": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-diff/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-diff/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-diff/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-diff/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-diff/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-diff/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-docblock": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-27.5.1.tgz", + "integrity": "sha512-rl7hlABeTsRYxKiUfpHrQrG4e2obOiTQWfMEH3PxPjOtdsfLQO4ReWSZaQ7DETm4xu07rl4q/h4zcKXyU0/OzQ==", + "dependencies": { + "detect-newline": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-each": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-27.5.1.tgz", + "integrity": "sha512-1Ff6p+FbhT/bXQnEouYy00bkNSY7OUpfIcmdl8vZ31A1UUaurOLPA8a8BbJOF2RDUElwJhmeaV7LnagI+5UwNQ==", + "dependencies": { + "@jest/types": "^27.5.1", + "chalk": "^4.0.0", + "jest-get-type": "^27.5.1", + "jest-util": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-each/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-each/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-each/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-each/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-each/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-each/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-environment-jsdom": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-environment-jsdom/-/jest-environment-jsdom-27.5.1.tgz", + "integrity": "sha512-TFBvkTC1Hnnnrka/fUb56atfDtJ9VMZ94JkjTbggl1PEpwrYtUBKMezB3inLmWqQsXYLcMwNoDQwoBTAvFfsfw==", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/fake-timers": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "jest-mock": "^27.5.1", + "jest-util": "^27.5.1", + "jsdom": "^16.6.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-environment-node": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-27.5.1.tgz", + "integrity": "sha512-Jt4ZUnxdOsTGwSRAfKEnE6BcwsSPNOijjwifq5sDFSA2kesnXTvNqKHYgM0hDq3549Uf/KzdXNYn4wMZJPlFLw==", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/fake-timers": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "jest-mock": "^27.5.1", + "jest-util": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-get-type": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-27.5.1.tgz", + "integrity": "sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-haste-map": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-27.5.1.tgz", + "integrity": "sha512-7GgkZ4Fw4NFbMSDSpZwXeBiIbx+t/46nJ2QitkOjvwPYyZmqttu2TDSimMHP1EkPOi4xUZAN1doE5Vd25H4Jng==", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/graceful-fs": "^4.1.2", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "graceful-fs": "^4.2.9", + "jest-regex-util": "^27.5.1", + "jest-serializer": "^27.5.1", + "jest-util": "^27.5.1", + "jest-worker": "^27.5.1", + "micromatch": "^4.0.4", + "walker": "^1.0.7" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + } + }, + "node_modules/jest-jasmine2": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-jasmine2/-/jest-jasmine2-27.5.1.tgz", + "integrity": "sha512-jtq7VVyG8SqAorDpApwiJJImd0V2wv1xzdheGHRGyuT7gZm6gG47QEskOlzsN1PG/6WNaCo5pmwMHDf3AkG2pQ==", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/source-map": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "co": "^4.6.0", + "expect": "^27.5.1", + "is-generator-fn": "^2.0.0", + "jest-each": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-runtime": "^27.5.1", + "jest-snapshot": "^27.5.1", + "jest-util": "^27.5.1", + "pretty-format": "^27.5.1", + "throat": "^6.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-jasmine2/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-jasmine2/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-jasmine2/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-jasmine2/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-leak-detector": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-27.5.1.tgz", + "integrity": "sha512-POXfWAMvfU6WMUXftV4HolnJfnPOGEu10fscNCA76KBpRRhcMN2c8d3iT2pxQS3HLbA+5X4sOUPzYO2NUyIlHQ==", + "dependencies": { + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-matcher-utils": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-27.5.1.tgz", + "integrity": "sha512-z2uTx/T6LBaCoNWNFWwChLBKYxTMcGBRjAt+2SbP929/Fflb9aa5LGma654Rz8z9HLxsrUaYzxE9T/EFIL/PAw==", + "dependencies": { + "chalk": "^4.0.0", + "jest-diff": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-matcher-utils/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-matcher-utils/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-matcher-utils/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-matcher-utils/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-matcher-utils/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-matcher-utils/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-message-util/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-message-util/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-message-util/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-message-util/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-message-util/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-message-util/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-mock": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-27.5.1.tgz", + "integrity": "sha512-K4jKbY1d4ENhbrG2zuPWaQBvDly+iZ2yAW+T1fATN78hc0sInwn7wZB8XtlNnvHug5RMwV897Xm4LqmPM4e2Og==", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-pnp-resolver": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz", + "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==", + "engines": { + "node": ">=6" + }, + "peerDependencies": { + "jest-resolve": "*" + }, + "peerDependenciesMeta": { + "jest-resolve": { + "optional": true + } + } + }, + "node_modules/jest-regex-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-27.5.1.tgz", + "integrity": "sha512-4bfKq2zie+x16okqDXjXn9ql2B0dScQu+vcwe4TvFVhkVyuWLqpZrZtXxLLWoXYgn0E87I6r6GRYHF7wFZBUvg==", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-resolve": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-27.5.1.tgz", + "integrity": "sha512-FFDy8/9E6CV83IMbDpcjOhumAQPDyETnU2KZ1O98DwTnz8AOBsW/Xv3GySr1mOZdItLR+zDZ7I/UdTFbgSOVCw==", + "dependencies": { + "@jest/types": "^27.5.1", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^27.5.1", + "jest-pnp-resolver": "^1.2.2", + "jest-util": "^27.5.1", + "jest-validate": "^27.5.1", + "resolve": "^1.20.0", + "resolve.exports": "^1.1.0", + "slash": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-resolve-dependencies": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-27.5.1.tgz", + "integrity": "sha512-QQOOdY4PE39iawDn5rzbIePNigfe5B9Z91GDD1ae/xNDlu9kaat8QQ5EKnNmVWPV54hUdxCVwwj6YMgR2O7IOg==", + "dependencies": { + "@jest/types": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-snapshot": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-resolve/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-resolve/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-resolve/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-resolve/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-resolve/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-resolve/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-runner": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-27.5.1.tgz", + "integrity": "sha512-g4NPsM4mFCOwFKXO4p/H/kWGdJp9V8kURY2lX8Me2drgXqG7rrZAx5kv+5H7wtt/cdFIjhqYx1HrlqWHaOvDaQ==", + "dependencies": { + "@jest/console": "^27.5.1", + "@jest/environment": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "emittery": "^0.8.1", + "graceful-fs": "^4.2.9", + "jest-docblock": "^27.5.1", + "jest-environment-jsdom": "^27.5.1", + "jest-environment-node": "^27.5.1", + "jest-haste-map": "^27.5.1", + "jest-leak-detector": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-runtime": "^27.5.1", + "jest-util": "^27.5.1", + "jest-worker": "^27.5.1", + "source-map-support": "^0.5.6", + "throat": "^6.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runner/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-runner/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-runner/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-runner/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-runner/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-runner/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-runtime": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-27.5.1.tgz", + "integrity": "sha512-o7gxw3Gf+H2IGt8fv0RiyE1+r83FJBRruoA+FXrlHw6xEyBsU8ugA6IPfTdVyA0w8HClpbK+DGJxH59UrNMx8A==", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/fake-timers": "^27.5.1", + "@jest/globals": "^27.5.1", + "@jest/source-map": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "chalk": "^4.0.0", + "cjs-module-lexer": "^1.0.0", + "collect-v8-coverage": "^1.0.0", + "execa": "^5.0.0", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-mock": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-snapshot": "^27.5.1", + "jest-util": "^27.5.1", + "slash": "^3.0.0", + "strip-bom": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runtime/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-runtime/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-runtime/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-runtime/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-runtime/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-runtime/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-serializer": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-serializer/-/jest-serializer-27.5.1.tgz", + "integrity": "sha512-jZCyo6iIxO1aqUxpuBlwTDMkzOAJS4a3eYz3YzgxxVQFwLeSA7Jfq5cbqCY+JLvTDrWirgusI/0KwxKMgrdf7w==", + "dependencies": { + "@types/node": "*", + "graceful-fs": "^4.2.9" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-27.5.1.tgz", + "integrity": "sha512-yYykXI5a0I31xX67mgeLw1DZ0bJB+gpq5IpSuCAoyDi0+BhgU/RIrL+RTzDmkNTchvDFWKP8lp+w/42Z3us5sA==", + "dependencies": { + "@babel/core": "^7.7.2", + "@babel/generator": "^7.7.2", + "@babel/plugin-syntax-typescript": "^7.7.2", + "@babel/traverse": "^7.7.2", + "@babel/types": "^7.0.0", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/babel__traverse": "^7.0.4", + "@types/prettier": "^2.1.5", + "babel-preset-current-node-syntax": "^1.0.0", + "chalk": "^4.0.0", + "expect": "^27.5.1", + "graceful-fs": "^4.2.9", + "jest-diff": "^27.5.1", + "jest-get-type": "^27.5.1", + "jest-haste-map": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-util": "^27.5.1", + "natural-compare": "^1.4.0", + "pretty-format": "^27.5.1", + "semver": "^7.3.2" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-snapshot/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-snapshot/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-snapshot/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-snapshot/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-util/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-util/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-util/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-util/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-util/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-util/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-validate": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-27.5.1.tgz", + "integrity": "sha512-thkNli0LYTmOI1tDB3FI1S1RTp/Bqyd9pTarJwL87OIBFuqEb5Apv5EaApEudYg4g86e3CT6kM0RowkhtEnCBQ==", + "dependencies": { + "@jest/types": "^27.5.1", + "camelcase": "^6.2.0", + "chalk": "^4.0.0", + "jest-get-type": "^27.5.1", + "leven": "^3.1.0", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-validate/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-validate/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-validate/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-validate/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-validate/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-validate/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watch-typeahead": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/jest-watch-typeahead/-/jest-watch-typeahead-1.1.0.tgz", + "integrity": "sha512-Va5nLSJTN7YFtC2jd+7wsoe1pNe5K4ShLux/E5iHEwlB9AxaxmggY7to9KUqKojhaJw3aXqt5WAb4jGPOolpEw==", + "dependencies": { + "ansi-escapes": "^4.3.1", + "chalk": "^4.0.0", + "jest-regex-util": "^28.0.0", + "jest-watcher": "^28.0.0", + "slash": "^4.0.0", + "string-length": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "peerDependencies": { + "jest": "^27.0.0 || ^28.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@jest/console": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/@jest/console/-/console-28.1.3.tgz", + "integrity": "sha512-QPAkP5EwKdK/bxIr6C1I4Vs0rm2nHiANzj/Z5X2JQkrZo6IqvC4ldZ9K95tF0HdidhA8Bo6egxSzUFPYKcEXLw==", + "dependencies": { + "@jest/types": "^28.1.3", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^28.1.3", + "jest-util": "^28.1.3", + "slash": "^3.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@jest/console/node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@jest/test-result": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-28.1.3.tgz", + "integrity": "sha512-kZAkxnSE+FqE8YjW8gNuoVkkC9I7S1qmenl8sGcDOLropASP+BkcGKwhXoyqQuGOGeYY0y/ixjrd/iERpEXHNg==", + "dependencies": { + "@jest/console": "^28.1.3", + "@jest/types": "^28.1.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@jest/types": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-28.1.3.tgz", + "integrity": "sha512-RyjiyMUZrKz/c+zlMFO1pm70DcIlST8AeWTkoUdZevew44wcNZQHsEVOiCVtgVnlFFD82FPaXycys58cf2muVQ==", + "dependencies": { + "@jest/schemas": "^28.1.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@types/yargs": { + "version": "17.0.18", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.18.tgz", + "integrity": "sha512-eIJR1UER6ur3EpKM3d+2Pgd+ET+k6Kn9B4ZItX0oPjjVI5PrfaRjKyLT5UYendDpLuoiJMNJvovLQbEXqhsPaw==", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-watch-typeahead/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-watch-typeahead/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-watch-typeahead/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-watch-typeahead/node_modules/emittery": { + "version": "0.10.2", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.10.2.tgz", + "integrity": "sha512-aITqOwnLanpHLNXZJENbOgjUBeHocD+xsSJmNrjovKBW5HbSpW3d1pEls7GFQPUWXiwG9+0P4GtHfEqC/4M0Iw==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sindresorhus/emittery?sponsor=1" + } + }, + "node_modules/jest-watch-typeahead/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-message-util": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-28.1.3.tgz", + "integrity": "sha512-PFdn9Iewbt575zKPf1286Ht9EPoJmYT7P0kY+RibeYZ2XtOr53pDLEFoTWXbd1h4JiGiWpTBC84fc8xMXQMb7g==", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^28.1.3", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^28.1.3", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-message-util/node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-regex-util": { + "version": "28.0.2", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-28.0.2.tgz", + "integrity": "sha512-4s0IgyNIy0y9FK+cjoVYoxamT7Zeo7MhzqRGx7YDYmaQn1wucY9rotiGkBzzcMXTtjrCAP/f7f+E0F7+fxPNdw==", + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-util": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-28.1.3.tgz", + "integrity": "sha512-XdqfpHwpcSRko/C35uLYFM2emRAltIIKZiJ9eAmhjsj0CqZMa0p1ib0R5fWIqGhn1a103DebTbpqIaP1qCQ6tQ==", + "dependencies": { + "@jest/types": "^28.1.3", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-watcher": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-28.1.3.tgz", + "integrity": "sha512-t4qcqj9hze+jviFPUN3YAtAEeFnr/azITXQEMARf5cMwKY2SMBRnCQTXLixTl20OR6mLh9KLMrgVJgJISym+1g==", + "dependencies": { + "@jest/test-result": "^28.1.3", + "@jest/types": "^28.1.3", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "emittery": "^0.10.2", + "jest-util": "^28.1.3", + "string-length": "^4.0.1" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-watcher/node_modules/string-length": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz", + "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==", + "dependencies": { + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-watcher/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watch-typeahead/node_modules/pretty-format": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-28.1.3.tgz", + "integrity": "sha512-8gFb/To0OmxHR9+ZTb14Df2vNxdGCX8g1xWGUTqUw5TiZvcQf5sHKObd5UcPyLLyowNwDAMTF3XWOG1B6mxl1Q==", + "dependencies": { + "@jest/schemas": "^28.1.3", + "ansi-regex": "^5.0.1", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/pretty-format/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-watch-typeahead/node_modules/react-is": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz", + "integrity": "sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==" + }, + "node_modules/jest-watch-typeahead/node_modules/slash": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz", + "integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/jest-watch-typeahead/node_modules/string-length": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-5.0.1.tgz", + "integrity": "sha512-9Ep08KAMUn0OadnVaBuRdE2l615CQ508kr0XMadjClfYpdCyvrbFp6Taebo8yyxokQ4viUd/xPPUA4FGgUa0ow==", + "dependencies": { + "char-regex": "^2.0.0", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/jest-watch-typeahead/node_modules/string-length/node_modules/char-regex": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-2.0.1.tgz", + "integrity": "sha512-oSvEeo6ZUD7NepqAat3RqoucZ5SeqLJgOvVIwkafu6IP3V0pO38s/ypdVUmDDK6qIIHNlYHJAKX9E7R7HoKElw==", + "engines": { + "node": ">=12.20" + } + }, + "node_modules/jest-watch-typeahead/node_modules/strip-ansi": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.0.1.tgz", + "integrity": "sha512-cXNxvT8dFNRVfhVME3JAe98mkXDYN2O1l7jmcwMnOslDeESg1rF/OZMtK0nRAhiari1unG5cD4jG3rapUAkLbw==", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/jest-watch-typeahead/node_modules/strip-ansi/node_modules/ansi-regex": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", + "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/jest-watch-typeahead/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watcher": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-27.5.1.tgz", + "integrity": "sha512-z676SuD6Z8o8qbmEGhoEUFOM1+jfEiL3DXHK/xgEiG2EyNYfFG60jluWcupY6dATjfEsKQuibReS1djInQnoVw==", + "dependencies": { + "@jest/test-result": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "jest-util": "^27.5.1", + "string-length": "^4.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-watcher/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-watcher/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/jest-watcher/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/jest-watcher/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/jest-watcher/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watcher/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-worker": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz", + "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==", + "dependencies": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/jest-worker/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-worker/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/js-sdsl": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.2.0.tgz", + "integrity": "sha512-dyBIzQBDkCqCu+0upx25Y2jGdbTGxE9fshMsCdK0ViOongpV+n5tXRcZY9v7CaVQ79AGS9KA1KHtojxiM7aXSQ==", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/js-sdsl" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==" + }, + "node_modules/js-yaml": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsdom": { + "version": "16.7.0", + "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-16.7.0.tgz", + "integrity": "sha512-u9Smc2G1USStM+s/x1ru5Sxrl6mPYCbByG1U/hUmqaVsm4tbNyS7CicOSRyuGQYZhTu0h84qkZZQ/I+dzizSVw==", + "dependencies": { + "abab": "^2.0.5", + "acorn": "^8.2.4", + "acorn-globals": "^6.0.0", + "cssom": "^0.4.4", + "cssstyle": "^2.3.0", + "data-urls": "^2.0.0", + "decimal.js": "^10.2.1", + "domexception": "^2.0.1", + "escodegen": "^2.0.0", + "form-data": "^3.0.0", + "html-encoding-sniffer": "^2.0.1", + "http-proxy-agent": "^4.0.1", + "https-proxy-agent": "^5.0.0", + "is-potential-custom-element-name": "^1.0.1", + "nwsapi": "^2.2.0", + "parse5": "6.0.1", + "saxes": "^5.0.1", + "symbol-tree": "^3.2.4", + "tough-cookie": "^4.0.0", + "w3c-hr-time": "^1.0.2", + "w3c-xmlserializer": "^2.0.0", + "webidl-conversions": "^6.1.0", + "whatwg-encoding": "^1.0.5", + "whatwg-mimetype": "^2.3.0", + "whatwg-url": "^8.5.0", + "ws": "^7.4.6", + "xml-name-validator": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "canvas": "^2.5.0" + }, + "peerDependenciesMeta": { + "canvas": { + "optional": true + } + } + }, + "node_modules/jsesc": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", + "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==" + }, + "node_modules/json-schema": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz", + "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==" + }, + "node_modules/json5": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.2.tgz", + "integrity": "sha512-46Tk9JiOL2z7ytNQWFLpj99RZkVgeHf87yGQKsIkaPz1qSH9UczKH1rO7K3wgRselo0tYMUNfecYpm/p1vC7tQ==", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/jsonfile": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", + "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/jsonpointer": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz", + "integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/jsx-ast-utils": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.3.tgz", + "integrity": "sha512-fYQHZTZ8jSfmWZ0iyzfwiU4WDX4HpHbMCZ3gPlWYiCl3BoeOTsqKBqnTVfH2rYT7eP5c3sVbeSPHnnJOaTrWiw==", + "dependencies": { + "array-includes": "^3.1.5", + "object.assign": "^4.1.3" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/kind-of": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/kleur": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz", + "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", + "engines": { + "node": ">=6" + } + }, + "node_modules/klona": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/klona/-/klona-2.0.5.tgz", + "integrity": "sha512-pJiBpiXMbt7dkzXe8Ghj/u4FfXOOa98fPW+bihOJ4SjnoijweJrNThJfd3ifXpXhREjpoF2mZVH1GfS9LV3kHQ==", + "engines": { + "node": ">= 8" + } + }, + "node_modules/lang-feel": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/lang-feel/-/lang-feel-0.1.0.tgz", + "integrity": "sha512-09oq5ey6+7HeZlE4Z1+N/z4VrlO96ypyUfIgKn8tHf5bbLirP3wu6e88uvTv81oEPVGjTNW0ZjU6MRG5xa8b2A==", + "dependencies": { + "@codemirror/autocomplete": "^6.0.0", + "@codemirror/language": "^6.0.0", + "@codemirror/state": "^6.0.0", + "@codemirror/view": "^6.0.0", + "@lezer/common": "^1.0.0", + "lezer-feel": "^0.15.0" + } + }, + "node_modules/language-subtag-registry": { + "version": "0.3.22", + "resolved": "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.22.tgz", + "integrity": "sha512-tN0MCzyWnoz/4nHS6uxdlFWoUZT7ABptwKPQ52Ea7URk6vll88bWBVhodtnlfEuCcKWNGoc+uGbw1cwa9IKh/w==" + }, + "node_modules/language-tags": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/language-tags/-/language-tags-1.0.7.tgz", + "integrity": "sha512-bSytju1/657hFjgUzPAPqszxH62ouE8nQFoFaVlIQfne4wO/wXC9A4+m8jYve7YBBvi59eq0SUpcshvG8h5Usw==", + "dependencies": { + "language-subtag-registry": "^0.3.20" + } + }, + "node_modules/leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "engines": { + "node": ">=6" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/lezer-feel": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/lezer-feel/-/lezer-feel-0.15.0.tgz", + "integrity": "sha512-coal496AMZ61XSBN6z2LC704to5EpRLHLq4RIetvdj8RMfHM02PDRfqQy0JPACS6CaWydW8ESCekkirsuc+cgA==", + "dependencies": { + "@lezer/highlight": "^1.1.2", + "@lezer/lr": "^1.2.5" + } + }, + "node_modules/lilconfig": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.0.6.tgz", + "integrity": "sha512-9JROoBW7pobfsx+Sq2JsASvCo6Pfo6WWoUW79HuB1BCoBXD4PLWJPqDF6fNj67pqBYTbAHkE57M1kS/+L1neOg==", + "engines": { + "node": ">=10" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==" + }, + "node_modules/loader-runner": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz", + "integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==", + "engines": { + "node": ">=6.11.5" + } + }, + "node_modules/loader-utils": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.4.tgz", + "integrity": "sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==", + "dependencies": { + "big.js": "^5.2.2", + "emojis-list": "^3.0.0", + "json5": "^2.1.2" + }, + "engines": { + "node": ">=8.9.0" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==" + }, + "node_modules/lodash.debounce": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz", + "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==" + }, + "node_modules/lodash.memoize": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", + "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==" + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==" + }, + "node_modules/lodash.sortby": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz", + "integrity": "sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==" + }, + "node_modules/lodash.uniq": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz", + "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lower-case": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz", + "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==", + "dependencies": { + "tslib": "^2.0.3" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/luxon": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.2.0.tgz", + "integrity": "sha512-Namj3XqoJjFekq/JHQEaaAv4zyE/fyyDBrMEBnIL2s/X54SC8W5Ea0uej1TRXUArWec8OojsAVsGBYhNRjpMVw==", + "engines": { + "node": ">=12" + } + }, + "node_modules/lz-string": { + "version": "1.4.4", + "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.4.4.tgz", + "integrity": "sha512-0ckx7ZHRPqb0oUm8zNr+90mtf9DQB60H1wMCjBtfi62Kl3a7JbHob6gA2bC+xRvZoOL+1hzUK8jeuEIQE8svEQ==", + "bin": { + "lz-string": "bin/bin.js" + } + }, + "node_modules/magic-string": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.25.9.tgz", + "integrity": "sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==", + "dependencies": { + "sourcemap-codec": "^1.4.8" + } + }, + "node_modules/make-dir": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", + "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==", + "dependencies": { + "semver": "^6.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/make-dir/node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/makeerror": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz", + "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==", + "dependencies": { + "tmpl": "1.0.5" + } + }, + "node_modules/matches-selector": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/matches-selector/-/matches-selector-1.2.0.tgz", + "integrity": "sha512-c4vLwYWyl+Ji+U43eU/G5FwxWd4ZH0ePUsFs5y0uwD9HUEFBXUQ1zUUan+78IpRD+y4pUfG0nAzNM292K7ItvA==" + }, + "node_modules/mdn-data": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.4.tgz", + "integrity": "sha512-iV3XNKw06j5Q7mi6h+9vbx23Tv7JkjEVgKHW4pimwyDGWm0OIQntJJ+u1C6mg6mK1EaTv42XQ7w76yuzH7M2cA==" + }, + "node_modules/media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/memfs": { + "version": "3.4.12", + "resolved": "https://registry.npmjs.org/memfs/-/memfs-3.4.12.tgz", + "integrity": "sha512-BcjuQn6vfqP+k100e0E9m61Hyqa//Brp+I3f0OBmN0ATHlFA8vx3Lt8z57R3u2bPqe3WGDBC+nF72fTH7isyEw==", + "dependencies": { + "fs-monkey": "^1.0.3" + }, + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/merge-descriptors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", + "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==" + }, + "node_modules/merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==" + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "engines": { + "node": ">= 8" + } + }, + "node_modules/methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "dependencies": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "engines": { + "node": ">=6" + } + }, + "node_modules/min-dash": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/min-dash/-/min-dash-4.0.0.tgz", + "integrity": "sha512-piIvVJ/nxuA4+LpnYIzF6oCtRvdtDvQJteSC+H768H2UvPKFKIt5oiJnUVtr0ZdchneXTcvUZ91vIrvWVIN0AA==" + }, + "node_modules/min-dom": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/min-dom/-/min-dom-4.0.3.tgz", + "integrity": "sha512-5zQyCMe8rtGiDIRjfGeqnF2YPJ7OAPFdJQeC7MakHais3dh4VG4PV2a0FacziKTzJjYK5qnPKm2sq1wSXB1wTQ==", + "dependencies": { + "component-event": "^0.1.4", + "domify": "^1.4.1", + "min-dash": "^4.0.0" + } + }, + "node_modules/min-indent": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz", + "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==", + "engines": { + "node": ">=4" + } + }, + "node_modules/mini-css-extract-plugin": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.7.2.tgz", + "integrity": "sha512-EdlUizq13o0Pd+uCp+WO/JpkLvHRVGt97RqfeGhXqAcorYo1ypJSpkV+WDT0vY/kmh/p7wRdJNJtuyK540PXDw==", + "dependencies": { + "schema-utils": "^4.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/mini-css-extract-plugin/node_modules/ajv": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz", + "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/mini-css-extract-plugin/node_modules/ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/mini-css-extract-plugin/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + }, + "node_modules/mini-css-extract-plugin/node_modules/schema-utils": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", + "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", + "dependencies": { + "@types/json-schema": "^7.0.9", + "ajv": "^8.8.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==" + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.7.tgz", + "integrity": "sha512-bzfL1YUZsP41gmu/qjrEk0Q6i2ix/cVeAhbCbqH9u3zYutS1cLg00qhrD0M2MVdCcx4Sc0UpP2eBWo9rotpq6g==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/mitt": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.0.tgz", + "integrity": "sha512-7dX2/10ITVyqh4aOSVI9gdape+t9l2/8QxHrFmUXu4EEUpdlxl6RudZUPZoc+zuY2hk1j7XxVroIVIan/pD/SQ==" + }, + "node_modules/mkdirp": { + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz", + "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==", + "dependencies": { + "minimist": "^1.2.6" + }, + "bin": { + "mkdirp": "bin/cmd.js" + } + }, + "node_modules/moddle": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/moddle/-/moddle-6.2.0.tgz", + "integrity": "sha512-2/Y2P1GU0wwb5Z/buam1rSUUy7hAxgvAG0ymPLwN99YMUYec7RyCxhCVbiacQj1MY+8IjRc6SvxSAeUkplQ8Jg==", + "dependencies": { + "min-dash": "^4.0.0" + } + }, + "node_modules/moddle-xml": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/moddle-xml/-/moddle-xml-10.1.0.tgz", + "integrity": "sha512-erWckwLt+dYskewKXJso9u+aAZ5172lOiYxSOqKCPTy7L/xmqH1PoeoA7eVC7oJTt3PqF5TkZzUmbjGH6soQBg==", + "dependencies": { + "min-dash": "^4.0.0", + "moddle": "^6.0.0", + "saxen": "^8.1.2" + } + }, + "node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/multicast-dns": { + "version": "7.2.5", + "resolved": "https://registry.npmjs.org/multicast-dns/-/multicast-dns-7.2.5.tgz", + "integrity": "sha512-2eznPJP8z2BFLX50tf0LuODrpINqP1RVIm/CObbTcBRITQgmC/TjcREF1NeTBzIcR5XO/ukWo+YHOjBbFwIupg==", + "dependencies": { + "dns-packet": "^5.2.2", + "thunky": "^1.0.2" + }, + "bin": { + "multicast-dns": "cli.js" + } + }, + "node_modules/nanoid": { + "version": "3.3.4", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.4.tgz", + "integrity": "sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==" + }, + "node_modules/natural-compare-lite": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz", + "integrity": "sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==" + }, + "node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/neo-async": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==" + }, + "node_modules/no-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz", + "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==", + "dependencies": { + "lower-case": "^2.0.2", + "tslib": "^2.0.3" + } + }, + "node_modules/node-forge": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.1.tgz", + "integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==", + "engines": { + "node": ">= 6.13.0" + } + }, + "node_modules/node-int64": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz", + "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==" + }, + "node_modules/node-releases": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.8.tgz", + "integrity": "sha512-dFSmB8fFHEH/s81Xi+Y/15DQY6VHW81nXRj86EMSL3lmuTmK1e+aT4wrFCkTbm+gSwkw4KpX+rT/pMM2c1mF+A==" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/normalize-range": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", + "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/normalize-url": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", + "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "dependencies": { + "path-key": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/nth-check": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", + "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==", + "dependencies": { + "boolbase": "^1.0.0" + }, + "funding": { + "url": "https://github.com/fb55/nth-check?sponsor=1" + } + }, + "node_modules/nwsapi": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.2.tgz", + "integrity": "sha512-90yv+6538zuvUMnN+zCr8LuV6bPFdq50304114vJYJ8RDyK8D5O9Phpbd6SZWgI7PwzmmfN1upeOJlvybDSgCw==" + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-hash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz", + "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==", + "engines": { + "node": ">= 6" + } + }, + "node_modules/object-inspect": { + "version": "1.12.2", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.2.tgz", + "integrity": "sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-is": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.5.tgz", + "integrity": "sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object-refs": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/object-refs/-/object-refs-0.3.0.tgz", + "integrity": "sha512-eP0ywuoWOaDoiake/6kTJlPJhs+k0qNm4nYRzXLNHj6vh+5M3i9R1epJTdxIPGlhWc4fNRQ7a6XJNCX+/L4FOQ==" + }, + "node_modules/object.assign": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz", + "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "has-symbols": "^1.0.3", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.entries": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.6.tgz", + "integrity": "sha512-leTPzo4Zvg3pmbQ3rDK69Rl8GQvIqMWubrkxONG9/ojtFE2rD9fjMKfSI5BxW3osRH1m6VdzmqK8oAY9aT4x5w==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.fromentries": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.6.tgz", + "integrity": "sha512-VciD13dswC4j1Xt5394WR4MzmAQmlgN72phd/riNp9vtD7tp4QQWJ0R4wvclXcafgcYK8veHRed2W6XeGBvcfg==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.getownpropertydescriptors": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.5.tgz", + "integrity": "sha512-yDNzckpM6ntyQiGTik1fKV1DcVDRS+w8bvpWNCBanvH5LfRX9O8WTHqQzG4RZwRAM4I0oU7TV11Lj5v0g20ibw==", + "dependencies": { + "array.prototype.reduce": "^1.0.5", + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.hasown": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/object.hasown/-/object.hasown-1.1.2.tgz", + "integrity": "sha512-B5UIT3J1W+WuWIU55h0mjlwaqxiE5vYENJXIXZ4VFe05pNYrkKuK0U/6aFcb0pKywYJh7IhfoqUfKVmrJJHZHw==", + "dependencies": { + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.values": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.6.tgz", + "integrity": "sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/obuf": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/obuf/-/obuf-1.1.2.tgz", + "integrity": "sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==" + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/on-headers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.0.2.tgz", + "integrity": "sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/open": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/open/-/open-8.4.0.tgz", + "integrity": "sha512-XgFPPM+B28FtCCgSb9I+s9szOC1vZRSwgWsRUA5ylIxRTgKozqjOCrVOqGsYABPYK5qnfqClxZTFBa8PKt2v6Q==", + "dependencies": { + "define-lazy-prop": "^2.0.0", + "is-docker": "^2.1.1", + "is-wsl": "^2.2.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/optimism": { + "version": "0.16.2", + "resolved": "https://registry.npmjs.org/optimism/-/optimism-0.16.2.tgz", + "integrity": "sha512-zWNbgWj+3vLEjZNIh/okkY2EUfX+vB9TJopzIZwT1xxaMqC5hRLLraePod4c5n4He08xuXNH+zhKFFCu390wiQ==", + "dependencies": { + "@wry/context": "^0.7.0", + "@wry/trie": "^0.3.0" + } + }, + "node_modules/optionator": { + "version": "0.9.1", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz", + "integrity": "sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.3" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-retry": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/p-retry/-/p-retry-4.6.2.tgz", + "integrity": "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==", + "dependencies": { + "@types/retry": "0.12.0", + "retry": "^0.13.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "engines": { + "node": ">=6" + } + }, + "node_modules/param-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz", + "integrity": "sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse-json": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "dependencies": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parse5": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz", + "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==" + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/pascal-case": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz", + "integrity": "sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-intersection": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/path-intersection/-/path-intersection-2.2.1.tgz", + "integrity": "sha512-9u8xvMcSfuOiStv9bPdnRJQhGQXLKurew94n4GPQCdH1nj9QKC9ObbNoIpiRq8skiOBxKkt277PgOoFgAt3/rA==" + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==" + }, + "node_modules/path-to-regexp": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", + "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==" + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "engines": { + "node": ">=8" + } + }, + "node_modules/performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==" + }, + "node_modules/picocolors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", + "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==" + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/pirates": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.5.tgz", + "integrity": "sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==", + "engines": { + "node": ">= 6" + } + }, + "node_modules/pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dependencies": { + "find-up": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dependencies": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dependencies": { + "p-locate": "^4.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pkg-dir/node_modules/p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dependencies": { + "p-limit": "^2.2.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-up": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/pkg-up/-/pkg-up-3.1.0.tgz", + "integrity": "sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==", + "dependencies": { + "find-up": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-up/node_modules/find-up": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", + "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "dependencies": { + "locate-path": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/pkg-up/node_modules/locate-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", + "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "dependencies": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/pkg-up/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pkg-up/node_modules/p-locate": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", + "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "dependencies": { + "p-limit": "^2.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/pkg-up/node_modules/path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==", + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss": { + "version": "8.4.20", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.20.tgz", + "integrity": "sha512-6Q04AXR1212bXr5fh03u8aAwbLxAQNGQ/Q1LNa0VfOI06ZAlhPHtQvE4OIdpj4kLThXilalPnmDSOD65DcHt+g==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + } + ], + "dependencies": { + "nanoid": "^3.3.4", + "picocolors": "^1.0.0", + "source-map-js": "^1.0.2" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/postcss-attribute-case-insensitive": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/postcss-attribute-case-insensitive/-/postcss-attribute-case-insensitive-5.0.2.tgz", + "integrity": "sha512-XIidXV8fDr0kKt28vqki84fRK8VW8eTuIa4PChv2MqKuT6C9UjmSKzen6KaWhWEoYvwxFCa7n/tC1SZ3tyq4SQ==", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-browser-comments": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-browser-comments/-/postcss-browser-comments-4.0.0.tgz", + "integrity": "sha512-X9X9/WN3KIvY9+hNERUqX9gncsgBA25XaeR+jshHz2j8+sYyHktHw1JdKuMjeLpGktXidqDhA7b/qm1mrBDmgg==", + "engines": { + "node": ">=8" + }, + "peerDependencies": { + "browserslist": ">=4", + "postcss": ">=8" + } + }, + "node_modules/postcss-calc": { + "version": "8.2.4", + "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-8.2.4.tgz", + "integrity": "sha512-SmWMSJmB8MRnnULldx0lQIyhSNvuDl9HfrZkaqqE/WHAhToYsAvDq+yAsA/kIyINDszOp3Rh0GFoNuH5Ypsm3Q==", + "dependencies": { + "postcss-selector-parser": "^6.0.9", + "postcss-value-parser": "^4.2.0" + }, + "peerDependencies": { + "postcss": "^8.2.2" + } + }, + "node_modules/postcss-clamp": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/postcss-clamp/-/postcss-clamp-4.1.0.tgz", + "integrity": "sha512-ry4b1Llo/9zz+PKC+030KUnPITTJAHeOwjfAyyB60eT0AorGLdzp52s31OsPRHRf8NchkgFoG2y6fCfn1IV1Ow==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": ">=7.6.0" + }, + "peerDependencies": { + "postcss": "^8.4.6" + } + }, + "node_modules/postcss-color-functional-notation": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/postcss-color-functional-notation/-/postcss-color-functional-notation-4.2.4.tgz", + "integrity": "sha512-2yrTAUZUab9s6CpxkxC4rVgFEVaR6/2Pipvi6qcgvnYiVqZcbDHEoBDhrXzyb7Efh2CCfHQNtcqWcIruDTIUeg==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-color-hex-alpha": { + "version": "8.0.4", + "resolved": "https://registry.npmjs.org/postcss-color-hex-alpha/-/postcss-color-hex-alpha-8.0.4.tgz", + "integrity": "sha512-nLo2DCRC9eE4w2JmuKgVA3fGL3d01kGq752pVALF68qpGLmx2Qrk91QTKkdUqqp45T1K1XV8IhQpcu1hoAQflQ==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-color-rebeccapurple": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-color-rebeccapurple/-/postcss-color-rebeccapurple-7.1.1.tgz", + "integrity": "sha512-pGxkuVEInwLHgkNxUc4sdg4g3py7zUeCQ9sMfwyHAT+Ezk8a4OaaVZ8lIY5+oNqA/BXXgLyXv0+5wHP68R79hg==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-colormin": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-5.3.0.tgz", + "integrity": "sha512-WdDO4gOFG2Z8n4P8TWBpshnL3JpmNmJwdnfP2gbk2qBA8PWwOYcmjmI/t3CmMeL72a7Hkd+x/Mg9O2/0rD54Pg==", + "dependencies": { + "browserslist": "^4.16.6", + "caniuse-api": "^3.0.0", + "colord": "^2.9.1", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-convert-values": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-5.1.3.tgz", + "integrity": "sha512-82pC1xkJZtcJEfiLw6UXnXVXScgtBrjlO5CBmuDQc+dlb88ZYheFsjTn40+zBVi3DkfF7iezO0nJUPLcJK3pvA==", + "dependencies": { + "browserslist": "^4.21.4", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-custom-media": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/postcss-custom-media/-/postcss-custom-media-8.0.2.tgz", + "integrity": "sha512-7yi25vDAoHAkbhAzX9dHx2yc6ntS4jQvejrNcC+csQJAXjj15e7VcWfMgLqBNAbOvqi5uIa9huOVwdHbf+sKqg==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.3" + } + }, + "node_modules/postcss-custom-properties": { + "version": "12.1.11", + "resolved": "https://registry.npmjs.org/postcss-custom-properties/-/postcss-custom-properties-12.1.11.tgz", + "integrity": "sha512-0IDJYhgU8xDv1KY6+VgUwuQkVtmYzRwu+dMjnmdMafXYv86SWqfxkc7qdDvWS38vsjaEtv8e0vGOUQrAiMBLpQ==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-custom-selectors": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/postcss-custom-selectors/-/postcss-custom-selectors-6.0.3.tgz", + "integrity": "sha512-fgVkmyiWDwmD3JbpCmB45SvvlCD6z9CG6Ie6Iere22W5aHea6oWa7EM2bpnv2Fj3I94L3VbtvX9KqwSi5aFzSg==", + "dependencies": { + "postcss-selector-parser": "^6.0.4" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.3" + } + }, + "node_modules/postcss-dir-pseudo-class": { + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/postcss-dir-pseudo-class/-/postcss-dir-pseudo-class-6.0.5.tgz", + "integrity": "sha512-eqn4m70P031PF7ZQIvSgy9RSJ5uI2171O/OO/zcRNYpJbvaeKFUlar1aJ7rmgiQtbm0FSPsRewjpdS0Oew7MPA==", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-discard-comments": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-5.1.2.tgz", + "integrity": "sha512-+L8208OVbHVF2UQf1iDmRcbdjJkuBF6IS29yBDSiWUIzpYaAhtNl6JYnYm12FnkeCwQqF5LeklOu6rAqgfBZqQ==", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-duplicates": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-5.1.0.tgz", + "integrity": "sha512-zmX3IoSI2aoenxHV6C7plngHWWhUOV3sP1T8y2ifzxzbtnuhk1EdPwm0S1bIUNaJ2eNbWeGLEwzw8huPD67aQw==", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-empty": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-5.1.1.tgz", + "integrity": "sha512-zPz4WljiSuLWsI0ir4Mcnr4qQQ5e1Ukc3i7UfE2XcrwKK2LIPIqE5jxMRxO6GbI3cv//ztXDsXwEWT3BHOGh3A==", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-overridden": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-5.1.0.tgz", + "integrity": "sha512-21nOL7RqWR1kasIVdKs8HNqQJhFxLsyRfAnUDm4Fe4t4mCWL9OJiHvlHPjcd8zc5Myu89b/7wZDnOSjFgeWRtw==", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-double-position-gradients": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/postcss-double-position-gradients/-/postcss-double-position-gradients-3.1.2.tgz", + "integrity": "sha512-GX+FuE/uBR6eskOK+4vkXgT6pDkexLokPaz/AbJna9s5Kzp/yl488pKPjhy0obB475ovfT1Wv8ho7U/cHNaRgQ==", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-env-function": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/postcss-env-function/-/postcss-env-function-4.0.6.tgz", + "integrity": "sha512-kpA6FsLra+NqcFnL81TnsU+Z7orGtDTxcOhl6pwXeEq1yFPpRMkCDpHhrz8CFQDr/Wfm0jLiNQ1OsGGPjlqPwA==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-flexbugs-fixes": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/postcss-flexbugs-fixes/-/postcss-flexbugs-fixes-5.0.2.tgz", + "integrity": "sha512-18f9voByak7bTktR2QgDveglpn9DTbBWPUzSOe9g0N4WR/2eSt6Vrcbf0hmspvMI6YWGywz6B9f7jzpFNJJgnQ==", + "peerDependencies": { + "postcss": "^8.1.4" + } + }, + "node_modules/postcss-focus-visible": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/postcss-focus-visible/-/postcss-focus-visible-6.0.4.tgz", + "integrity": "sha512-QcKuUU/dgNsstIK6HELFRT5Y3lbrMLEOwG+A4s5cA+fx3A3y/JTq3X9LaOj3OC3ALH0XqyrgQIgey/MIZ8Wczw==", + "dependencies": { + "postcss-selector-parser": "^6.0.9" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-focus-within": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/postcss-focus-within/-/postcss-focus-within-5.0.4.tgz", + "integrity": "sha512-vvjDN++C0mu8jz4af5d52CB184ogg/sSxAFS+oUJQq2SuCe7T5U2iIsVJtsCp2d6R4j0jr5+q3rPkBVZkXD9fQ==", + "dependencies": { + "postcss-selector-parser": "^6.0.9" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-font-variant": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/postcss-font-variant/-/postcss-font-variant-5.0.0.tgz", + "integrity": "sha512-1fmkBaCALD72CK2a9i468mA/+tr9/1cBxRRMXOUaZqO43oWPR5imcyPjXwuv7PXbCid4ndlP5zWhidQVVa3hmA==", + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-gap-properties": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/postcss-gap-properties/-/postcss-gap-properties-3.0.5.tgz", + "integrity": "sha512-IuE6gKSdoUNcvkGIqdtjtcMtZIFyXZhmFd5RUlg97iVEvp1BZKV5ngsAjCjrVy+14uhGBQl9tzmi1Qwq4kqVOg==", + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-image-set-function": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/postcss-image-set-function/-/postcss-image-set-function-4.0.7.tgz", + "integrity": "sha512-9T2r9rsvYzm5ndsBE8WgtrMlIT7VbtTfE7b3BQnudUqnBcBo7L758oc+o+pdj/dUV0l5wjwSdjeOH2DZtfv8qw==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-import": { + "version": "14.1.0", + "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-14.1.0.tgz", + "integrity": "sha512-flwI+Vgm4SElObFVPpTIT7SU7R3qk2L7PyduMcokiaVKuWv9d/U+Gm/QAd8NDLuykTWTkcrjOeD2Pp1rMeBTGw==", + "dependencies": { + "postcss-value-parser": "^4.0.0", + "read-cache": "^1.0.0", + "resolve": "^1.1.7" + }, + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "node_modules/postcss-initial": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/postcss-initial/-/postcss-initial-4.0.1.tgz", + "integrity": "sha512-0ueD7rPqX8Pn1xJIjay0AZeIuDoF+V+VvMt/uOnn+4ezUKhZM/NokDeP6DwMNyIoYByuN/94IQnt5FEkaN59xQ==", + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "node_modules/postcss-js": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.0.0.tgz", + "integrity": "sha512-77QESFBwgX4irogGVPgQ5s07vLvFqWr228qZY+w6lW599cRlK/HmnlivnnVUxkjHnCu4J16PDMHcH+e+2HbvTQ==", + "dependencies": { + "camelcase-css": "^2.0.1" + }, + "engines": { + "node": "^12 || ^14 || >= 16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + "peerDependencies": { + "postcss": "^8.3.3" + } + }, + "node_modules/postcss-lab-function": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/postcss-lab-function/-/postcss-lab-function-4.2.1.tgz", + "integrity": "sha512-xuXll4isR03CrQsmxyz92LJB2xX9n+pZJ5jE9JgcnmsCammLyKdlzrBin+25dy6wIjfhJpKBAN80gsTlCgRk2w==", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-load-config": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-3.1.4.tgz", + "integrity": "sha512-6DiM4E7v4coTE4uzA8U//WhtPwyhiim3eyjEMFCnUpzbrkK9wJHgKDT2mR+HbtSrd/NubVaYTOpSpjUl8NQeRg==", + "dependencies": { + "lilconfig": "^2.0.5", + "yaml": "^1.10.2" + }, + "engines": { + "node": ">= 10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + "peerDependencies": { + "postcss": ">=8.0.9", + "ts-node": ">=9.0.0" + }, + "peerDependenciesMeta": { + "postcss": { + "optional": true + }, + "ts-node": { + "optional": true + } + } + }, + "node_modules/postcss-loader": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/postcss-loader/-/postcss-loader-6.2.1.tgz", + "integrity": "sha512-WbbYpmAaKcux/P66bZ40bpWsBucjx/TTgVVzRZ9yUO8yQfVBlameJ0ZGVaPfH64hNSBh63a+ICP5nqOpBA0w+Q==", + "dependencies": { + "cosmiconfig": "^7.0.0", + "klona": "^2.0.5", + "semver": "^7.3.5" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "postcss": "^7.0.0 || ^8.0.1", + "webpack": "^5.0.0" + } + }, + "node_modules/postcss-logical": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/postcss-logical/-/postcss-logical-5.0.4.tgz", + "integrity": "sha512-RHXxplCeLh9VjinvMrZONq7im4wjWGlRJAqmAVLXyZaXwfDWP73/oq4NdIp+OZwhQUMj0zjqDfM5Fj7qby+B4g==", + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-media-minmax": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/postcss-media-minmax/-/postcss-media-minmax-5.0.0.tgz", + "integrity": "sha512-yDUvFf9QdFZTuCUg0g0uNSHVlJ5X1lSzDZjPSFaiCWvjgsvu8vEVxtahPrLMinIDEEGnx6cBe6iqdx5YWz08wQ==", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-merge-longhand": { + "version": "5.1.7", + "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-5.1.7.tgz", + "integrity": "sha512-YCI9gZB+PLNskrK0BB3/2OzPnGhPkBEwmwhfYk1ilBHYVAZB7/tkTHFBAnCrvBBOmeYyMYw3DMjT55SyxMBzjQ==", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "stylehacks": "^5.1.1" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-merge-rules": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-5.1.3.tgz", + "integrity": "sha512-LbLd7uFC00vpOuMvyZop8+vvhnfRGpp2S+IMQKeuOZZapPRY4SMq5ErjQeHbHsjCUgJkRNrlU+LmxsKIqPKQlA==", + "dependencies": { + "browserslist": "^4.21.4", + "caniuse-api": "^3.0.0", + "cssnano-utils": "^3.1.0", + "postcss-selector-parser": "^6.0.5" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-font-values": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-5.1.0.tgz", + "integrity": "sha512-el3mYTgx13ZAPPirSVsHqFzl+BBBDrXvbySvPGFnQcTI4iNslrPaFq4muTkLZmKlGk4gyFAYUBMH30+HurREyA==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-gradients": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-5.1.1.tgz", + "integrity": "sha512-VGvXMTpCEo4qHTNSa9A0a3D+dxGFZCYwR6Jokk+/3oB6flu2/PnPXAh2x7x52EkY5xlIHLm+Le8tJxe/7TNhzw==", + "dependencies": { + "colord": "^2.9.1", + "cssnano-utils": "^3.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-params": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-5.1.4.tgz", + "integrity": "sha512-+mePA3MgdmVmv6g+30rn57USjOGSAyuxUmkfiWpzalZ8aiBkdPYjXWtHuwJGm1v5Ojy0Z0LaSYhHaLJQB0P8Jw==", + "dependencies": { + "browserslist": "^4.21.4", + "cssnano-utils": "^3.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-selectors": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-5.2.1.tgz", + "integrity": "sha512-nPJu7OjZJTsVUmPdm2TcaiohIwxP+v8ha9NehQ2ye9szv4orirRU3SDdtUmKH+10nzn0bAyOXZ0UEr7OpvLehg==", + "dependencies": { + "postcss-selector-parser": "^6.0.5" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-modules-extract-imports": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.0.0.tgz", + "integrity": "sha512-bdHleFnP3kZ4NYDhuGlVK+CMrQ/pqUm8bx/oGL93K6gVwiclvX5x0n76fYMKuIGKzlABOy13zsvqjb0f92TEXw==", + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-local-by-default": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.0.tgz", + "integrity": "sha512-sT7ihtmGSF9yhm6ggikHdV0hlziDTX7oFoXtuVWeDd3hHObNkcHRo9V3yg7vCAY7cONyxJC/XXCmmiHHcvX7bQ==", + "dependencies": { + "icss-utils": "^5.0.0", + "postcss-selector-parser": "^6.0.2", + "postcss-value-parser": "^4.1.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-scope": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-3.0.0.tgz", + "integrity": "sha512-hncihwFA2yPath8oZ15PZqvWGkWf+XUfQgUGamS4LqoP1anQLOsOJw0vr7J7IwLpoY9fatA2qiGUGmuZL0Iqlg==", + "dependencies": { + "postcss-selector-parser": "^6.0.4" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-values": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz", + "integrity": "sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==", + "dependencies": { + "icss-utils": "^5.0.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-nested": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.0.0.tgz", + "integrity": "sha512-0DkamqrPcmkBDsLn+vQDIrtkSbNkv5AD/M322ySo9kqFkCIYklym2xEmWkwo+Y3/qZo34tzEPNUw4y7yMCdv5w==", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": ">=12.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + "peerDependencies": { + "postcss": "^8.2.14" + } + }, + "node_modules/postcss-nesting": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/postcss-nesting/-/postcss-nesting-10.2.0.tgz", + "integrity": "sha512-EwMkYchxiDiKUhlJGzWsD9b2zvq/r2SSubcRrgP+jujMXFzqvANLt16lJANC+5uZ6hjI7lpRmI6O8JIl+8l1KA==", + "dependencies": { + "@csstools/selector-specificity": "^2.0.0", + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-normalize": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/postcss-normalize/-/postcss-normalize-10.0.1.tgz", + "integrity": "sha512-+5w18/rDev5mqERcG3W5GZNMJa1eoYYNGo8gB7tEwaos0ajk3ZXAI4mHGcNT47NE+ZnZD1pEpUOFLvltIwmeJA==", + "dependencies": { + "@csstools/normalize.css": "*", + "postcss-browser-comments": "^4", + "sanitize.css": "*" + }, + "engines": { + "node": ">= 12" + }, + "peerDependencies": { + "browserslist": ">= 4", + "postcss": ">= 8" + } + }, + "node_modules/postcss-normalize-charset": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-5.1.0.tgz", + "integrity": "sha512-mSgUJ+pd/ldRGVx26p2wz9dNZ7ji6Pn8VWBajMXFf8jk7vUoSrZ2lt/wZR7DtlZYKesmZI680qjr2CeFF2fbUg==", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-display-values": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-5.1.0.tgz", + "integrity": "sha512-WP4KIM4o2dazQXWmFaqMmcvsKmhdINFblgSeRgn8BJ6vxaMyaJkwAzpPpuvSIoG/rmX3M+IrRZEz2H0glrQNEA==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-positions": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-5.1.1.tgz", + "integrity": "sha512-6UpCb0G4eofTCQLFVuI3EVNZzBNPiIKcA1AKVka+31fTVySphr3VUgAIULBhxZkKgwLImhzMR2Bw1ORK+37INg==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-repeat-style": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-5.1.1.tgz", + "integrity": "sha512-mFpLspGWkQtBcWIRFLmewo8aC3ImN2i/J3v8YCFUwDnPu3Xz4rLohDO26lGjwNsQxB3YF0KKRwspGzE2JEuS0g==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-string": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-5.1.0.tgz", + "integrity": "sha512-oYiIJOf4T9T1N4i+abeIc7Vgm/xPCGih4bZz5Nm0/ARVJ7K6xrDlLwvwqOydvyL3RHNf8qZk6vo3aatiw/go3w==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-timing-functions": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-5.1.0.tgz", + "integrity": "sha512-DOEkzJ4SAXv5xkHl0Wa9cZLF3WCBhF3o1SKVxKQAa+0pYKlueTpCgvkFAHfk+Y64ezX9+nITGrDZeVGgITJXjg==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-unicode": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-5.1.1.tgz", + "integrity": "sha512-qnCL5jzkNUmKVhZoENp1mJiGNPcsJCs1aaRmURmeJGES23Z/ajaln+EPTD+rBeNkSryI+2WTdW+lwcVdOikrpA==", + "dependencies": { + "browserslist": "^4.21.4", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-url": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-5.1.0.tgz", + "integrity": "sha512-5upGeDO+PVthOxSmds43ZeMeZfKH+/DKgGRD7TElkkyS46JXAUhMzIKiCa7BabPeIy3AQcTkXwVVN7DbqsiCew==", + "dependencies": { + "normalize-url": "^6.0.1", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-whitespace": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-5.1.1.tgz", + "integrity": "sha512-83ZJ4t3NUDETIHTa3uEg6asWjSBYL5EdkVB0sDncx9ERzOKBVJIUeDO9RyA9Zwtig8El1d79HBp0JEi8wvGQnA==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-opacity-percentage": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/postcss-opacity-percentage/-/postcss-opacity-percentage-1.1.3.tgz", + "integrity": "sha512-An6Ba4pHBiDtyVpSLymUUERMo2cU7s+Obz6BTrS+gxkbnSBNKSuD0AVUc+CpBMrpVPKKfoVz0WQCX+Tnst0i4A==", + "funding": [ + { + "type": "kofi", + "url": "https://ko-fi.com/mrcgrtz" + }, + { + "type": "liberapay", + "url": "https://liberapay.com/mrcgrtz" + } + ], + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-ordered-values": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-5.1.3.tgz", + "integrity": "sha512-9UO79VUhPwEkzbb3RNpqqghc6lcYej1aveQteWY+4POIwlqkYE21HKWaLDF6lWNuqCobEAyTovVhtI32Rbv2RQ==", + "dependencies": { + "cssnano-utils": "^3.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-overflow-shorthand": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/postcss-overflow-shorthand/-/postcss-overflow-shorthand-3.0.4.tgz", + "integrity": "sha512-otYl/ylHK8Y9bcBnPLo3foYFLL6a6Ak+3EQBPOTR7luMYCOsiVTUk1iLvNf6tVPNGXcoL9Hoz37kpfriRIFb4A==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-page-break": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/postcss-page-break/-/postcss-page-break-3.0.4.tgz", + "integrity": "sha512-1JGu8oCjVXLa9q9rFTo4MbeeA5FMe00/9C7lN4va606Rdb+HkxXtXsmEDrIraQ11fGz/WvKWa8gMuCKkrXpTsQ==", + "peerDependencies": { + "postcss": "^8" + } + }, + "node_modules/postcss-place": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/postcss-place/-/postcss-place-7.0.5.tgz", + "integrity": "sha512-wR8igaZROA6Z4pv0d+bvVrvGY4GVHihBCBQieXFY3kuSuMyOmEnnfFzHl/tQuqHZkfkIVBEbDvYcFfHmpSet9g==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-preset-env": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/postcss-preset-env/-/postcss-preset-env-7.8.3.tgz", + "integrity": "sha512-T1LgRm5uEVFSEF83vHZJV2z19lHg4yJuZ6gXZZkqVsqv63nlr6zabMH3l4Pc01FQCyfWVrh2GaUeCVy9Po+Aag==", + "dependencies": { + "@csstools/postcss-cascade-layers": "^1.1.1", + "@csstools/postcss-color-function": "^1.1.1", + "@csstools/postcss-font-format-keywords": "^1.0.1", + "@csstools/postcss-hwb-function": "^1.0.2", + "@csstools/postcss-ic-unit": "^1.0.1", + "@csstools/postcss-is-pseudo-class": "^2.0.7", + "@csstools/postcss-nested-calc": "^1.0.0", + "@csstools/postcss-normalize-display-values": "^1.0.1", + "@csstools/postcss-oklab-function": "^1.1.1", + "@csstools/postcss-progressive-custom-properties": "^1.3.0", + "@csstools/postcss-stepped-value-functions": "^1.0.1", + "@csstools/postcss-text-decoration-shorthand": "^1.0.0", + "@csstools/postcss-trigonometric-functions": "^1.0.2", + "@csstools/postcss-unset-value": "^1.0.2", + "autoprefixer": "^10.4.13", + "browserslist": "^4.21.4", + "css-blank-pseudo": "^3.0.3", + "css-has-pseudo": "^3.0.4", + "css-prefers-color-scheme": "^6.0.3", + "cssdb": "^7.1.0", + "postcss-attribute-case-insensitive": "^5.0.2", + "postcss-clamp": "^4.1.0", + "postcss-color-functional-notation": "^4.2.4", + "postcss-color-hex-alpha": "^8.0.4", + "postcss-color-rebeccapurple": "^7.1.1", + "postcss-custom-media": "^8.0.2", + "postcss-custom-properties": "^12.1.10", + "postcss-custom-selectors": "^6.0.3", + "postcss-dir-pseudo-class": "^6.0.5", + "postcss-double-position-gradients": "^3.1.2", + "postcss-env-function": "^4.0.6", + "postcss-focus-visible": "^6.0.4", + "postcss-focus-within": "^5.0.4", + "postcss-font-variant": "^5.0.0", + "postcss-gap-properties": "^3.0.5", + "postcss-image-set-function": "^4.0.7", + "postcss-initial": "^4.0.1", + "postcss-lab-function": "^4.2.1", + "postcss-logical": "^5.0.4", + "postcss-media-minmax": "^5.0.0", + "postcss-nesting": "^10.2.0", + "postcss-opacity-percentage": "^1.1.2", + "postcss-overflow-shorthand": "^3.0.4", + "postcss-page-break": "^3.0.4", + "postcss-place": "^7.0.5", + "postcss-pseudo-class-any-link": "^7.1.6", + "postcss-replace-overflow-wrap": "^4.0.0", + "postcss-selector-not": "^6.0.1", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-pseudo-class-any-link": { + "version": "7.1.6", + "resolved": "https://registry.npmjs.org/postcss-pseudo-class-any-link/-/postcss-pseudo-class-any-link-7.1.6.tgz", + "integrity": "sha512-9sCtZkO6f/5ML9WcTLcIyV1yz9D1rf0tWc+ulKcvV30s0iZKS/ONyETvoWsr6vnrmW+X+KmuK3gV/w5EWnT37w==", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-reduce-initial": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-5.1.1.tgz", + "integrity": "sha512-//jeDqWcHPuXGZLoolFrUXBDyuEGbr9S2rMo19bkTIjBQ4PqkaO+oI8wua5BOUxpfi97i3PCoInsiFIEBfkm9w==", + "dependencies": { + "browserslist": "^4.21.4", + "caniuse-api": "^3.0.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-reduce-transforms": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-5.1.0.tgz", + "integrity": "sha512-2fbdbmgir5AvpW9RLtdONx1QoYG2/EtqpNQbFASDlixBbAYuTcJ0dECwlqNqH7VbaUnEnh8SrxOe2sRIn24XyQ==", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-replace-overflow-wrap": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-replace-overflow-wrap/-/postcss-replace-overflow-wrap-4.0.0.tgz", + "integrity": "sha512-KmF7SBPphT4gPPcKZc7aDkweHiKEEO8cla/GjcBK+ckKxiZslIu3C4GCRW3DNfL0o7yW7kMQu9xlZ1kXRXLXtw==", + "peerDependencies": { + "postcss": "^8.0.3" + } + }, + "node_modules/postcss-selector-not": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/postcss-selector-not/-/postcss-selector-not-6.0.1.tgz", + "integrity": "sha512-1i9affjAe9xu/y9uqWH+tD4r6/hDaXJruk8xn2x1vzxC2U3J3LKO3zJW4CyxlNhA56pADJ/djpEwpH1RClI2rQ==", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-selector-parser": { + "version": "6.0.11", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.11.tgz", + "integrity": "sha512-zbARubNdogI9j7WY4nQJBiNqQf3sLS3wCP4WfOidu+p28LofJqDH1tcXypGrcmMHhDk2t9wGhCsYe/+szLTy1g==", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-svgo": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-5.1.0.tgz", + "integrity": "sha512-D75KsH1zm5ZrHyxPakAxJWtkyXew5qwS70v56exwvw542d9CRtTo78K0WeFxZB4G7JXKKMbEZtZayTGdIky/eA==", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "svgo": "^2.7.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-svgo/node_modules/commander": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", + "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==", + "engines": { + "node": ">= 10" + } + }, + "node_modules/postcss-svgo/node_modules/css-tree": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-1.1.3.tgz", + "integrity": "sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==", + "dependencies": { + "mdn-data": "2.0.14", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/postcss-svgo/node_modules/mdn-data": { + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.14.tgz", + "integrity": "sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==" + }, + "node_modules/postcss-svgo/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/postcss-svgo/node_modules/svgo": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-2.8.0.tgz", + "integrity": "sha512-+N/Q9kV1+F+UeWYoSiULYo4xYSDQlTgb+ayMobAXPwMnLvop7oxKMo9OzIrX5x3eS4L4f2UHhc9axXwY8DpChg==", + "dependencies": { + "@trysound/sax": "0.2.0", + "commander": "^7.2.0", + "css-select": "^4.1.3", + "css-tree": "^1.1.3", + "csso": "^4.2.0", + "picocolors": "^1.0.0", + "stable": "^0.1.8" + }, + "bin": { + "svgo": "bin/svgo" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/postcss-unique-selectors": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-5.1.1.tgz", + "integrity": "sha512-5JiODlELrz8L2HwxfPnhOWZYWDxVHWL83ufOv84NrcgipI7TaeRsatAhK4Tr2/ZiYldpK/wBvw5BD3qfaK96GA==", + "dependencies": { + "postcss-selector-parser": "^6.0.5" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-value-parser": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", + "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==" + }, + "node_modules/preact": { + "version": "10.11.3", + "resolved": "https://registry.npmjs.org/preact/-/preact-10.11.3.tgz", + "integrity": "sha512-eY93IVpod/zG3uMF22Unl8h9KkrcKIRs2EGar8hwLZZDU1lkjph303V9HZBwufh2s736U6VXuhD109LYqPoffg==", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/preact" + } + }, + "node_modules/preact-markup": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/preact-markup/-/preact-markup-2.1.1.tgz", + "integrity": "sha512-8JL2p36mzK8XkspOyhBxUSPjYwMxDM0L5BWBZWxsZMVW8WsGQrYQDgVuDKkRspt2hwrle+Cxr/053hpc9BJwfw==", + "peerDependencies": { + "preact": ">=10" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/pretty-bytes": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-5.6.0.tgz", + "integrity": "sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pretty-error": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/pretty-error/-/pretty-error-4.0.0.tgz", + "integrity": "sha512-AoJ5YMAcXKYxKhuJGdcvse+Voc6v1RgnsR3nWcYU7q4t6z0Q6T86sv5Zq8VIRbOWWFpvdGE83LtdSMNd+6Y0xw==", + "dependencies": { + "lodash": "^4.17.20", + "renderkid": "^3.0.0" + } + }, + "node_modules/pretty-format": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz", + "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==", + "dependencies": { + "ansi-regex": "^5.0.1", + "ansi-styles": "^5.0.0", + "react-is": "^17.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/pretty-format/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==" + }, + "node_modules/promise": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/promise/-/promise-8.3.0.tgz", + "integrity": "sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==", + "dependencies": { + "asap": "~2.0.6" + } + }, + "node_modules/prompts": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", + "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==", + "dependencies": { + "kleur": "^3.0.3", + "sisteransi": "^1.0.5" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/prop-types/node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==" + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/proxy-addr/node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/psl": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz", + "integrity": "sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==" + }, + "node_modules/punycode": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", + "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==", + "engines": { + "node": ">=6" + } + }, + "node_modules/q": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz", + "integrity": "sha512-kV/CThkXo6xyFEZUugw/+pIOywXcDbFYgSct5cT3gqlbkBE1SJdwy6UQoZvodiWF/ckQLZyDE/Bu1M6gVu5lVw==", + "engines": { + "node": ">=0.6.0", + "teleport": ">=0.2.0" + } + }, + "node_modules/qs": { + "version": "6.11.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz", + "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==", + "dependencies": { + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/querystringify": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.2.0.tgz", + "integrity": "sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==" + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/quick-lru": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", + "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/raf": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/raf/-/raf-3.4.1.tgz", + "integrity": "sha512-Sq4CW4QhwOHE8ucn6J34MqtZCeWFP2aQSmrlroYgqAV1PjStIhJXxYuTgUIfkEk7zTLjmIjLmU5q+fbD1NnOJA==", + "dependencies": { + "performance-now": "^2.1.0" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz", + "integrity": "sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/raw-body/node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/raw-body/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react/-/react-18.2.0.tgz", + "integrity": "sha512-/3IjMdb2L9QbBdWiW5e3P2/npwMBaU9mHCSCUzNln0ZCYbcfTsGbTJrU/kGemdH2IWmB2ioZ+zkxtmq6g09fGQ==", + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-app-polyfill": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/react-app-polyfill/-/react-app-polyfill-3.0.0.tgz", + "integrity": "sha512-sZ41cxiU5llIB003yxxQBYrARBqe0repqPTTYBTmMqTz9szeBbE37BehCE891NZsmdZqqP+xWKdT3eo3vOzN8w==", + "dependencies": { + "core-js": "^3.19.2", + "object-assign": "^4.1.1", + "promise": "^8.1.0", + "raf": "^3.4.1", + "regenerator-runtime": "^0.13.9", + "whatwg-fetch": "^3.6.2" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/react-bpmn": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/react-bpmn/-/react-bpmn-0.2.0.tgz", + "integrity": "sha512-GBIlVw7On32k2IdCHbbN/2y9r7C5iLyzKvBmMclqQ/vMOXH5QEiCcO7qV/70LETvLLL1RZO/AhrvCIYD1pBZqQ==" + }, + "node_modules/react-dev-utils": { + "version": "12.0.1", + "resolved": "https://registry.npmjs.org/react-dev-utils/-/react-dev-utils-12.0.1.tgz", + "integrity": "sha512-84Ivxmr17KjUupyqzFode6xKhjwuEJDROWKJy/BthkL7Wn6NJ8h4WE6k/exAv6ImS+0oZLRRW5j/aINMHyeGeQ==", + "dependencies": { + "@babel/code-frame": "^7.16.0", + "address": "^1.1.2", + "browserslist": "^4.18.1", + "chalk": "^4.1.2", + "cross-spawn": "^7.0.3", + "detect-port-alt": "^1.1.6", + "escape-string-regexp": "^4.0.0", + "filesize": "^8.0.6", + "find-up": "^5.0.0", + "fork-ts-checker-webpack-plugin": "^6.5.0", + "global-modules": "^2.0.0", + "globby": "^11.0.4", + "gzip-size": "^6.0.0", + "immer": "^9.0.7", + "is-root": "^2.1.0", + "loader-utils": "^3.2.0", + "open": "^8.4.0", + "pkg-up": "^3.1.0", + "prompts": "^2.4.2", + "react-error-overlay": "^6.0.11", + "recursive-readdir": "^2.2.2", + "shell-quote": "^1.7.3", + "strip-ansi": "^6.0.1", + "text-table": "^0.2.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/react-dev-utils/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/react-dev-utils/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/react-dev-utils/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/react-dev-utils/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/react-dev-utils/node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dev-utils/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/react-dev-utils/node_modules/loader-utils": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-3.2.1.tgz", + "integrity": "sha512-ZvFw1KWS3GVyYBYb7qkmRM/WwL2TQQBxgCK62rlvm4WpVQ23Nb4tYjApUlfjrEGvOs7KHEsmyUn75OHZrJMWPw==", + "engines": { + "node": ">= 12.13.0" + } + }, + "node_modules/react-dev-utils/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/react-dom": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.2.0.tgz", + "integrity": "sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.0" + }, + "peerDependencies": { + "react": "^18.2.0" + } + }, + "node_modules/react-error-overlay": { + "version": "6.0.11", + "resolved": "https://registry.npmjs.org/react-error-overlay/-/react-error-overlay-6.0.11.tgz", + "integrity": "sha512-/6UZ2qgEyH2aqzYZgQPxEnz33NJ2gNsnHA2o5+o4wW9bLM/JYQitNP9xPhsXwC08hMMovfGe/8retsdDsczPRg==" + }, + "node_modules/react-icons": { + "version": "4.7.1", + "resolved": "https://registry.npmjs.org/react-icons/-/react-icons-4.7.1.tgz", + "integrity": "sha512-yHd3oKGMgm7zxo3EA7H2n7vxSoiGmHk5t6Ou4bXsfcgWyhfDKMpyKfhHR6Bjnn63c+YXBLBPUql9H4wPJM6sXw==", + "peerDependencies": { + "react": "*" + } + }, + "node_modules/react-is": { + "version": "17.0.2", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz", + "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==" + }, + "node_modules/react-refresh": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.11.0.tgz", + "integrity": "sha512-F27qZr8uUqwhWZboondsPx8tnC3Ct3SxZA3V5WyEvujRyyNv0VYPhoBg1gZ8/MV5tubQp76Trw8lTv9hzRBa+A==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-scripts": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/react-scripts/-/react-scripts-5.0.1.tgz", + "integrity": "sha512-8VAmEm/ZAwQzJ+GOMLbBsTdDKOpuZh7RPs0UymvBR2vRk4iZWCskjbFnxqjrzoIvlNNRZ3QJFx6/qDSi6zSnaQ==", + "dependencies": { + "@babel/core": "^7.16.0", + "@pmmmwh/react-refresh-webpack-plugin": "^0.5.3", + "@svgr/webpack": "^5.5.0", + "babel-jest": "^27.4.2", + "babel-loader": "^8.2.3", + "babel-plugin-named-asset-import": "^0.3.8", + "babel-preset-react-app": "^10.0.1", + "bfj": "^7.0.2", + "browserslist": "^4.18.1", + "camelcase": "^6.2.1", + "case-sensitive-paths-webpack-plugin": "^2.4.0", + "css-loader": "^6.5.1", + "css-minimizer-webpack-plugin": "^3.2.0", + "dotenv": "^10.0.0", + "dotenv-expand": "^5.1.0", + "eslint": "^8.3.0", + "eslint-config-react-app": "^7.0.1", + "eslint-webpack-plugin": "^3.1.1", + "file-loader": "^6.2.0", + "fs-extra": "^10.0.0", + "html-webpack-plugin": "^5.5.0", + "identity-obj-proxy": "^3.0.0", + "jest": "^27.4.3", + "jest-resolve": "^27.4.2", + "jest-watch-typeahead": "^1.0.0", + "mini-css-extract-plugin": "^2.4.5", + "postcss": "^8.4.4", + "postcss-flexbugs-fixes": "^5.0.2", + "postcss-loader": "^6.2.1", + "postcss-normalize": "^10.0.1", + "postcss-preset-env": "^7.0.1", + "prompts": "^2.4.2", + "react-app-polyfill": "^3.0.0", + "react-dev-utils": "^12.0.1", + "react-refresh": "^0.11.0", + "resolve": "^1.20.0", + "resolve-url-loader": "^4.0.0", + "sass-loader": "^12.3.0", + "semver": "^7.3.5", + "source-map-loader": "^3.0.0", + "style-loader": "^3.3.1", + "tailwindcss": "^3.0.2", + "terser-webpack-plugin": "^5.2.5", + "webpack": "^5.64.4", + "webpack-dev-server": "^4.6.0", + "webpack-manifest-plugin": "^4.0.2", + "workbox-webpack-plugin": "^6.4.1" + }, + "bin": { + "react-scripts": "bin/react-scripts.js" + }, + "engines": { + "node": ">=14.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + }, + "peerDependencies": { + "react": ">= 16", + "typescript": "^3.2.1 || ^4" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/read-cache": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", + "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", + "dependencies": { + "pify": "^2.3.0" + } + }, + "node_modules/readable-stream": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", + "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/recursive-readdir": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.3.tgz", + "integrity": "sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==", + "dependencies": { + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/redent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz", + "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==", + "dependencies": { + "indent-string": "^4.0.0", + "strip-indent": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/regenerate": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz", + "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==" + }, + "node_modules/regenerate-unicode-properties": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.1.0.tgz", + "integrity": "sha512-d1VudCLoIGitcU/hEg2QqvyGZQmdC0Lf8BqdOMXGFSvJP4bNV1+XqbPQeHHLD51Jh4QJJ225dlIFvY4Ly6MXmQ==", + "dependencies": { + "regenerate": "^1.4.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regenerator-runtime": { + "version": "0.13.11", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz", + "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==" + }, + "node_modules/regenerator-transform": { + "version": "0.15.1", + "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.1.tgz", + "integrity": "sha512-knzmNAcuyxV+gQCufkYcvOqX/qIIfHLv0u5x79kRxuGojfYVky1f15TzZEu2Avte8QGepvUNTnLskf8E6X6Vyg==", + "dependencies": { + "@babel/runtime": "^7.8.4" + } + }, + "node_modules/regex-parser": { + "version": "2.2.11", + "resolved": "https://registry.npmjs.org/regex-parser/-/regex-parser-2.2.11.tgz", + "integrity": "sha512-jbD/FT0+9MBU2XAZluI7w2OBs1RBi6p9M83nkoZayQXXU9e8Robt69FcZc7wU4eJD/YFTjn1JdCk3rbMJajz8Q==" + }, + "node_modules/regexp.prototype.flags": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz", + "integrity": "sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "functions-have-names": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/regexpp": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz", + "integrity": "sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/mysticatea" + } + }, + "node_modules/regexpu-core": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-5.2.2.tgz", + "integrity": "sha512-T0+1Zp2wjF/juXMrMxHxidqGYn8U4R+zleSJhX9tQ1PUsS8a9UtYfbsF9LdiVgNX3kiX8RNaKM42nfSgvFJjmw==", + "dependencies": { + "regenerate": "^1.4.2", + "regenerate-unicode-properties": "^10.1.0", + "regjsgen": "^0.7.1", + "regjsparser": "^0.9.1", + "unicode-match-property-ecmascript": "^2.0.0", + "unicode-match-property-value-ecmascript": "^2.1.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regjsgen": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.7.1.tgz", + "integrity": "sha512-RAt+8H2ZEzHeYWxZ3H2z6tF18zyyOnlcdaafLrm21Bguj7uZy6ULibiAFdXEtKQY4Sy7wDTwDiOazasMLc4KPA==" + }, + "node_modules/regjsparser": { + "version": "0.9.1", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.9.1.tgz", + "integrity": "sha512-dQUtn90WanSNl+7mQKcXAgZxvUe7Z0SqXlgzv0za4LwiUhyzBC58yQO3liFoUgu8GiJVInAhJjkj1N0EtQ5nkQ==", + "dependencies": { + "jsesc": "~0.5.0" + }, + "bin": { + "regjsparser": "bin/parser" + } + }, + "node_modules/regjsparser/node_modules/jsesc": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz", + "integrity": "sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==", + "bin": { + "jsesc": "bin/jsesc" + } + }, + "node_modules/relateurl": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/relateurl/-/relateurl-0.2.7.tgz", + "integrity": "sha512-G08Dxvm4iDN3MLM0EsP62EDV9IuhXPR6blNz6Utcp7zyV3tr4HVNINt6MpaRWbxoOHT3Q7YN2P+jaHX8vUbgog==", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/renderkid": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/renderkid/-/renderkid-3.0.0.tgz", + "integrity": "sha512-q/7VIQA8lmM1hF+jn+sFSPWGlMkSAeNYcPLmDQx2zzuiDfaLrOmumR8iaUKlenFgh0XRPIUeSPlH3A+AW3Z5pg==", + "dependencies": { + "css-select": "^4.1.3", + "dom-converter": "^0.2.0", + "htmlparser2": "^6.1.0", + "lodash": "^4.17.21", + "strip-ansi": "^6.0.1" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/requires-port": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz", + "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==" + }, + "node_modules/resolve": { + "version": "1.22.1", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz", + "integrity": "sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==", + "dependencies": { + "is-core-module": "^2.9.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dependencies": { + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-url-loader": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-url-loader/-/resolve-url-loader-4.0.0.tgz", + "integrity": "sha512-05VEMczVREcbtT7Bz+C+96eUO5HDNvdthIiMB34t7FcF8ehcu4wC0sSgPUubs3XW2Q3CNLJk/BJrCU9wVRymiA==", + "dependencies": { + "adjust-sourcemap-loader": "^4.0.0", + "convert-source-map": "^1.7.0", + "loader-utils": "^2.0.0", + "postcss": "^7.0.35", + "source-map": "0.6.1" + }, + "engines": { + "node": ">=8.9" + }, + "peerDependencies": { + "rework": "1.0.1", + "rework-visit": "1.0.0" + }, + "peerDependenciesMeta": { + "rework": { + "optional": true + }, + "rework-visit": { + "optional": true + } + } + }, + "node_modules/resolve-url-loader/node_modules/picocolors": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-0.2.1.tgz", + "integrity": "sha512-cMlDqaLEqfSaW8Z7N5Jw+lyIW869EzT73/F5lhtY9cLGoVxSXznfgfXMO0Z5K0o0Q2TkTXq+0KFsdnSe3jDViA==" + }, + "node_modules/resolve-url-loader/node_modules/postcss": { + "version": "7.0.39", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-7.0.39.tgz", + "integrity": "sha512-yioayjNbHn6z1/Bywyb2Y4s3yvDAeXGOyxqD+LnVOinq6Mdmd++SW2wUNVzavyyHxd6+DxzWGIuosg6P1Rj8uA==", + "dependencies": { + "picocolors": "^0.2.1", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + } + }, + "node_modules/resolve-url-loader/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve.exports": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-1.1.0.tgz", + "integrity": "sha512-J1l+Zxxp4XK3LUDZ9m60LRJF/mAe4z6a4xyabPHk7pvK5t35dACV32iIjJDFeWZFfZlO29w6SZ67knR0tHzJtQ==", + "engines": { + "node": ">=10" + } + }, + "node_modules/response-iterator": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/response-iterator/-/response-iterator-0.2.6.tgz", + "integrity": "sha512-pVzEEzrsg23Sh053rmDUvLSkGXluZio0qu8VT6ukrYuvtjVfCbDZH9d6PGXb8HZfzdNZt8feXv/jvUzlhRgLnw==", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/retry": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz", + "integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==", + "engines": { + "node": ">= 4" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/rollup": { + "version": "2.79.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.1.tgz", + "integrity": "sha512-uKxbd0IhMZOhjAiD5oAFp7BqvkA4Dv47qpOCtaNvng4HBwdbWtdOh8f5nZNuk2rp51PMGk3bzfWu5oayNEuYnw==", + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=10.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/rollup-plugin-terser": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/rollup-plugin-terser/-/rollup-plugin-terser-7.0.2.tgz", + "integrity": "sha512-w3iIaU4OxcF52UUXiZNsNeuXIMDvFrr+ZXK6bFZ0Q60qyVfq4uLptoS4bbq3paG3x216eQllFZX7zt6TIImguQ==", + "deprecated": "This package has been deprecated and is no longer maintained. Please use @rollup/plugin-terser", + "dependencies": { + "@babel/code-frame": "^7.10.4", + "jest-worker": "^26.2.1", + "serialize-javascript": "^4.0.0", + "terser": "^5.0.0" + }, + "peerDependencies": { + "rollup": "^2.0.0" + } + }, + "node_modules/rollup-plugin-terser/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/rollup-plugin-terser/node_modules/jest-worker": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz", + "integrity": "sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==", + "dependencies": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^7.0.0" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/rollup-plugin-terser/node_modules/serialize-javascript": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-4.0.0.tgz", + "integrity": "sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/rollup-plugin-terser/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/safe-regex-test": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", + "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "is-regex": "^1.1.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "node_modules/sanitize.css": { + "version": "13.0.0", + "resolved": "https://registry.npmjs.org/sanitize.css/-/sanitize.css-13.0.0.tgz", + "integrity": "sha512-ZRwKbh/eQ6w9vmTjkuG0Ioi3HBwPFce0O+v//ve+aOq1oeCy7jMV2qzzAlpsNuqpqCBjjriM1lbtZbF/Q8jVyA==" + }, + "node_modules/sass-loader": { + "version": "12.6.0", + "resolved": "https://registry.npmjs.org/sass-loader/-/sass-loader-12.6.0.tgz", + "integrity": "sha512-oLTaH0YCtX4cfnJZxKSLAyglED0naiYfNG1iXfU5w1LNZ+ukoA5DtyDIN5zmKVZwYNJP4KRc5Y3hkWga+7tYfA==", + "dependencies": { + "klona": "^2.0.4", + "neo-async": "^2.6.2" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "fibers": ">= 3.1.0", + "node-sass": "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0", + "sass": "^1.3.0", + "sass-embedded": "*", + "webpack": "^5.0.0" + }, + "peerDependenciesMeta": { + "fibers": { + "optional": true + }, + "node-sass": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + } + } + }, + "node_modules/sax": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", + "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==" + }, + "node_modules/saxen": { + "version": "8.1.2", + "resolved": "https://registry.npmjs.org/saxen/-/saxen-8.1.2.tgz", + "integrity": "sha512-xUOiiFbc3Ow7p8KMxwsGICPx46ZQvy3+qfNVhrkwfz3Vvq45eGt98Ft5IQaA1R/7Tb5B5MKh9fUR9x3c3nDTxw==" + }, + "node_modules/saxes": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/saxes/-/saxes-5.0.1.tgz", + "integrity": "sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==", + "dependencies": { + "xmlchars": "^2.2.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/scheduler": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.0.tgz", + "integrity": "sha512-CtuThmgHNg7zIZWAXi3AsyIzA3n4xx7aNyjwC2VJldO2LMVDhFK+63xGqq6CsJH4rTAt6/M+N4GhZiDYPx9eUw==", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/schema-utils": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.1.1.tgz", + "integrity": "sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==", + "dependencies": { + "@types/json-schema": "^7.0.8", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/select-hose": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/select-hose/-/select-hose-2.0.0.tgz", + "integrity": "sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg==" + }, + "node_modules/selfsigned": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.1.1.tgz", + "integrity": "sha512-GSL3aowiF7wa/WtSFwnUrludWFoNhftq8bUkH9pkzjpN2XSPOAYEgg6e0sS9s0rZwgJzJiQRPU18A6clnoW5wQ==", + "dependencies": { + "node-forge": "^1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver": { + "version": "7.3.8", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.8.tgz", + "integrity": "sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver/node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/send": { + "version": "0.18.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz", + "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "2.4.1", + "range-parser": "~1.2.1", + "statuses": "2.0.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/send/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/send/node_modules/debug/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + }, + "node_modules/serialize-javascript": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", + "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/serve-index": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/serve-index/-/serve-index-1.9.1.tgz", + "integrity": "sha512-pXHfKNP4qujrtteMrSBb0rc8HJ9Ms/GrXwcUtUtD5s4ewDJI8bT3Cz2zTVRMKtri49pLx2e0Ya8ziP5Ya2pZZw==", + "dependencies": { + "accepts": "~1.3.4", + "batch": "0.6.1", + "debug": "2.6.9", + "escape-html": "~1.0.3", + "http-errors": "~1.6.2", + "mime-types": "~2.1.17", + "parseurl": "~1.3.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/serve-index/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/serve-index/node_modules/depd": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", + "integrity": "sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-index/node_modules/http-errors": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", + "integrity": "sha512-lks+lVC8dgGyh97jxvxeYTWQFvh4uw4yC12gVl63Cg30sjPX4wuGcdkICVXDAESr6OJGjqGA8Iz5mkeN6zlD7A==", + "dependencies": { + "depd": "~1.1.2", + "inherits": "2.0.3", + "setprototypeof": "1.1.0", + "statuses": ">= 1.4.0 < 2" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-index/node_modules/inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==" + }, + "node_modules/serve-index/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/serve-index/node_modules/setprototypeof": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz", + "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==" + }, + "node_modules/serve-index/node_modules/statuses": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", + "integrity": "sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-static": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz", + "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==", + "dependencies": { + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "0.18.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "engines": { + "node": ">=8" + } + }, + "node_modules/shell-quote": { + "version": "1.7.4", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.7.4.tgz", + "integrity": "sha512-8o/QEhSSRb1a5i7TFR0iM4G16Z0vYB2OQVs4G3aAFXjn3T6yEx8AZxy1PgDF7I00LZHYA3WxaSYIf5e5sAX8Rw==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", + "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "dependencies": { + "call-bind": "^1.0.0", + "get-intrinsic": "^1.0.2", + "object-inspect": "^1.9.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==" + }, + "node_modules/sisteransi": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==" + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "engines": { + "node": ">=8" + } + }, + "node_modules/sockjs": { + "version": "0.3.24", + "resolved": "https://registry.npmjs.org/sockjs/-/sockjs-0.3.24.tgz", + "integrity": "sha512-GJgLTZ7vYb/JtPSSZ10hsOYIvEYsjbNU+zPdIHcUaWVNUEPivzxku31865sSSud0Da0W4lEeOPlmw93zLQchuQ==", + "dependencies": { + "faye-websocket": "^0.11.3", + "uuid": "^8.3.2", + "websocket-driver": "^0.7.4" + } + }, + "node_modules/source-list-map": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/source-list-map/-/source-list-map-2.0.1.tgz", + "integrity": "sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==" + }, + "node_modules/source-map": { + "version": "0.7.4", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz", + "integrity": "sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==", + "engines": { + "node": ">= 8" + } + }, + "node_modules/source-map-js": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.0.2.tgz", + "integrity": "sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-loader": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/source-map-loader/-/source-map-loader-3.0.2.tgz", + "integrity": "sha512-BokxPoLjyl3iOrgkWaakaxqnelAJSS+0V+De0kKIq6lyWrXuiPgYTGp6z3iHmqljKAaLXwZa+ctD8GccRJeVvg==", + "dependencies": { + "abab": "^2.0.5", + "iconv-lite": "^0.6.3", + "source-map-js": "^1.0.1" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/source-map-support/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/sourcemap-codec": { + "version": "1.4.8", + "resolved": "https://registry.npmjs.org/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz", + "integrity": "sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==", + "deprecated": "Please use @jridgewell/sourcemap-codec instead" + }, + "node_modules/spdy": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/spdy/-/spdy-4.0.2.tgz", + "integrity": "sha512-r46gZQZQV+Kl9oItvl1JZZqJKGr+oEkB08A6BzkiR7593/7IbtuncXHd2YoYeTsG4157ZssMu9KYvUHLcjcDoA==", + "dependencies": { + "debug": "^4.1.0", + "handle-thing": "^2.0.0", + "http-deceiver": "^1.2.7", + "select-hose": "^2.0.0", + "spdy-transport": "^3.0.0" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/spdy-transport": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/spdy-transport/-/spdy-transport-3.0.0.tgz", + "integrity": "sha512-hsLVFE5SjA6TCisWeJXFKniGGOpBgMLmerfO2aCyCU5s7nJ/rpAepqmFifv/GCbSbueEeAJJnmSQ2rKC/g8Fcw==", + "dependencies": { + "debug": "^4.1.0", + "detect-node": "^2.0.4", + "hpack.js": "^2.1.6", + "obuf": "^1.1.2", + "readable-stream": "^3.0.6", + "wbuf": "^1.7.3" + } + }, + "node_modules/sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==" + }, + "node_modules/stable": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/stable/-/stable-0.1.8.tgz", + "integrity": "sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==", + "deprecated": "Modern JS already guarantees Array#sort() is a stable sort, so this library is deprecated. See the compatibility table on MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#browser_compatibility" + }, + "node_modules/stack-utils": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz", + "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==", + "dependencies": { + "escape-string-regexp": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/stack-utils/node_modules/escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/stackframe": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/stackframe/-/stackframe-1.3.4.tgz", + "integrity": "sha512-oeVtt7eWQS+Na6F//S4kJ2K2VbRlS9D43mAlMyVpVWovy9o+jfgH8O9agzANzaiLjclA0oYzUXEM4PurhSUChw==" + }, + "node_modules/statuses": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/string-length": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz", + "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==", + "dependencies": { + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/string-natural-compare": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/string-natural-compare/-/string-natural-compare-3.0.1.tgz", + "integrity": "sha512-n3sPwynL1nwKi3WJ6AIsClwBMa0zTi54fn2oLU6ndfTSIO05xaznjSf15PcBZU6FNWbmN5Q6cxT4V5hGvB4taw==" + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "node_modules/string.prototype.matchall": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.8.tgz", + "integrity": "sha512-6zOCOcJ+RJAQshcTvXPHoxoQGONa3e/Lqx90wUA+wEzX78sg5Bo+1tQo4N0pohS0erG9qtCqJDjNCQBjeWVxyg==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "get-intrinsic": "^1.1.3", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.3", + "regexp.prototype.flags": "^1.4.3", + "side-channel": "^1.0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimend": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", + "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimstart": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", + "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/stringify-object": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz", + "integrity": "sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==", + "dependencies": { + "get-own-enumerable-property-symbols": "^3.0.0", + "is-obj": "^1.0.1", + "is-regexp": "^1.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-bom": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", + "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-comments/-/strip-comments-2.0.1.tgz", + "integrity": "sha512-ZprKx+bBLXv067WTCALv8SSz5l2+XhpYCsVtSqlMnkAXMWDq+/ekVbl1ghqP9rUHTzv6sm/DwCOiYutU/yp1fw==", + "engines": { + "node": ">=10" + } + }, + "node_modules/strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "engines": { + "node": ">=6" + } + }, + "node_modules/strip-indent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz", + "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==", + "dependencies": { + "min-indent": "^1.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/style-loader": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/style-loader/-/style-loader-3.3.1.tgz", + "integrity": "sha512-GPcQ+LDJbrcxHORTRes6Jy2sfvK2kS6hpSfI/fXhPt+spVzxF6LJ1dHLN9zIGmVaaP044YKaIatFaufENRiDoQ==", + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/style-mod": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/style-mod/-/style-mod-4.0.0.tgz", + "integrity": "sha512-OPhtyEjyyN9x3nhPsu76f52yUGXiZcgvsrFVtvTkyGRQJ0XK+GPc6ov1z+lRpbeabka+MYEQxOYRnt5nF30aMw==" + }, + "node_modules/stylehacks": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-5.1.1.tgz", + "integrity": "sha512-sBpcd5Hx7G6seo7b1LkpttvTz7ikD0LlH5RmdcBNb6fFR0Fl7LQwHDFr300q4cwUqi+IYrFGmsIHieMBfnN/Bw==", + "dependencies": { + "browserslist": "^4.21.4", + "postcss-selector-parser": "^6.0.4" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/supports-hyperlinks": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-2.3.0.tgz", + "integrity": "sha512-RpsAZlpWcDwOPQA22aCH4J0t7L8JmAvsCxfOSEwm7cQs3LshN36QaTkwd70DnBOXDWGssw2eUoc8CaRWT0XunA==", + "dependencies": { + "has-flag": "^4.0.0", + "supports-color": "^7.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-hyperlinks/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-hyperlinks/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/svg-parser": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/svg-parser/-/svg-parser-2.0.4.tgz", + "integrity": "sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ==" + }, + "node_modules/svgo": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-1.3.2.tgz", + "integrity": "sha512-yhy/sQYxR5BkC98CY7o31VGsg014AKLEPxdfhora76l36hD9Rdy5NZA/Ocn6yayNPgSamYdtX2rFJdcv07AYVw==", + "deprecated": "This SVGO version is no longer supported. Upgrade to v2.x.x.", + "dependencies": { + "chalk": "^2.4.1", + "coa": "^2.0.2", + "css-select": "^2.0.0", + "css-select-base-adapter": "^0.1.1", + "css-tree": "1.0.0-alpha.37", + "csso": "^4.0.2", + "js-yaml": "^3.13.1", + "mkdirp": "~0.5.1", + "object.values": "^1.1.0", + "sax": "~1.2.4", + "stable": "^0.1.8", + "unquote": "~1.1.1", + "util.promisify": "~1.0.0" + }, + "bin": { + "svgo": "bin/svgo" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/svgo/node_modules/css-select": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-2.1.0.tgz", + "integrity": "sha512-Dqk7LQKpwLoH3VovzZnkzegqNSuAziQyNZUcrdDM401iY+R5NkGBXGmtO05/yaXQziALuPogeG0b7UAgjnTJTQ==", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^3.2.1", + "domutils": "^1.7.0", + "nth-check": "^1.0.2" + } + }, + "node_modules/svgo/node_modules/css-what": { + "version": "3.4.2", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-3.4.2.tgz", + "integrity": "sha512-ACUm3L0/jiZTqfzRM3Hi9Q8eZqd6IK37mMWPLz9PJxkLWllYeRf+EHUSHYEtFop2Eqytaq1FizFVh7XfBnXCDQ==", + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/svgo/node_modules/dom-serializer": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.2.2.tgz", + "integrity": "sha512-2/xPb3ORsQ42nHYiSunXkDjPLBaEj/xTwUO4B7XCZQTRk7EBtTOPaygh10YAAh2OI1Qrp6NWfpAhzswj0ydt9g==", + "dependencies": { + "domelementtype": "^2.0.1", + "entities": "^2.0.0" + } + }, + "node_modules/svgo/node_modules/domutils": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-1.7.0.tgz", + "integrity": "sha512-Lgd2XcJ/NjEw+7tFvfKxOzCYKZsdct5lczQ2ZaQY8Djz7pfAD3Gbp8ySJWtreII/vDlMVmxwa6pHmdxIYgttDg==", + "dependencies": { + "dom-serializer": "0", + "domelementtype": "1" + } + }, + "node_modules/svgo/node_modules/domutils/node_modules/domelementtype": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.3.1.tgz", + "integrity": "sha512-BSKB+TSpMpFI/HOxCNr1O8aMOTZ8hT3pM3GQ0w/mWRmkhEDSFJkkyzz4XQsBV44BChwGkrDfMyjVD0eA2aFV3w==" + }, + "node_modules/svgo/node_modules/nth-check": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-1.0.2.tgz", + "integrity": "sha512-WeBOdju8SnzPN5vTUJYxYUxLeXpCaVP5i5e0LF8fg7WORF2Wd7wFX/pk0tYZk7s8T+J7VLy0Da6J1+wCT0AtHg==", + "dependencies": { + "boolbase": "~1.0.0" + } + }, + "node_modules/symbol-observable": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-4.0.0.tgz", + "integrity": "sha512-b19dMThMV4HVFynSAM1++gBHAbk2Tc/osgLIBZMKsyqh34jb2e8Os7T6ZW/Bt3pJFdBTd2JwAnAAEQV7rSNvcQ==", + "engines": { + "node": ">=0.10" + } + }, + "node_modules/symbol-tree": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz", + "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==" + }, + "node_modules/tailwindcss": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.2.4.tgz", + "integrity": "sha512-AhwtHCKMtR71JgeYDaswmZXhPcW9iuI9Sp2LvZPo9upDZ7231ZJ7eA9RaURbhpXGVlrjX4cFNlB4ieTetEb7hQ==", + "dependencies": { + "arg": "^5.0.2", + "chokidar": "^3.5.3", + "color-name": "^1.1.4", + "detective": "^5.2.1", + "didyoumean": "^1.2.2", + "dlv": "^1.1.3", + "fast-glob": "^3.2.12", + "glob-parent": "^6.0.2", + "is-glob": "^4.0.3", + "lilconfig": "^2.0.6", + "micromatch": "^4.0.5", + "normalize-path": "^3.0.0", + "object-hash": "^3.0.0", + "picocolors": "^1.0.0", + "postcss": "^8.4.18", + "postcss-import": "^14.1.0", + "postcss-js": "^4.0.0", + "postcss-load-config": "^3.1.4", + "postcss-nested": "6.0.0", + "postcss-selector-parser": "^6.0.10", + "postcss-value-parser": "^4.2.0", + "quick-lru": "^5.1.1", + "resolve": "^1.22.1" + }, + "bin": { + "tailwind": "lib/cli.js", + "tailwindcss": "lib/cli.js" + }, + "engines": { + "node": ">=12.13.0" + }, + "peerDependencies": { + "postcss": "^8.0.9" + } + }, + "node_modules/tailwindcss/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/tapable": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz", + "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==", + "engines": { + "node": ">=6" + } + }, + "node_modules/temp-dir": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/temp-dir/-/temp-dir-2.0.0.tgz", + "integrity": "sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==", + "engines": { + "node": ">=8" + } + }, + "node_modules/tempy": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tempy/-/tempy-0.6.0.tgz", + "integrity": "sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw==", + "dependencies": { + "is-stream": "^2.0.0", + "temp-dir": "^2.0.0", + "type-fest": "^0.16.0", + "unique-string": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/tempy/node_modules/type-fest": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.16.0.tgz", + "integrity": "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/terminal-link": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/terminal-link/-/terminal-link-2.1.1.tgz", + "integrity": "sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ==", + "dependencies": { + "ansi-escapes": "^4.2.1", + "supports-hyperlinks": "^2.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/terser": { + "version": "5.16.1", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.16.1.tgz", + "integrity": "sha512-xvQfyfA1ayT0qdK47zskQgRZeWLoOQ8JQ6mIgRGVNwZKdQMU+5FkCBjmv4QjcrTzyZquRw2FVtlJSRUmMKQslw==", + "dependencies": { + "@jridgewell/source-map": "^0.3.2", + "acorn": "^8.5.0", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "bin": { + "terser": "bin/terser" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/terser-webpack-plugin": { + "version": "5.3.6", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.6.tgz", + "integrity": "sha512-kfLFk+PoLUQIbLmB1+PZDMRSZS99Mp+/MHqDNmMA6tOItzRt+Npe3E+fsMs5mfcM0wCtrrdU387UnV+vnSffXQ==", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.14", + "jest-worker": "^27.4.5", + "schema-utils": "^3.1.1", + "serialize-javascript": "^6.0.0", + "terser": "^5.14.1" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.1.0" + }, + "peerDependenciesMeta": { + "@swc/core": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "uglify-js": { + "optional": true + } + } + }, + "node_modules/terser/node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==" + }, + "node_modules/test-exclude": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", + "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", + "dependencies": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^7.1.4", + "minimatch": "^3.0.4" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==" + }, + "node_modules/throat": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/throat/-/throat-6.0.1.tgz", + "integrity": "sha512-8hmiGIJMDlwjg7dlJ4yKGLK8EsYqKgPWbG3b4wjJddKNwc7N7Dpn08Df4szr/sZdMVeOstrdYSsqzX6BYbcB+w==" + }, + "node_modules/thunky": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz", + "integrity": "sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA==" + }, + "node_modules/ticky": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/ticky/-/ticky-1.0.1.tgz", + "integrity": "sha512-RX35iq/D+lrsqhcPWIazM9ELkjOe30MSeoBHQHSsRwd1YuhJO5ui1K1/R0r7N3mFvbLBs33idw+eR6j+w6i/DA==" + }, + "node_modules/tiny-svg": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/tiny-svg/-/tiny-svg-3.0.0.tgz", + "integrity": "sha512-+u6VomQO7MbI7CQe5q1IwNePpbVKG/HVdUQBmaEpSCdP/QmeyjhrS6WKFsNetXlvf9LWu/f5woRqjMdxBMe/0w==" + }, + "node_modules/tmpl": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz", + "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==" + }, + "node_modules/to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", + "engines": { + "node": ">=4" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/tough-cookie": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.2.tgz", + "integrity": "sha512-G9fqXWoYFZgTc2z8Q5zaHy/vJMjm+WV0AkAeHxVCQiEB1b+dGvWzFW6QV07cY5jQ5gRkeid2qIkzkxUnmoQZUQ==", + "dependencies": { + "psl": "^1.1.33", + "punycode": "^2.1.1", + "universalify": "^0.2.0", + "url-parse": "^1.5.3" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/tough-cookie/node_modules/universalify": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.2.0.tgz", + "integrity": "sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/tr46": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-2.1.0.tgz", + "integrity": "sha512-15Ih7phfcdP5YxqiB+iDtLoaTz4Nd35+IiAv0kQ5FNKHzXgdWqPoTIqEDDJmXceQt4JZk6lVPT8lnDlPpGDppw==", + "dependencies": { + "punycode": "^2.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/tryer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/tryer/-/tryer-1.0.1.tgz", + "integrity": "sha512-c3zayb8/kWWpycWYg87P71E1S1ZL6b6IJxfb5fvsUgsf0S2MVGaDhDXXjDMpdCpfWXqptc+4mXwmiy1ypXqRAA==" + }, + "node_modules/ts-invariant": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/ts-invariant/-/ts-invariant-0.10.3.tgz", + "integrity": "sha512-uivwYcQaxAucv1CzRp2n/QdYPo4ILf9VXgH19zEIjFx2EJufV16P0JtJVpYHy89DItG6Kwj2oIUjrcK5au+4tQ==", + "dependencies": { + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/tsconfig-paths": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.1.tgz", + "integrity": "sha512-fxDhWnFSLt3VuTwtvJt5fpwxBHg5AdKWMsgcPOOIilyjymcYVZoCQF8fvFRezCNfblEXmi+PcM1eYHeOAgXCOQ==", + "dependencies": { + "@types/json5": "^0.0.29", + "json5": "^1.0.1", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + } + }, + "node_modules/tsconfig-paths/node_modules/json5": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz", + "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==", + "dependencies": { + "minimist": "^1.2.0" + }, + "bin": { + "json5": "lib/cli.js" + } + }, + "node_modules/tsconfig-paths/node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "engines": { + "node": ">=4" + } + }, + "node_modules/tslib": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.1.tgz", + "integrity": "sha512-tGyy4dAjRIEwI7BzsB0lynWgOpfqjUdq91XXAlIWD2OwKBH7oCl/GZG/HT4BOHrTlPMOASlMQ7veyTqpmRcrNA==" + }, + "node_modules/tsutils": { + "version": "3.21.0", + "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz", + "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==", + "dependencies": { + "tslib": "^1.8.1" + }, + "engines": { + "node": ">= 6" + }, + "peerDependencies": { + "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta" + } + }, + "node_modules/tsutils/node_modules/tslib": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==" + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "engines": { + "node": ">=4" + } + }, + "node_modules/type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "dependencies": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/typedarray-to-buffer": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", + "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", + "dependencies": { + "is-typedarray": "^1.0.0" + } + }, + "node_modules/typescript": { + "version": "4.9.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.4.tgz", + "integrity": "sha512-Uz+dTXYzxXXbsFpM86Wh3dKCxrQqUcVMxwU54orwlJjOpO3ao8L7j5lH+dWfTwgCwIuM9GQ2kvVotzYJMXTBZg==", + "peer": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dependencies": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/unicode-canonical-property-names-ecmascript": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.0.tgz", + "integrity": "sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-match-property-ecmascript": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz", + "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==", + "dependencies": { + "unicode-canonical-property-names-ecmascript": "^2.0.0", + "unicode-property-aliases-ecmascript": "^2.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-match-property-value-ecmascript": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.1.0.tgz", + "integrity": "sha512-qxkjQt6qjg/mYscYMC0XKRn3Rh0wFPlfxB0xkt9CfyTvpX1Ra0+rAmdX2QyAobptSEvuy4RtpPRui6XkV+8wjA==", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-property-aliases-ecmascript": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.1.0.tgz", + "integrity": "sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==", + "engines": { + "node": ">=4" + } + }, + "node_modules/unique-string": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz", + "integrity": "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==", + "dependencies": { + "crypto-random-string": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/universalify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz", + "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/unquote": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/unquote/-/unquote-1.1.1.tgz", + "integrity": "sha512-vRCqFv6UhXpWxZPyGDh/F3ZpNv8/qo7w6iufLpQg9aKnQ71qM4B5KiI7Mia9COcjEhrO9LueHpMYjYzsWH3OIg==" + }, + "node_modules/upath": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", + "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", + "engines": { + "node": ">=4", + "yarn": "*" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz", + "integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + } + ], + "dependencies": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + }, + "bin": { + "browserslist-lint": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/url-parse": { + "version": "1.5.10", + "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.10.tgz", + "integrity": "sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==", + "dependencies": { + "querystringify": "^2.1.1", + "requires-port": "^1.0.0" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==" + }, + "node_modules/util.promisify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/util.promisify/-/util.promisify-1.0.1.tgz", + "integrity": "sha512-g9JpC/3He3bm38zsLupWryXHoEcS22YHthuPQSJdMy6KNrzIRzWqcsHzD/WUnqe45whVou4VIsPew37DoXWNrA==", + "dependencies": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.2", + "has-symbols": "^1.0.1", + "object.getownpropertydescriptors": "^2.1.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/utila": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/utila/-/utila-0.4.0.tgz", + "integrity": "sha512-Z0DbgELS9/L/75wZbro8xAnT50pBVFQZ+hUEueGDU5FN51YSCYM+jdxsfCiHjwNP/4LCDD0i/graKpeBnOXKRA==" + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/v8-to-istanbul": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-8.1.1.tgz", + "integrity": "sha512-FGtKtv3xIpR6BYhvgH8MI/y78oT7d8Au3ww4QIxymrCtZEh5b8gCw2siywE+puhEmuWKDtmfrvF5UlB298ut3w==", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^1.6.0", + "source-map": "^0.7.3" + }, + "engines": { + "node": ">=10.12.0" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/w3c-hr-time": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/w3c-hr-time/-/w3c-hr-time-1.0.2.tgz", + "integrity": "sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==", + "deprecated": "Use your platform's native performance.now() and performance.timeOrigin.", + "dependencies": { + "browser-process-hrtime": "^1.0.0" + } + }, + "node_modules/w3c-keyname": { + "version": "2.2.6", + "resolved": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.6.tgz", + "integrity": "sha512-f+fciywl1SJEniZHD6H+kUO8gOnwIr7f4ijKA6+ZvJFjeGi1r4PDLl53Ayud9O/rk64RqgoQine0feoeOU0kXg==" + }, + "node_modules/w3c-xmlserializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-2.0.0.tgz", + "integrity": "sha512-4tzD0mF8iSiMiNs30BiLO3EpfGLZUT2MSX/G+o7ZywDzliWQ3OPtTZ0PTC3B3ca1UAf4cJMHB+2Bf56EriJuRA==", + "dependencies": { + "xml-name-validator": "^3.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/walker": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz", + "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==", + "dependencies": { + "makeerror": "1.0.12" + } + }, + "node_modules/watchpack": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz", + "integrity": "sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==", + "dependencies": { + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.1.2" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/wbuf": { + "version": "1.7.3", + "resolved": "https://registry.npmjs.org/wbuf/-/wbuf-1.7.3.tgz", + "integrity": "sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==", + "dependencies": { + "minimalistic-assert": "^1.0.0" + } + }, + "node_modules/web-vitals": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/web-vitals/-/web-vitals-2.1.4.tgz", + "integrity": "sha512-sVWcwhU5mX6crfI5Vd2dC4qchyTqxV8URinzt25XqVh+bHEPGH4C3NPrNionCP7Obx59wrYEbNlw4Z8sjALzZg==" + }, + "node_modules/webidl-conversions": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-6.1.0.tgz", + "integrity": "sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w==", + "engines": { + "node": ">=10.4" + } + }, + "node_modules/webpack": { + "version": "5.75.0", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.75.0.tgz", + "integrity": "sha512-piaIaoVJlqMsPtX/+3KTTO6jfvrSYgauFVdt8cr9LTHKmcq/AMd4mhzsiP7ZF/PGRNPGA8336jldh9l2Kt2ogQ==", + "dependencies": { + "@types/eslint-scope": "^3.7.3", + "@types/estree": "^0.0.51", + "@webassemblyjs/ast": "1.11.1", + "@webassemblyjs/wasm-edit": "1.11.1", + "@webassemblyjs/wasm-parser": "1.11.1", + "acorn": "^8.7.1", + "acorn-import-assertions": "^1.7.6", + "browserslist": "^4.14.5", + "chrome-trace-event": "^1.0.2", + "enhanced-resolve": "^5.10.0", + "es-module-lexer": "^0.9.0", + "eslint-scope": "5.1.1", + "events": "^3.2.0", + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.2.9", + "json-parse-even-better-errors": "^2.3.1", + "loader-runner": "^4.2.0", + "mime-types": "^2.1.27", + "neo-async": "^2.6.2", + "schema-utils": "^3.1.0", + "tapable": "^2.1.1", + "terser-webpack-plugin": "^5.1.3", + "watchpack": "^2.4.0", + "webpack-sources": "^3.2.3" + }, + "bin": { + "webpack": "bin/webpack.js" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependenciesMeta": { + "webpack-cli": { + "optional": true + } + } + }, + "node_modules/webpack-dev-middleware": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-5.3.3.tgz", + "integrity": "sha512-hj5CYrY0bZLB+eTO+x/j67Pkrquiy7kWepMHmUMoPsmcUaeEnQJqFzHJOyxgWlq746/wUuA64p9ta34Kyb01pA==", + "dependencies": { + "colorette": "^2.0.10", + "memfs": "^3.4.3", + "mime-types": "^2.1.31", + "range-parser": "^1.2.1", + "schema-utils": "^4.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^4.0.0 || ^5.0.0" + } + }, + "node_modules/webpack-dev-middleware/node_modules/ajv": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz", + "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/webpack-dev-middleware/node_modules/ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/webpack-dev-middleware/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + }, + "node_modules/webpack-dev-middleware/node_modules/schema-utils": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", + "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", + "dependencies": { + "@types/json-schema": "^7.0.9", + "ajv": "^8.8.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/webpack-dev-server": { + "version": "4.11.1", + "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.11.1.tgz", + "integrity": "sha512-lILVz9tAUy1zGFwieuaQtYiadImb5M3d+H+L1zDYalYoDl0cksAB1UNyuE5MMWJrG6zR1tXkCP2fitl7yoUJiw==", + "dependencies": { + "@types/bonjour": "^3.5.9", + "@types/connect-history-api-fallback": "^1.3.5", + "@types/express": "^4.17.13", + "@types/serve-index": "^1.9.1", + "@types/serve-static": "^1.13.10", + "@types/sockjs": "^0.3.33", + "@types/ws": "^8.5.1", + "ansi-html-community": "^0.0.8", + "bonjour-service": "^1.0.11", + "chokidar": "^3.5.3", + "colorette": "^2.0.10", + "compression": "^1.7.4", + "connect-history-api-fallback": "^2.0.0", + "default-gateway": "^6.0.3", + "express": "^4.17.3", + "graceful-fs": "^4.2.6", + "html-entities": "^2.3.2", + "http-proxy-middleware": "^2.0.3", + "ipaddr.js": "^2.0.1", + "open": "^8.0.9", + "p-retry": "^4.5.0", + "rimraf": "^3.0.2", + "schema-utils": "^4.0.0", + "selfsigned": "^2.1.1", + "serve-index": "^1.9.1", + "sockjs": "^0.3.24", + "spdy": "^4.0.2", + "webpack-dev-middleware": "^5.3.1", + "ws": "^8.4.2" + }, + "bin": { + "webpack-dev-server": "bin/webpack-dev-server.js" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^4.37.0 || ^5.0.0" + }, + "peerDependenciesMeta": { + "webpack-cli": { + "optional": true + } + } + }, + "node_modules/webpack-dev-server/node_modules/ajv": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz", + "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/webpack-dev-server/node_modules/ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/webpack-dev-server/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + }, + "node_modules/webpack-dev-server/node_modules/schema-utils": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", + "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", + "dependencies": { + "@types/json-schema": "^7.0.9", + "ajv": "^8.8.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/webpack-dev-server/node_modules/ws": { + "version": "8.11.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.11.0.tgz", + "integrity": "sha512-HPG3wQd9sNQoT9xHyNCXoDUa+Xw/VevmY9FoHyQ+g+rrMn4j6FB4np7Z0OhdTgjx6MgQLK7jwSy1YecU1+4Asg==", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/webpack-manifest-plugin": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/webpack-manifest-plugin/-/webpack-manifest-plugin-4.1.1.tgz", + "integrity": "sha512-YXUAwxtfKIJIKkhg03MKuiFAD72PlrqCiwdwO4VEXdRO5V0ORCNwaOwAZawPZalCbmH9kBDmXnNeQOw+BIEiow==", + "dependencies": { + "tapable": "^2.0.0", + "webpack-sources": "^2.2.0" + }, + "engines": { + "node": ">=12.22.0" + }, + "peerDependencies": { + "webpack": "^4.44.2 || ^5.47.0" + } + }, + "node_modules/webpack-manifest-plugin/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/webpack-manifest-plugin/node_modules/webpack-sources": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-2.3.1.tgz", + "integrity": "sha512-y9EI9AO42JjEcrTJFOYmVywVZdKVUfOvDUPsJea5GIr1JOEGFVqwlY2K098fFoIjOkDzHn2AjRvM8dsBZu+gCA==", + "dependencies": { + "source-list-map": "^2.0.1", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/webpack-sources": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz", + "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==", + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/webpack/node_modules/@types/estree": { + "version": "0.0.51", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.51.tgz", + "integrity": "sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==" + }, + "node_modules/webpack/node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/webpack/node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/websocket-driver": { + "version": "0.7.4", + "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz", + "integrity": "sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==", + "dependencies": { + "http-parser-js": ">=0.5.1", + "safe-buffer": ">=5.1.0", + "websocket-extensions": ">=0.1.1" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/websocket-extensions": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/websocket-extensions/-/websocket-extensions-0.1.4.tgz", + "integrity": "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/whatwg-encoding": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-1.0.5.tgz", + "integrity": "sha512-b5lim54JOPN9HtzvK9HFXvBma/rnfFeqsic0hSpjtDbVxR3dJKLc+KB4V6GgiGOvl7CY/KNh8rxSo9DKQrnUEw==", + "dependencies": { + "iconv-lite": "0.4.24" + } + }, + "node_modules/whatwg-encoding/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/whatwg-fetch": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/whatwg-fetch/-/whatwg-fetch-3.6.2.tgz", + "integrity": "sha512-bJlen0FcuU/0EMLrdbJ7zOnW6ITZLrZMIarMUVmdKtsGvZna8vxKYaexICWPfZ8qwf9fzNq+UEIZrnSaApt6RA==" + }, + "node_modules/whatwg-mimetype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-2.3.0.tgz", + "integrity": "sha512-M4yMwr6mAnQz76TbJm914+gPpB/nCwvZbJU28cUD6dR004SAxDLOOSUaB1JDRqLtaOV/vi0IC5lEAGFgrjGv/g==" + }, + "node_modules/whatwg-url": { + "version": "8.7.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-8.7.0.tgz", + "integrity": "sha512-gAojqb/m9Q8a5IV96E3fHJM70AzCkgt4uXYX2O7EmuyOnLrViCQlsEBmF9UQIu3/aeAIp2U17rtbpZWNntQqdg==", + "dependencies": { + "lodash": "^4.7.0", + "tr46": "^2.1.0", + "webidl-conversions": "^6.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/which-boxed-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", + "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "dependencies": { + "is-bigint": "^1.0.1", + "is-boolean-object": "^1.1.0", + "is-number-object": "^1.0.4", + "is-string": "^1.0.5", + "is-symbol": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-collection": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.1.tgz", + "integrity": "sha512-W8xeTUwaln8i3K/cY1nGXzdnVZlidBcagyNFtBdD5kxnb4TvGKR7FfSIS3mYpwWS1QUCutfKz8IY8RjftB0+1A==", + "dependencies": { + "is-map": "^2.0.1", + "is-set": "^2.0.1", + "is-weakmap": "^2.0.1", + "is-weakset": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-typed-array": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz", + "integrity": "sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==", + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0", + "is-typed-array": "^1.1.10" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/word-wrap": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", + "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/workbox-background-sync": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-background-sync/-/workbox-background-sync-6.5.4.tgz", + "integrity": "sha512-0r4INQZMyPky/lj4Ou98qxcThrETucOde+7mRGJl13MPJugQNKeZQOdIJe/1AchOP23cTqHcN/YVpD6r8E6I8g==", + "dependencies": { + "idb": "^7.0.1", + "workbox-core": "6.5.4" + } + }, + "node_modules/workbox-broadcast-update": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-broadcast-update/-/workbox-broadcast-update-6.5.4.tgz", + "integrity": "sha512-I/lBERoH1u3zyBosnpPEtcAVe5lwykx9Yg1k6f8/BGEPGaMMgZrwVrqL1uA9QZ1NGGFoyE6t9i7lBjOlDhFEEw==", + "dependencies": { + "workbox-core": "6.5.4" + } + }, + "node_modules/workbox-build": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-build/-/workbox-build-6.5.4.tgz", + "integrity": "sha512-kgRevLXEYvUW9WS4XoziYqZ8Q9j/2ziJYEtTrjdz5/L/cTUa2XfyMP2i7c3p34lgqJ03+mTiz13SdFef2POwbA==", + "dependencies": { + "@apideck/better-ajv-errors": "^0.3.1", + "@babel/core": "^7.11.1", + "@babel/preset-env": "^7.11.0", + "@babel/runtime": "^7.11.2", + "@rollup/plugin-babel": "^5.2.0", + "@rollup/plugin-node-resolve": "^11.2.1", + "@rollup/plugin-replace": "^2.4.1", + "@surma/rollup-plugin-off-main-thread": "^2.2.3", + "ajv": "^8.6.0", + "common-tags": "^1.8.0", + "fast-json-stable-stringify": "^2.1.0", + "fs-extra": "^9.0.1", + "glob": "^7.1.6", + "lodash": "^4.17.20", + "pretty-bytes": "^5.3.0", + "rollup": "^2.43.1", + "rollup-plugin-terser": "^7.0.0", + "source-map": "^0.8.0-beta.0", + "stringify-object": "^3.3.0", + "strip-comments": "^2.0.1", + "tempy": "^0.6.0", + "upath": "^1.2.0", + "workbox-background-sync": "6.5.4", + "workbox-broadcast-update": "6.5.4", + "workbox-cacheable-response": "6.5.4", + "workbox-core": "6.5.4", + "workbox-expiration": "6.5.4", + "workbox-google-analytics": "6.5.4", + "workbox-navigation-preload": "6.5.4", + "workbox-precaching": "6.5.4", + "workbox-range-requests": "6.5.4", + "workbox-recipes": "6.5.4", + "workbox-routing": "6.5.4", + "workbox-strategies": "6.5.4", + "workbox-streams": "6.5.4", + "workbox-sw": "6.5.4", + "workbox-window": "6.5.4" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/workbox-build/node_modules/@apideck/better-ajv-errors": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/@apideck/better-ajv-errors/-/better-ajv-errors-0.3.6.tgz", + "integrity": "sha512-P+ZygBLZtkp0qqOAJJVX4oX/sFo5JR3eBWwwuqHHhK0GIgQOKWrAfiAaWX0aArHkRWHMuggFEgAZNxVPwPZYaA==", + "dependencies": { + "json-schema": "^0.4.0", + "jsonpointer": "^5.0.0", + "leven": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "ajv": ">=8" + } + }, + "node_modules/workbox-build/node_modules/ajv": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz", + "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/workbox-build/node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/workbox-build/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + }, + "node_modules/workbox-build/node_modules/source-map": { + "version": "0.8.0-beta.0", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.8.0-beta.0.tgz", + "integrity": "sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==", + "dependencies": { + "whatwg-url": "^7.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/workbox-build/node_modules/tr46": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-1.0.1.tgz", + "integrity": "sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/workbox-build/node_modules/webidl-conversions": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz", + "integrity": "sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==" + }, + "node_modules/workbox-build/node_modules/whatwg-url": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-7.1.0.tgz", + "integrity": "sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==", + "dependencies": { + "lodash.sortby": "^4.7.0", + "tr46": "^1.0.1", + "webidl-conversions": "^4.0.2" + } + }, + "node_modules/workbox-cacheable-response": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-cacheable-response/-/workbox-cacheable-response-6.5.4.tgz", + "integrity": "sha512-DCR9uD0Fqj8oB2TSWQEm1hbFs/85hXXoayVwFKLVuIuxwJaihBsLsp4y7J9bvZbqtPJ1KlCkmYVGQKrBU4KAug==", + "dependencies": { + "workbox-core": "6.5.4" + } + }, + "node_modules/workbox-core": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-core/-/workbox-core-6.5.4.tgz", + "integrity": "sha512-OXYb+m9wZm8GrORlV2vBbE5EC1FKu71GGp0H4rjmxmF4/HLbMCoTFws87M3dFwgpmg0v00K++PImpNQ6J5NQ6Q==" + }, + "node_modules/workbox-expiration": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-expiration/-/workbox-expiration-6.5.4.tgz", + "integrity": "sha512-jUP5qPOpH1nXtjGGh1fRBa1wJL2QlIb5mGpct3NzepjGG2uFFBn4iiEBiI9GUmfAFR2ApuRhDydjcRmYXddiEQ==", + "dependencies": { + "idb": "^7.0.1", + "workbox-core": "6.5.4" + } + }, + "node_modules/workbox-google-analytics": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-google-analytics/-/workbox-google-analytics-6.5.4.tgz", + "integrity": "sha512-8AU1WuaXsD49249Wq0B2zn4a/vvFfHkpcFfqAFHNHwln3jK9QUYmzdkKXGIZl9wyKNP+RRX30vcgcyWMcZ9VAg==", + "dependencies": { + "workbox-background-sync": "6.5.4", + "workbox-core": "6.5.4", + "workbox-routing": "6.5.4", + "workbox-strategies": "6.5.4" + } + }, + "node_modules/workbox-navigation-preload": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-navigation-preload/-/workbox-navigation-preload-6.5.4.tgz", + "integrity": "sha512-IIwf80eO3cr8h6XSQJF+Hxj26rg2RPFVUmJLUlM0+A2GzB4HFbQyKkrgD5y2d84g2IbJzP4B4j5dPBRzamHrng==", + "dependencies": { + "workbox-core": "6.5.4" + } + }, + "node_modules/workbox-precaching": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-precaching/-/workbox-precaching-6.5.4.tgz", + "integrity": "sha512-hSMezMsW6btKnxHB4bFy2Qfwey/8SYdGWvVIKFaUm8vJ4E53JAY+U2JwLTRD8wbLWoP6OVUdFlXsTdKu9yoLTg==", + "dependencies": { + "workbox-core": "6.5.4", + "workbox-routing": "6.5.4", + "workbox-strategies": "6.5.4" + } + }, + "node_modules/workbox-range-requests": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-range-requests/-/workbox-range-requests-6.5.4.tgz", + "integrity": "sha512-Je2qR1NXCFC8xVJ/Lux6saH6IrQGhMpDrPXWZWWS8n/RD+WZfKa6dSZwU+/QksfEadJEr/NfY+aP/CXFFK5JFg==", + "dependencies": { + "workbox-core": "6.5.4" + } + }, + "node_modules/workbox-recipes": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-recipes/-/workbox-recipes-6.5.4.tgz", + "integrity": "sha512-QZNO8Ez708NNwzLNEXTG4QYSKQ1ochzEtRLGaq+mr2PyoEIC1xFW7MrWxrONUxBFOByksds9Z4//lKAX8tHyUA==", + "dependencies": { + "workbox-cacheable-response": "6.5.4", + "workbox-core": "6.5.4", + "workbox-expiration": "6.5.4", + "workbox-precaching": "6.5.4", + "workbox-routing": "6.5.4", + "workbox-strategies": "6.5.4" + } + }, + "node_modules/workbox-routing": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-routing/-/workbox-routing-6.5.4.tgz", + "integrity": "sha512-apQswLsbrrOsBUWtr9Lf80F+P1sHnQdYodRo32SjiByYi36IDyL2r7BH1lJtFX8fwNHDa1QOVY74WKLLS6o5Pg==", + "dependencies": { + "workbox-core": "6.5.4" + } + }, + "node_modules/workbox-strategies": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-strategies/-/workbox-strategies-6.5.4.tgz", + "integrity": "sha512-DEtsxhx0LIYWkJBTQolRxG4EI0setTJkqR4m7r4YpBdxtWJH1Mbg01Cj8ZjNOO8etqfA3IZaOPHUxCs8cBsKLw==", + "dependencies": { + "workbox-core": "6.5.4" + } + }, + "node_modules/workbox-streams": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-streams/-/workbox-streams-6.5.4.tgz", + "integrity": "sha512-FXKVh87d2RFXkliAIheBojBELIPnWbQdyDvsH3t74Cwhg0fDheL1T8BqSM86hZvC0ZESLsznSYWw+Va+KVbUzg==", + "dependencies": { + "workbox-core": "6.5.4", + "workbox-routing": "6.5.4" + } + }, + "node_modules/workbox-sw": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-sw/-/workbox-sw-6.5.4.tgz", + "integrity": "sha512-vo2RQo7DILVRoH5LjGqw3nphavEjK4Qk+FenXeUsknKn14eCNedHOXWbmnvP4ipKhlE35pvJ4yl4YYf6YsJArA==" + }, + "node_modules/workbox-webpack-plugin": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-webpack-plugin/-/workbox-webpack-plugin-6.5.4.tgz", + "integrity": "sha512-LmWm/zoaahe0EGmMTrSLUi+BjyR3cdGEfU3fS6PN1zKFYbqAKuQ+Oy/27e4VSXsyIwAw8+QDfk1XHNGtZu9nQg==", + "dependencies": { + "fast-json-stable-stringify": "^2.1.0", + "pretty-bytes": "^5.4.1", + "upath": "^1.2.0", + "webpack-sources": "^1.4.3", + "workbox-build": "6.5.4" + }, + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "webpack": "^4.4.0 || ^5.9.0" + } + }, + "node_modules/workbox-webpack-plugin/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/workbox-webpack-plugin/node_modules/webpack-sources": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.4.3.tgz", + "integrity": "sha512-lgTS3Xhv1lCOKo7SA5TjKXMjpSM4sBjNV5+q2bqesbSPs5FjGmU6jjtBSkX9b4qW87vDIsCIlUPOEhbZrMdjeQ==", + "dependencies": { + "source-list-map": "^2.0.0", + "source-map": "~0.6.1" + } + }, + "node_modules/workbox-window": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/workbox-window/-/workbox-window-6.5.4.tgz", + "integrity": "sha512-HnLZJDwYBE+hpG25AQBO8RUWBJRaCsI9ksQJEp3aCOFCaG5kqaToAYXFRAHxzRluM2cQbGzdQF5rjKPWPA1fug==", + "dependencies": { + "@types/trusted-types": "^2.0.2", + "workbox-core": "6.5.4" + } + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/wrap-ansi/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" + }, + "node_modules/write-file-atomic": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz", + "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==", + "dependencies": { + "imurmurhash": "^0.1.4", + "is-typedarray": "^1.0.0", + "signal-exit": "^3.0.2", + "typedarray-to-buffer": "^3.1.5" + } + }, + "node_modules/ws": { + "version": "7.5.9", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz", + "integrity": "sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==", + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/xml-name-validator": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-3.0.0.tgz", + "integrity": "sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw==" + }, + "node_modules/xmlchars": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz", + "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==" + }, + "node_modules/xtend": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", + "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "engines": { + "node": ">=0.4" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "engines": { + "node": ">=10" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==" + }, + "node_modules/yaml": { + "version": "1.10.2", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz", + "integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==", + "engines": { + "node": ">= 6" + } + }, + "node_modules/yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "dependencies": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-parser": { + "version": "20.2.9", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz", + "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==", + "engines": { + "node": ">=10" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zen-observable": { + "version": "0.8.15", + "resolved": "https://registry.npmjs.org/zen-observable/-/zen-observable-0.8.15.tgz", + "integrity": "sha512-PQ2PC7R9rslx84ndNBZB/Dkv8V8fZEpk83RLgXtYd0fwUgEjseMn1Dgajh2x6S8QbZAFa9p2qVCEuYZNgve0dQ==" + }, + "node_modules/zen-observable-ts": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/zen-observable-ts/-/zen-observable-ts-1.2.5.tgz", + "integrity": "sha512-QZWQekv6iB72Naeake9hS1KxHlotfRpe+WGNbNx5/ta+R3DNjVO2bswf63gXlWDcs+EMd7XY8HfVQyP1X6T4Zg==", + "dependencies": { + "zen-observable": "0.8.15" + } + } + } +} diff --git a/custom-tasklist-exporter-based/tasklist/client/package.json b/custom-tasklist-exporter-based/tasklist/client/package.json new file mode 100644 index 00000000..7f16a71a --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/package.json @@ -0,0 +1,49 @@ +{ + "name": "tasklist", + "version": "0.1.0", + "private": true, + "dependencies": { + "@apollo/client": "^3.7.4", + "@bpmn-io/form-js": "^0.10.1", + "@bpmn-io/form-js-viewer": "^0.10.1", + "@testing-library/jest-dom": "^5.16.5", + "@testing-library/react": "^13.4.0", + "@testing-library/user-event": "^13.5.0", + "bootstrap": "^5.2.3", + "bootstrap-icons": "^1.10.3", + "bpmn-js": "^11.1.0", + "graphql": "^16.6.0", + "react": "^18.2.0", + "react-bpmn": "^0.2.0", + "react-dom": "^18.2.0", + "react-icons": "^4.7.1", + "react-scripts": "5.0.1", + "web-vitals": "^2.1.4" + }, + "scripts": { + "start": "react-scripts start", + "build": "react-scripts build", + "test": "react-scripts test", + "eject": "react-scripts eject" + }, + "eslintConfig": { + "extends": [ + "react-app", + "react-app/jest" + ] + }, + "browserslist": { + "production": [ + ">0.2%", + "not dead", + "not op_mini all" + ], + "development": [ + "last 1 chrome version", + "last 1 firefox version", + "last 1 safari version" + ] + }, + + "proxy": "http://localhost:8083" +} diff --git a/custom-tasklist-exporter-based/tasklist/client/public/favicon.ico b/custom-tasklist-exporter-based/tasklist/client/public/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..17790053871a76348ffdee8d4dce91ff5887f840 GIT binary patch literal 15406 zcmeI2Ux-yj9LHyM^KbswO$_w5Y}@KXEM%4vl0pxG1koSXMa&0vMFk5@qqLrU3PfKl z(MrXjgs6vJq7n&p6<_=ZMhY&vk_wfTS(&My@7_B&jOU)a_ug~PJ-ePCe0Ju{ocaBJ z^E-3q%*dZhhdbAV6O3u$9-7c1UrrLI z3_*EAg$5p^-9h*TrdOcjTiW~$Kf!PCBv@Ha=9>_9P`4AF2cl+9z*Tq(B)w^$zcc@L zJjpRQ;ue;fAHn^T%4}23?Hg&l+oPilg}1o(BBWa}u zU0D0=)ZY%FtI&QM>2n1%o~(VcCFL4-_%;reY<2gBhsi$fG45`4x^tRma_}r@e#)dz zM4%BbUxYz5@K&F%-$Cz;=H{W0l(b?<^OO6&e#iB&1RR)#jVqpQ>&HIIhllv^GIhn~ zz*6OJ&{og;3|M>T$iEK%Ic59F2l*h|wq2#E>|H46=_Zvwl2^g?;Rmj@9&jZp`%_W6 z7N)q$$-e|Q!1nC`d3}Rji6Z{4K0mK_@n5h$Z1rzQ;Q9r}hb;-%3o`Kpg^M7`IU&f8 ztStHnXl|JccAZr$ogTgE9*u|jYu~R@>53S9&^oo0U0c69M*G*%E&V?F4kls$=OTU6 zcu1pt?ZrAlepkXp+Pwqz`Ip=Om9({SsWjF8xKjI#v^`ga4>xJMxeEIfVB=MdvH?VL=JzQ9l4O$s*8iBA{~;Z9W%4c1}VN zGRY!ve?;H`x~cD;_S9PA4urlU+K0ajT0d%C@F%QmZ9ab5@dO~_sEs1G_5OY<3n z);}BIFK~Ug`9COM1GPB6#cZf(Y-s%QuS>y^tKN=qiux8VxSqFlYw7SO*>oy z-{+H*xo4HCS06OSbhZ&D@?Cqt3!u0}jmE=iSO{I<`~DeaP4FrF@72o}t@p#8gW@jV zeZ5g%cVpwSV@G?(uV5TV8sKa2`=I$rV{R}6Ns|6A#ewsneWv!5kAf@e!!B^ooE67^ zU_JO}&lL6iJ`wl$`4KxBKN<&*fZnq)5G3O%`~>uT+%cf{LEnoZ;7d~PuWz^5wZ_z! z;P*jeX-=_5DJvg~Kik3m?Lg1t&6N2W=8pQX4eWE!eDq9MgA~?{#HY963wQUS^gk=*egRs2Vx_ao3bfpo@!{;%#mh{OLT^j-mXjKz`HSz#RhPe$+Q1pGf9 zlmGSTT?pMV^+D%3@_iP>5r5PsCa(WF(^&;NA1sE>raHkL&uN+e)t5`4v!P<>+ok_0 zN~8a-Pvzum8GoG{mg8&Cz3u3zm3)BVAfI|$) + + + + + + + + + + + + + + + + + + + Custom Tasklist + + + +
+ + + diff --git a/custom-tasklist-exporter-based/tasklist/client/public/logo192.png b/custom-tasklist-exporter-based/tasklist/client/public/logo192.png new file mode 100644 index 0000000000000000000000000000000000000000..fc44b0a3796c0e0a64c3d858ca038bd4570465d9 GIT binary patch literal 5347 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 b{|{}U^kRn2wo}j7|0ATu<;8xA7zX}7|B6mN literal 0 HcmV?d00001 diff --git a/custom-tasklist-exporter-based/tasklist/client/public/manifest.json b/custom-tasklist-exporter-based/tasklist/client/public/manifest.json new file mode 100644 index 00000000..f1869f8b --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/public/manifest.json @@ -0,0 +1,25 @@ +{ + "short_name": "Custom Tasklist", + "name": "Custom Tasklist", + "icons": [ + { + "src": "favicon.ico", + "sizes": "64x64 32x32 24x24 16x16", + "type": "image/x-icon" + }, + { + "src": "logo192.png", + "type": "image/png", + "sizes": "192x192" + }, + { + "src": "logo512.png", + "type": "image/png", + "sizes": "512x512" + } + ], + "start_url": ".", + "display": "standalone", + "theme_color": "#000000", + "background_color": "#ffffff" +} diff --git a/custom-tasklist-exporter-based/tasklist/client/public/robots.txt b/custom-tasklist-exporter-based/tasklist/client/public/robots.txt new file mode 100644 index 00000000..e9e57dc4 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/public/robots.txt @@ -0,0 +1,3 @@ +# https://www.robotstxt.org/robotstxt.html +User-agent: * +Disallow: diff --git a/custom-tasklist-exporter-based/tasklist/client/src/App.css b/custom-tasklist-exporter-based/tasklist/client/src/App.css new file mode 100644 index 00000000..6480e2d2 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/App.css @@ -0,0 +1,146 @@ +* { + box-sizing: border-box; + font-family: 'Poppins'; + font-style: normal; +} + +.header { + background-color: #4F6D7A; + color: #F8FAFC; +} + +.task-list-name { + padding-left: 20px; + padding-top: 10px; +} + +.task-list-icon { + padding-right: 20px; +} + +html { + background-color: #F8FAFC; +} + +.main { + /* + TODO: Find Better solution to have sticky header but still not overlap with main content + */ + background-color: #F8FAFC; + padding-top: 100px; + padding-bottom: 50px; +} + +.primary { + color: #13070C; +} + +.secondary { + color: #4F6D7A; +} + +.warning-yellow { + color: #FCD581; +} + +.warning-red { + color: #EF5B5B; +} + +.good-green { + color: #8AE9C1; +} + +.bold { + font-weight: bold; +} + +.task { + padding: 20px 10px 10px; + margin: 20px; + border: none; +} + +.badge { + font-size: x-small; + vertical-align: middle; + margin-right: 2px; + margin-left: 2px; +} + +.orange-badge { + background-color: #FCD581; + color: #13070C; +} + +.green-badge { + background-color: #8AE9C1; + color: #13070C; +} + +.red-badge { + background-color: #EF5B5B; + color: white; +} + +.tab-content { + margin: 20px; + font-size: small; +} + +.task-info { + font-size: x-small; + margin-bottom: 0px; + padding-right: 10px; +} +.task-info > p > span { + margin-left: 10px; + font-weight: bold; +} + +.nav-link { + font-size: small; + color: #13070C; +} + +.task-name { + padding-left: 10px; + padding-right: 10px; +} + +.task-header { + cursor: pointer; +} + +.info-header{ + font-size: small; + color: #4F6D7A; +} + +.djs-container > svg { + height: 500px +} + +.bjs-breadcrumbs{ + visibility: hidden; +} + +.wrapper { + display: flex; + align-items: stretch; + overflow: visible; +} + +#sidebar { + min-width: 250px; + max-width: 250px; + color: #F8FAFC; + background-color: #4F6D7A; + margin-bottom: -5000px; + padding-bottom: 5000px; + z-index: 10000 +} + +#sidebar.active { + margin-left: -250px; +} \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/App.js b/custom-tasklist-exporter-based/tasklist/client/src/App.js new file mode 100644 index 00000000..76b97152 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/App.js @@ -0,0 +1,14 @@ +import Header from "./components/Navigation/Header"; +import Main from "./components/Main"; +import './App.css'; + +function App() { + return ( +
+
+
+
+ ); +} + +export default App; diff --git a/custom-tasklist-exporter-based/tasklist/client/src/BpmnMock.js b/custom-tasklist-exporter-based/tasklist/client/src/BpmnMock.js new file mode 100644 index 00000000..39aeb67c --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/BpmnMock.js @@ -0,0 +1,177 @@ +const bpmn = "\n" + + "\n" + + " \n" + + " \n" + + " { \"schemaVersion\": 2, \"components\": [ { \"text\": \"# Review Application\", \"type\": \"text\", \"id\": \"Field_0j0h09s\" }, { \"label\": \"Application Id\", \"type\": \"textfield\", \"id\": \"Field_0mb144r\", \"key\": \"applicationId\" }, { \"text\": \"## Applicant Information\", \"type\": \"text\", \"id\": \"Field_04uqzuj\" }, { \"label\": \"Applicant's Name\", \"type\": \"textfield\", \"id\": \"Field_1o52u87\", \"key\": \"applicantName\" }, { \"label\": \"Applicant's Email\", \"type\": \"textfield\", \"id\": \"Field_1epkqk9\", \"key\": \"applicantEmail\" }, { \"label\": \"Applicant Age\", \"type\": \"textfield\", \"id\": \"Field_13ctb55\", \"key\": \"applicantAge\" }, { \"label\": \"Approve Application\", \"type\": \"checkbox\", \"id\": \"Field_13o5vxo\", \"key\": \"approved\" } ], \"type\": \"default\", \"id\": \"ApplicationForm\", \"executionPlatform\": \"Camunda Cloud\", \"executionPlatformVersion\": \"1.2\" }\n" + + " \n" + + " \n" + + " Flow_15tj0hw\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " Flow_1h7lrn0\n" + + " Flow_0n4rtd7\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " Flow_15tj0hw\n" + + " Flow_0ets4df\n" + + " \n" + + " \n" + + " Flow_0ets4df\n" + + " Flow_1h7lrn0\n" + + " Flow_1qbgho7\n" + + " Flow_14ms2nk\n" + + " \n" + + " \n" + + " =score between 61 and 84\n" + + " \n" + + " \n" + + " Flow_1s1j6rm\n" + + " \n" + + " \n" + + " =score>=85\n" + + " \n" + + " \n" + + " Flow_0q42znu\n" + + " \n" + + " \n" + + " =score<=60\n" + + " \n" + + " \n" + + " Flow_0n4rtd7\n" + + " Flow_0n5bsuq\n" + + " Flow_19045iq\n" + + " \n" + + " \n" + + " Flow_14ms2nk\n" + + " Flow_19045iq\n" + + " Flow_0q42znu\n" + + " \n" + + " \n" + + " \n" + + " Flow_1qbgho7\n" + + " Flow_0n5bsuq\n" + + " Flow_1s1j6rm\n" + + " \n" + + " \n" + + " \n" + + " =approved = true\n" + + " \n" + + " \n" + + " = approved = false\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + "" + +export default bpmn \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/DataMock.js b/custom-tasklist-exporter-based/tasklist/client/src/DataMock.js new file mode 100644 index 00000000..d2bd2b99 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/DataMock.js @@ -0,0 +1,107 @@ +const dataMock = { + "data": { + "filteredUserTasks": [ + { + "userTaskId": "630e68550e74b92192df5d97", + "taskElementName": "My UserTask", + "eventType": "ENDED", + "source": "C7", + "dueDate": "Mon Jun 26 09:54:00 UTC 2023", + "priority": 20, + "assignee": "manu", + "variables": [] + }, + { + "userTaskId": "630e68580e74b92192df5d98", + "taskElementName": "My UserTask", + "eventType": "CREATED", + "source": "C7", + "dueDate": "Mon Jun 26 09:54:00 UTC 2023", + "priority": 20, + "assignee": "manu", + "variables": [] + }, + { + "userTaskId": "630e685c0e74b92192df5d99", + "taskElementName": "My UserTask", + "eventType": "CREATED", + "source": "C7", + "dueDate": "Mon Jun 26 09:54:00 UTC 2023", + "priority": 20, + "assignee": "manu", + "variables": [] + }, + { + "userTaskId": "630e69ea38e7262b3ea00b2f", + "taskElementName": "My UserTask", + "eventType": "CREATED", + "source": "C7", + "dueDate": "Mon Jun 26 09:54:00 UTC 2023", + "priority": 20, + "assignee": "manu", + "variables": [] + }, + { + "userTaskId": "630e69ee38e7262b3ea00b30", + "taskElementName": "My UserTask", + "eventType": "CREATED", + "source": "C7", + "dueDate": "Mon Jun 26 09:54:00 UTC 2023", + "priority": 20, + "assignee": "manu", + "variables": [] + }, + { + "userTaskId": "f673e4bb-289d-11ed-bf6e-0242ac170005", + "taskElementName": "My UserTask", + "eventType": "CREATED", + "source": "C7", + "dueDate": "Mon Jun 26 09:54:00 UTC 2023", + "priority": 20, + "assignee": "manu", + "variables": [] + }, + { + "userTaskId": "f72113b7-289d-11ed-bf6e-0242ac170005", + "taskElementName": "My UserTask", + "eventType": "CREATED", + "source": "C7", + "dueDate": "Mon Jun 26 09:54:00 UTC 2023", + "priority": 20, + "assignee": "manu", + "variables": [] + }, + { + "userTaskId": "f7d08da3-289d-11ed-bf6e-0242ac170005", + "taskElementName": "My UserTask", + "eventType": "COMPLETED", + "source": "C7", + "dueDate": "Mon Jun 26 09:54:00 UTC 2023", + "priority": 20, + "assignee": "manu", + "variables": [] + }, + { + "userTaskId": "630f6d4bd5b609648a58175c", + "taskElementName": "Handle Error", + "eventType": "CREATED", + "source": "C7", + "dueDate": null, + "priority": 50, + "assignee": null, + "variables": [] + }, + { + "userTaskId": "630f6d4fd5b609648a58175d", + "taskElementName": "Handle Error", + "eventType": "CREATED", + "source": "C7", + "dueDate": null, + "priority": 50, + "assignee": null, + "variables": [] + } + ] + } +} +export default dataMock \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Bpmn/DiagramViewer.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Bpmn/DiagramViewer.js new file mode 100644 index 00000000..ca39c603 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Bpmn/DiagramViewer.js @@ -0,0 +1,22 @@ +import BpmnJS from "bpmn-js/lib/NavigatedViewer"; +import {useEffect, useRef} from "react"; + +function DiagramViewer(props) { + + const diagramElement = useRef(null) + + const viewer = new BpmnJS(); + + useEffect( () => { + if (diagramElement.current.children.length === 0) { + viewer.attachTo(diagramElement.current) + viewer.importXML(props.xml); + } + }) + + return ( +
+ ); +} + +export default DiagramViewer \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Bpmn/FormViewer.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Bpmn/FormViewer.js new file mode 100644 index 00000000..3f332899 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Bpmn/FormViewer.js @@ -0,0 +1,35 @@ +import {Form} from '@bpmn-io/form-js-viewer'; +import React, {useEffect, useRef} from 'react' +import CompleteUserTaskMutation from "../../integration/CompleteUserTaskMutation"; +import {useMutation} from "@apollo/client"; +function FormViewer(props) { + + const formElement = useRef(null) + const form = new Form() + const [completeTask, {error }] = useMutation(CompleteUserTaskMutation); + + useEffect(() => { + const current = formElement.current + if (current.children.length === 0) { + form.attachTo(current) + form.importSchema(props.schema, JSON.parse(props.data)) + } + form.on('submit', (event) => { + event.preventDefault(); + completeTask({ + variables: { + userTaskId: props.userTaskId, + variables: JSON.stringify(event.data)} + }); + }); + },) + + if (error) return `Submission error! ${error.message}`; + + + return ( +
+ ); +} + +export default FormViewer; diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Main.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Main.js new file mode 100644 index 00000000..f5319d8f --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Main.js @@ -0,0 +1,13 @@ +import Tasks from "./Tasks/Tasks"; + +function Main() { + + return ( +
+ +
+ + ); +} + +export default Main; \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Navigation/Header.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Navigation/Header.js new file mode 100644 index 00000000..a60d4458 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Navigation/Header.js @@ -0,0 +1,16 @@ +import {FaRegCheckCircle} from "react-icons/fa"; + +function Header() { + return ( +
+ +
+ ); +} + +export default Header; diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tabs/Tab.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tabs/Tab.js new file mode 100644 index 00000000..c11ccf7f --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tabs/Tab.js @@ -0,0 +1,11 @@ +function Tab(props) { + + return ( +
+ {props.content} +
+ ); +} + +export default Tab \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tabs/Tabs.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tabs/Tabs.js new file mode 100644 index 00000000..6689e393 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tabs/Tabs.js @@ -0,0 +1,66 @@ +import React from "react"; +import Tab from "./Tab"; +import FormViewer from "../../Bpmn/FormViewer"; +import DiagramViewer from "../../Bpmn/DiagramViewer"; +import {useQuery} from "@apollo/client"; +import DiagramQuery from "../../../integration/DiagramQuery"; +import defaultForm from "../../../integration/DefaultForm"; + +function Tabs(props) { + + const processDefinitionId = props.task.processDefinitionId; + let formKey; + if(props.task.formKey === null){ + formKey = defaultForm; + } + else { + try { + formKey = JSON.parse(props.task.formKey); + } catch (e) { + formKey = defaultForm; + } + } + + const { loading, error, data } = useQuery(DiagramQuery(processDefinitionId)); + + if (loading) return

Loading...

; + if (error) return

Error : {error.message}

; + + return ( + + ); +} + +export default Tabs; diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Task.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Task.js new file mode 100644 index 00000000..39917d52 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Task.js @@ -0,0 +1,27 @@ +import TaskInfo from "./TaskInfo"; +import TaskHeader from "./TaskHeader"; +import React, {useState} from "react"; +import Tabs from "./Tabs/Tabs"; + +function Task(props) { + + const [taskOpen, setTaskOpen] = useState(false) + + function showDetails() { + setTaskOpen(taskOpen => !taskOpen) + } + + return ( +
+ + + {taskOpen && } + {taskOpen && } +
+ ); +} + +export default Task \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/TaskHeader.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/TaskHeader.js new file mode 100644 index 00000000..89945f3e --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/TaskHeader.js @@ -0,0 +1,43 @@ +import { FaCaretDown, FaCaretRight } from "react-icons/fa"; +function TaskHeader(props) { + + let badgeColor = "" + let status = "" + + switch (props.task.eventType) { + case "CREATED": + badgeColor = "orange-badge" + status = "To Do" + break; + case "COMPLETED": + badgeColor = "green-badge" + status = "Done" + break; + case "ENDED": + badgeColor = "red-badge" + status = "Ended" + break; + default: + break; + + + } + + return ( +
+
+
+ {props.taskOpen ?:} + {props.task.taskElementName} + {props.taskOpen && {status}} +
+
+ { !props.taskOpen &&
{props.task.assignee}
} + { !props.taskOpen &&
{props.task.priority}
} + { !props.taskOpen &&
{props.task.dueDate}
} + { !props.taskOpen &&
{status}
} +
+ ); +} + +export default TaskHeader \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/TaskInfo.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/TaskInfo.js new file mode 100644 index 00000000..66655139 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/TaskInfo.js @@ -0,0 +1,15 @@ +function TaskInfo(props) { + + return ( +
+

Tags: + {props.task.source} +

+ {props.task.priority != null &&

Priority: {props.task.priority}

} + {props.task.dueDate != null &&

Due Date: {props.task.dueDate}

} + {props.task.assignee != null &&

Assignee: {props.task.assignee}

} +
+ ); +} + +export default TaskInfo \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tasks.js b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tasks.js new file mode 100644 index 00000000..8ef6f6ab --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/components/Tasks/Tasks.js @@ -0,0 +1,28 @@ +import Task from "./Task"; +import { useQuery} from '@apollo/client'; +import GetFilteredTasks from "../../integration/GetFilteredTasks"; +import {useEffect} from "react"; +function Tasks() { + + const { loading, error, data, startPolling } = useQuery(GetFilteredTasks,{ + variables: {eventType: "CREATED", page: 0, size: 10} + }); + + useEffect(() => { + startPolling(500); + }, [startPolling]); + + if (loading) return

Loading...

; + if (error) return

Error : {error.message}

; + + + return data.filteredUserTasks.map(task => ( + + )); + +} + +export default Tasks; diff --git a/custom-tasklist-exporter-based/tasklist/client/src/index.css b/custom-tasklist-exporter-based/tasklist/client/src/index.css new file mode 100644 index 00000000..e69de29b diff --git a/custom-tasklist-exporter-based/tasklist/client/src/index.js b/custom-tasklist-exporter-based/tasklist/client/src/index.js new file mode 100644 index 00000000..9b9032c6 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/index.js @@ -0,0 +1,22 @@ +import React from 'react'; +import ReactDOM from 'react-dom/client'; +import './index.css'; +import 'bootstrap/dist/css/bootstrap.css'; +import 'bootstrap/dist/js/bootstrap.js'; +import { ApolloClient, InMemoryCache, ApolloProvider } from '@apollo/client'; +import App from './App'; + +const client = new ApolloClient({ + uri: '/graphql', + fetchOptions: { + mode: 'no-cors' + }, + cache: new InMemoryCache(), +}); + +const root = ReactDOM.createRoot(document.getElementById('root')); +root.render( + + + +); diff --git a/custom-tasklist-exporter-based/tasklist/client/src/integration/CompleteUserTaskMutation.js b/custom-tasklist-exporter-based/tasklist/client/src/integration/CompleteUserTaskMutation.js new file mode 100644 index 00000000..002cc1f5 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/integration/CompleteUserTaskMutation.js @@ -0,0 +1,15 @@ +import {gql} from "@apollo/client"; + +const CompleteUserTaskMutation = + gql` + mutation completeUserTask($userTaskId: ID! $variables: String) { + completeUserTask(userTaskId: $userTaskId variables: $variables) { + userTaskId + processInstanceId + eventType + source + } + } + `; + +export default CompleteUserTaskMutation; \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/integration/DefaultForm.js b/custom-tasklist-exporter-based/tasklist/client/src/integration/DefaultForm.js new file mode 100644 index 00000000..2d6a0a07 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/integration/DefaultForm.js @@ -0,0 +1,22 @@ +const defaultForm = { + "components": [ + { + "action": "submit", + "label": "Complete User Task", + "type": "button", + "id": "Field_15q307p", + "key": "field_01gbtgg" + } + ], + "schemaVersion": 6, + "exporter": { + "name": "Camunda Web Modeler", + "version": "7b4d270" + }, + "type": "default", + "id": "Form_4ef0fc79-0b72-4c8b-a55c-42d0dd1000c8", + "executionPlatform": "Camunda Cloud", + "executionPlatformVersion": "8.1.0" +} + +export default defaultForm; \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/integration/DiagramQuery.js b/custom-tasklist-exporter-based/tasklist/client/src/integration/DiagramQuery.js new file mode 100644 index 00000000..dab7557d --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/integration/DiagramQuery.js @@ -0,0 +1,12 @@ +import {gql} from "@apollo/client"; + +function diagramById(id) { + return gql` + query{diagramById(diagramId: \"${id}\") { + diagramId + processDefinition + }} + `; +} + +export default diagramById; \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/integration/GetFilteredTasks.js b/custom-tasklist-exporter-based/tasklist/client/src/integration/GetFilteredTasks.js new file mode 100644 index 00000000..150c88f2 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/integration/GetFilteredTasks.js @@ -0,0 +1,22 @@ +import {gql} from "@apollo/client"; + +const GET_FILTERED_TASKS = gql` + query FilteredTasks($source: String, $eventType: EventType, $page: Int, $size: Int) { + filteredUserTasks(source: $source , eventType: $eventType, page: $page, size: $size) { + userTaskId + taskElementName + source + assignee + priority + eventType + dueDate + candidateUsers + candidateGroups + processInstanceId + processDefinitionId + formKey + variables + } + } +`; +export default GET_FILTERED_TASKS \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/client/src/logo.svg b/custom-tasklist-exporter-based/tasklist/client/src/logo.svg new file mode 100644 index 00000000..9dfc1c05 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/client/src/logo.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/pom.xml b/custom-tasklist-exporter-based/tasklist/pom.xml new file mode 100644 index 00000000..638c9539 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/pom.xml @@ -0,0 +1,162 @@ + + + 4.0.0 + + + com.camunda.consulting + tasklist-parent + 1.0-SNAPSHOT + + + com.camunda.consulting + tasklist + + tasklist + + + + com.camunda.consulting + model + + + org.springframework.boot + spring-boot-starter + + + org.springframework.kafka + spring-kafka + 2.8.10 + + + org.springframework.boot + spring-boot-starter-web + + + + org.springframework.boot + spring-boot-starter-data-mongodb + + + org.springframework.boot + spring-boot-starter-graphql + + + + + + org.springframework.boot + spring-boot-starter-test + test + + + + org.springframework.kafka + spring-kafka-test + 2.8.10 + test + + + + de.flapdoodle.embed + de.flapdoodle.embed.mongo + test + + + + + + + + org.apache.maven.plugins + maven-shade-plugin + + + com.github.eirslett + frontend-maven-plugin + 1.12.1 + + client + target + + + + install node and npm + + install-node-and-npm + + + v14.17.1 + 9.2.0 + + + + npm install + + npm + + + install + + + + npm run build + + npm + + + run build + + + + + + org.apache.maven.plugins + maven-antrun-plugin + 3.1.0 + + + generate-resources + + + + + + + + + run + + + + + + org.springframework.boot + spring-boot-maven-plugin + + com.camunda.consulting.TasklistApplication + JAR + + + + + repackage + + + + + + + + + + + + org.springframework.boot + spring-boot-dependencies + + + + diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/TasklistApplication.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/TasklistApplication.java new file mode 100644 index 00000000..6b188fbf --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/TasklistApplication.java @@ -0,0 +1,17 @@ +package com.camunda.consulting; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.data.mongodb.repository.config.EnableMongoRepositories; +import org.springframework.kafka.annotation.EnableKafka; + +@SpringBootApplication +@EnableMongoRepositories +@EnableKafka +public class TasklistApplication { + + public static void main(String[] args) { + SpringApplication.run(TasklistApplication.class, args); + } + +} diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/controller/DiagramController.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/controller/DiagramController.java new file mode 100644 index 00000000..afa82f7d --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/controller/DiagramController.java @@ -0,0 +1,22 @@ +package com.camunda.consulting.api.controller; + +import com.camunda.consulting.api.service.DiagramService; +import com.camunda.consulting.impl.BpmnDiagram; +import java.util.Optional; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.graphql.data.method.annotation.Argument; +import org.springframework.graphql.data.method.annotation.QueryMapping; +import org.springframework.stereotype.Controller; + +@Controller +public class DiagramController { + + @Autowired + private DiagramService diagramService; + + @QueryMapping + public Optional diagramById(@Argument String diagramId) { + return diagramService.diagramById(diagramId); + } + +} diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/controller/UserTaskController.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/controller/UserTaskController.java new file mode 100644 index 00000000..26f021c3 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/controller/UserTaskController.java @@ -0,0 +1,63 @@ +package com.camunda.consulting.api.controller; + +import com.camunda.consulting.EventType; +import com.camunda.consulting.api.graphql.UserTaskDTO; +import com.camunda.consulting.api.service.UserTaskService; +import java.util.List; +import java.util.Optional; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.graphql.data.method.annotation.Argument; +import org.springframework.graphql.data.method.annotation.MutationMapping; +import org.springframework.graphql.data.method.annotation.QueryMapping; +import org.springframework.stereotype.Controller; + +@Controller +public class UserTaskController { + + @Autowired + private UserTaskService userTaskService; + + @QueryMapping + public Optional userTaskById(@Argument String userTaskId) { + return userTaskService.userTaskByIdDto(userTaskId); + } + + @QueryMapping + public List allUserTasks(@Argument Optional page, + @Argument Optional size) { + return userTaskService.allUserTasks(page, size); + } + + @QueryMapping + public List filteredUserTasks( + @Argument Optional userTaskId, + @Argument Optional processInstanceId, + @Argument Optional taskElementName, + @Argument Optional formKey, + @Argument Optional assignee, + @Argument List candidateUsers, + @Argument List candidateGroups, + @Argument Optional dueDate, + @Argument Optional followUpDate, + @Argument Optional priority, + @Argument Optional source, + @Argument Optional eventType, + @Argument Optional page, + @Argument Optional size) { + + return userTaskService.filteredUserTasks(userTaskId, processInstanceId, taskElementName, + formKey, assignee, candidateUsers, candidateGroups, dueDate, followUpDate, priority, source, eventType, page, size); + } + + @MutationMapping + public UserTaskDTO completeUserTask(@Argument String userTaskId, + @Argument String variables) { + return userTaskService.completeUserTask(userTaskId, variables); + } + + @MutationMapping + public UserTaskDTO assignUserTask(@Argument String userTaskId, + @Argument String assignee) { + return userTaskService.assignUserTask(userTaskId, assignee); + } +} \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/graphql/UserTaskDTO.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/graphql/UserTaskDTO.java new file mode 100644 index 00000000..1388ad46 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/graphql/UserTaskDTO.java @@ -0,0 +1,180 @@ +package com.camunda.consulting.api.graphql; + +import com.camunda.consulting.EventType; +import com.camunda.consulting.impl.UserTask; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.util.ArrayList; +import java.util.List; + +public class UserTaskDTO { + + private String userTaskId; + private String processInstanceId; + + private String processDefinitionId; + private String taskElementName; + private String formKey; + private String assignee; + private List candidateGroups; + private List candidateUsers; + private String dueDate; + private String followUpDate; + private int priority; + private String variables; + private String source; + private EventType eventType; + private ObjectMapper mapper = new ObjectMapper(); + + public UserTaskDTO(UserTask userTask) { + this.userTaskId = userTask.getUserTaskId(); + this.processInstanceId = userTask.getProcessInstanceId(); + this.processDefinitionId = userTask.getProcessDefinitionId(); + this.taskElementName = userTask.getTaskElementName(); + this.formKey = userTask.getFormKey(); + this.assignee = userTask.getAssignee(); + this.candidateGroups = userTask.getCandidateGroups(); + this.candidateUsers = userTask.getCandidateUsers(); + this.dueDate = userTask.getDueDate(); + this.followUpDate = userTask.getFollowUpDate(); + this.priority = userTask.getPriority(); + try { + this.variables = mapper.writeValueAsString(userTask.getVariables()); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + this.source = userTask.getSource(); + this.eventType = userTask.getEventType(); + } + + public String getUserTaskId() { + return userTaskId; + } + + public void setUserTaskId(String userTaskId) { + this.userTaskId = userTaskId; + } + + public String getProcessInstanceId() { + return processInstanceId; + } + + public void setProcessInstanceId(String processInstanceId) { + this.processInstanceId = processInstanceId; + } + +public String getProcessDefinitionId() { + return processDefinitionId; + } + + public void setProcessDefinitionId(String processDefinitionId) { + this.processDefinitionId = processDefinitionId; + } + + public String getTaskElementName() { + return taskElementName; + } + + public void setTaskElementName(String taskElementName) { + this.taskElementName = taskElementName; + } + + public String getFormKey() { + return formKey; + } + + public void setFormKey(String formKey) { + this.formKey = formKey; + } + + public String getAssignee() { + return assignee; + } + + public void setAssignee(String assignee) { + this.assignee = assignee; + } + + public List getCandidateGroups() { + return candidateGroups; + } + + public void setCandidateGroups(List candidateGroups) { + this.candidateGroups = candidateGroups; + } + + public List getCandidateUsers() { + return candidateUsers; + } + + public void setCandidateUsers(List candidateUsers) { + this.candidateUsers = candidateUsers; + } + + public String getDueDate() { + return dueDate; + } + + public void setDueDate(String dueDate) { + this.dueDate = dueDate; + } + + public String getFollowUpDate() { + return followUpDate; + } + + public void setFollowUpDate(String followUpDate) { + this.followUpDate = followUpDate; + } + + public int getPriority() { + return priority; + } + + public void setPriority(int priority) { + this.priority = priority; + } + + public String getVariables() { + return variables; + } + + public void setVariables(String variables) { + this.variables = variables; + } + + public String getSource() { + return source; + } + + public void setSource(String source) { + this.source = source; + } + + public EventType getEventType() { + return eventType; + } + + public void setEventType(EventType eventType) { + this.eventType = eventType; + } + + @Override + public String toString() { + return "UserTaskDTO{" + + "userTaskId='" + userTaskId + '\'' + + ", processInstanceId='" + processInstanceId + '\'' + + ", taskElementName='" + taskElementName + '\'' + + ", formKey='" + formKey + '\'' + + ", assignee='" + assignee + '\'' + + ", candidateGroups=" + candidateGroups + + ", candidateUsers=" + candidateUsers + + ", dueDate='" + dueDate + '\'' + + ", followUpDate='" + followUpDate + '\'' + + ", priority=" + priority + + ", variables=" + variables + + ", source='" + source + '\'' + + ", eventType=" + eventType + + '}'; + } +} diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/repository/DiagramRepository.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/repository/DiagramRepository.java new file mode 100644 index 00000000..6111b06f --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/repository/DiagramRepository.java @@ -0,0 +1,8 @@ +package com.camunda.consulting.api.repository; + +import com.camunda.consulting.impl.BpmnDiagram; +import org.springframework.data.mongodb.repository.MongoRepository; + +public interface DiagramRepository extends MongoRepository { + +} diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/repository/UserTaskRepository.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/repository/UserTaskRepository.java new file mode 100644 index 00000000..c948c817 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/repository/UserTaskRepository.java @@ -0,0 +1,12 @@ +package com.camunda.consulting.api.repository; + +import com.camunda.consulting.impl.UserTask; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; +import org.springframework.data.mongodb.repository.MongoRepository; + +public interface UserTaskRepository extends MongoRepository { + + public Page findAll(Pageable pageable); + +} diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/service/DiagramService.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/service/DiagramService.java new file mode 100644 index 00000000..53fa0b7b --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/service/DiagramService.java @@ -0,0 +1,25 @@ +package com.camunda.consulting.api.service; + +import com.camunda.consulting.api.repository.DiagramRepository; +import com.camunda.consulting.impl.BpmnDiagram; +import java.util.Optional; +import org.springframework.stereotype.Service; + +@Service +public class DiagramService { + + private final DiagramRepository diagramRepository; + + public DiagramService(DiagramRepository diagramRepository) { + this.diagramRepository = diagramRepository; + } + + public void save(BpmnDiagram diagram) { + diagramRepository.save(diagram); + } + + public Optional diagramById(String id) { + return diagramRepository.findById(id); + } + +} diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/service/UserTaskService.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/service/UserTaskService.java new file mode 100644 index 00000000..5d4669e5 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/api/service/UserTaskService.java @@ -0,0 +1,161 @@ +package com.camunda.consulting.api.service; + +import com.camunda.consulting.EventType; +import com.camunda.consulting.api.graphql.UserTaskDTO; +import com.camunda.consulting.api.repository.UserTaskRepository; +import com.camunda.consulting.impl.CompletedTaskMessage; +import com.camunda.consulting.impl.UserTask; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.data.domain.PageRequest; +import org.springframework.data.mongodb.core.MongoTemplate; +import org.springframework.data.mongodb.core.query.Criteria; +import org.springframework.data.mongodb.core.query.Query; +import org.springframework.graphql.data.method.annotation.Argument; +import org.springframework.kafka.core.KafkaTemplate; +import org.springframework.stereotype.Service; + +@Service +public class UserTaskService { + + @Autowired + private UserTaskRepository userTaskRepository; + + @Autowired + private MongoTemplate mongoTemplate; + + @Autowired + private KafkaTemplate kafkaTemplate; + + private ObjectMapper mapper = new ObjectMapper(); + + private static final int DEFAULT_PAGE_SIZE = 25; + + public Optional userTaskByIdDto(String userTaskId) { + return userTaskRepository.findById(userTaskId).map(UserTaskDTO::new); + + } + + public Optional userTaskById(String userTaskId) { + return userTaskRepository.findById(userTaskId); + + } + + public List allUserTasks(Optional page, Optional size) { + if (page.isPresent() && size.isPresent()) { + return userTaskRepository.findAll(PageRequest.of(page.get(), size.get())).stream() + .map(UserTaskDTO::new).collect(java.util.stream.Collectors.toList()); + } + return userTaskRepository.findAll().stream().map(UserTaskDTO::new) + .collect(java.util.stream.Collectors.toList()); + } + + public List filteredUserTasks( + @Argument Optional userTaskId, + @Argument Optional processInstanceId, + @Argument Optional taskElementName, + @Argument Optional formKey, + @Argument Optional assignee, + @Argument List candidateUsers, + @Argument List candidateGroups, + @Argument Optional dueDate, + @Argument Optional followUpDate, + @Argument Optional priority, + @Argument Optional source, + @Argument Optional eventType, + @Argument Optional page, + @Argument Optional size) { + + Query query = new Query(); + if (userTaskId.isPresent()) { + query.addCriteria(Criteria.where("userTaskId").is(userTaskId.get())); + } + if (processInstanceId.isPresent()) { + query.addCriteria(Criteria.where("processInstanceId").is(processInstanceId.get())); + } + if (taskElementName.isPresent()) { + query.addCriteria(Criteria.where("taskElementName").is(taskElementName.get())); + } + if (formKey.isPresent()) { + query.addCriteria(Criteria.where("formKey").is(formKey.get())); + } + if (assignee.isPresent()) { + query.addCriteria(Criteria.where("assignee").is(assignee.get())); + } + if (candidateUsers != null && !candidateUsers.isEmpty()) { + query.addCriteria(Criteria.where("candidateUsers").in(candidateUsers)); + } + if (candidateGroups != null && !candidateGroups.isEmpty()) { + query.addCriteria(Criteria.where("candidateGroups").in(candidateGroups)); + } + if (dueDate.isPresent()) { + query.addCriteria(Criteria.where("dueDate").is(dueDate.get())); + } + if (followUpDate.isPresent()) { + query.addCriteria(Criteria.where("followUpDate").is(followUpDate.get())); + } + if (priority.isPresent()) { + query.addCriteria(Criteria.where("priority").is(priority.get())); + } + + if (source.isPresent()) { + query.addCriteria(Criteria.where("source").is(source.get())); + } + if (eventType.isPresent()) { + query.addCriteria(Criteria.where("eventType").is(eventType.get())); + } + + if (page.isPresent() && size.isPresent()) { + query.with(PageRequest.of(page.get(), size.get())); + } else { + query.with(PageRequest.of(0, DEFAULT_PAGE_SIZE)); + } + + return mongoTemplate.find(query, UserTask.class).stream().map(UserTaskDTO::new) + .collect(java.util.stream.Collectors.toList()); + + } + + + public void save(UserTask userTask) { + userTaskRepository.save(userTask); + } + + public UserTaskDTO completeUserTask(String userTaskId, String variables) { + Optional userTask = userTaskRepository.findById(userTaskId); + if (userTask.isPresent() && userTask.get().getEventType() == EventType.CREATED) { + UserTask task = userTask.get(); + String topic = task.getSource(); + String id; + if (task.getJobKey() != null) { + id = task.getJobKey(); + } else { + id = task.getUserTaskId(); + } + CompletedTaskMessage message = new CompletedTaskMessage(); + message.setId(id); + try { + message.setVariables(mapper.readValue(variables, Map.class)); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + kafkaTemplate.send(topic, message); + return new UserTaskDTO(userTask.get()); + } + return null; + } + + public UserTaskDTO assignUserTask(String userTaskId, String assignee) { + Optional userTask = userTaskRepository.findById(userTaskId); + if (userTask.isPresent()) { + userTask.get().setAssignee(assignee); + userTaskRepository.save(userTask.get()); + return new UserTaskDTO(userTask.get()); + } + return null; + } +} diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/listener/DeploymentKafkaListener.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/listener/DeploymentKafkaListener.java new file mode 100644 index 00000000..85df6e3f --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/listener/DeploymentKafkaListener.java @@ -0,0 +1,29 @@ +package com.camunda.consulting.listener; + +import com.camunda.consulting.api.service.DiagramService; +import com.camunda.consulting.impl.BpmnDiagram; +import java.util.logging.Logger; +import org.springframework.kafka.annotation.KafkaListener; +import org.springframework.stereotype.Component; + +@Component +public class DeploymentKafkaListener { + + private final Logger LOGGER = Logger.getLogger(UserTaskKafkaListener.class.getName()); + + + private final DiagramService diagramService; + + public DeploymentKafkaListener(DiagramService diagramService) { + this.diagramService = diagramService; + } + + @KafkaListener(topics = "${tasklist.kafka.deployment-topic}") + public void listen(BpmnDiagram diagram) { + LOGGER.info("Received BpmnDiagram: " + diagram.getDiagramId()); + diagramService.save(diagram); + } + + + +} diff --git a/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/listener/UserTaskKafkaListener.java b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/listener/UserTaskKafkaListener.java new file mode 100644 index 00000000..55261b2a --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/java/com/camunda/consulting/listener/UserTaskKafkaListener.java @@ -0,0 +1,58 @@ +package com.camunda.consulting.listener; + +import com.camunda.consulting.EventType; +import com.camunda.consulting.api.service.UserTaskService; +import com.camunda.consulting.impl.UserTask; +import java.util.logging.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.kafka.annotation.KafkaListener; +import org.springframework.stereotype.Component; + +@Component +public class UserTaskKafkaListener { + + + private final Logger LOGGER = Logger.getLogger(UserTaskKafkaListener.class.getName()); + + private final UserTaskService userTaskService; + + public UserTaskKafkaListener(UserTaskService userTaskService) { + this.userTaskService = userTaskService; + } + + @KafkaListener(topics = "${tasklist.kafka.user-task-topic}") + public void listen(UserTask userTask) { + try { + LOGGER.fine("Received UserTask: " + userTask); + String taskId = userTask.getUserTaskId(); + switch (userTask.getEventType()) { + case CREATED: + userTaskService.save(userTask); + break; + case COMPLETED: + updateTask(taskId, EventType.COMPLETED); + break; + case ENDED: + updateTask(taskId, EventType.ENDED); + break; + default: + LOGGER.warning("Received Message for unknown Event Type: " + userTask.getEventType()); + } + } catch (Exception e) { + LOGGER.severe("Error while processing UserTask: " + userTask + " - " + e.getMessage()); + } + } + + private void updateTask(String taskId, EventType eventType) { + userTaskService.userTaskById(taskId).ifPresentOrElse( + task -> { + task.setEventType(eventType); + userTaskService.save(task); + }, + () -> { + LOGGER.warning("Task not found: " + taskId); + } + ); + } + +} diff --git a/custom-tasklist-exporter-based/tasklist/src/main/resources/application.yaml b/custom-tasklist-exporter-based/tasklist/src/main/resources/application.yaml new file mode 100644 index 00000000..ea4de5f5 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/resources/application.yaml @@ -0,0 +1,45 @@ +server: + port: 8083 +spring: + kafka: + bootstrap-servers: localhost:29092 + producer: + value-serializer: org.springframework.kafka.support.serializer.JsonSerializer + key-serializer: org.apache.kafka.common.serialization.StringSerializer + consumer: + key-deserializer: org.apache.kafka.common.serialization.StringDeserializer + value-deserializer: org.springframework.kafka.support.serializer.ErrorHandlingDeserializer + group-id: tasklist-backend + properties: + spring: + deserializer: + value: + delegate: + class: org.springframework.kafka.support.serializer.JsonDeserializer + spring.json.trusted.packages: "com.camunda.consulting.*" + spring.json.use.type.headers: true + spring.json.value.default.type: com.camunda.consulting.impl.UserTask + graphql: + graphiql: + enabled: true + path: /graphiql + data: + mongodb: + host: localhost + port: 27017 + database: tasklist + username: demo + password: demo + auto-index-creation: false + authentication-database: admin + +tasklist: + kafka: + user-task-topic: usertask-info + deployment-topic: deploy-info + +logging: + org: + springframework: + data: + mongodb: DEBUG diff --git a/custom-tasklist-exporter-based/tasklist/src/main/resources/graphql/schema.graphqls b/custom-tasklist-exporter-based/tasklist/src/main/resources/graphql/schema.graphqls new file mode 100644 index 00000000..eab2e24a --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/main/resources/graphql/schema.graphqls @@ -0,0 +1,61 @@ +type Query { + allUserTasks(page: Int, size: Int): [UserTask] + userTaskById(userTaskId: ID!): UserTask + filteredUserTasks( + userTaskId: ID + processInstanceId: String + taskElementName: String + formKey: String + assignee: String + candidateUsers: [String] + candidateGroups: [String] + dueDate: String + followUpDate: String + priority: Int + source: String + eventType: EventType + page: Int + size: Int): [UserTask] + diagramById(diagramId: ID!): Diagram +} + +type Mutation { + completeUserTask(userTaskId: ID!, variables: String): UserTask + assignUserTask(userTaskId: ID!, assignee: String): UserTask +} + +type UserTask { + userTaskId: ID + processInstanceId: String + processDefinitionId: String + taskElementName: String + formKey: String + assignee: String + candidateUsers: [String] + candidateGroups: [String] + dueDate: String + followUpDate: String + priority: Int + variables: String + source: String + eventType: EventType +} + +type Diagram { + diagramId: ID + processDefinition: String +} + +enum EventType { + CREATED, + COMPLETED, + ENDED +} + +enum Types { + STRING, + INTEGER, + DOUBLE, + BOOLEAN, + JSON +} \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/DeploymentKafkaListenerTest.java b/custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/DeploymentKafkaListenerTest.java new file mode 100644 index 00000000..c4591a9d --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/DeploymentKafkaListenerTest.java @@ -0,0 +1,36 @@ +package com.camunda.consulting; + +import static org.junit.jupiter.api.Assertions.*; + +import com.camunda.consulting.api.service.DiagramService; +import com.camunda.consulting.impl.BpmnDiagram; +import com.camunda.consulting.listener.DeploymentKafkaListener; +import org.apache.commons.lang3.builder.EqualsBuilder; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +@SpringBootTest +public class DeploymentKafkaListenerTest { + + @Autowired + private DiagramService diagramService; + + private final static String DIAGRAM_ID = "diagramId"; + + @Test + public void whenDeployedAddToKafka() { + // given + DeploymentKafkaListener listener = new DeploymentKafkaListener(diagramService); + BpmnDiagram bpmnDiagram = new BpmnDiagram(); + bpmnDiagram.setDiagramId(DIAGRAM_ID); + bpmnDiagram.setProcessDefinition(""); + // when + listener.listen(bpmnDiagram); + // then + BpmnDiagram diagram = diagramService.diagramById(DIAGRAM_ID).get(); + assertNotNull(diagram); + assertTrue(EqualsBuilder.reflectionEquals(bpmnDiagram, diagram)); + } + +} diff --git a/custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/UserTaskKafkaListenerTest.java b/custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/UserTaskKafkaListenerTest.java new file mode 100644 index 00000000..0debf5cd --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/UserTaskKafkaListenerTest.java @@ -0,0 +1,72 @@ +package com.camunda.consulting; + +import static junit.framework.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.camunda.consulting.api.service.UserTaskService; +import com.camunda.consulting.impl.UserTask; +import com.camunda.consulting.listener.UserTaskKafkaListener; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.annotation.DirtiesContext; + +@SpringBootTest +@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD) +public class UserTaskKafkaListenerTest { + + @Autowired + private UserTaskService userTaskService; + private static UserTask userTask = new UserTask(); + private static UserTaskKafkaListener userTaskKafkaListener; + + private static String userTaskId = "userTaskId"; + + @BeforeEach + public void setup() { + userTask.setUserTaskId(userTaskId); + userTask.setProcessInstanceId("processInstanceId"); + userTask.setTaskElementName("taskElementName"); + userTask.setFormKey("formKey"); + userTask.setAssignee("assignee"); + userTask.setDueDate("dueDate"); + userTask.setFollowUpDate("followUpDate"); + userTask.setPriority(1); + userTask.setVariables(Map.of("key", "value")); + userTask.setSource("source"); + userTaskKafkaListener = new UserTaskKafkaListener(this.userTaskService); + } + + @Test + public void whenNewUserTaskReceivedCreate() { + // given + userTask.setEventType(EventType.CREATED); + assertTrue(userTaskService.userTaskById(userTaskId).isEmpty()); + // when + userTaskKafkaListener.listen(userTask); + // then + assertTrue(userTaskService.userTaskById(userTaskId).isPresent()); + + } + + @Test + public void whenUserTaskUpdated() { + //given + userTask.setEventType(EventType.CREATED); + userTaskKafkaListener.listen(userTask); + assertEquals(1,userTaskService.filteredUserTasks(Optional.of(userTaskId),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(), + List.of(),List.of(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty()).size()); + // when + userTask.setEventType(EventType.COMPLETED); + userTaskKafkaListener.listen(userTask); + // then + assertEquals(1,userTaskService.filteredUserTasks(Optional.of(userTaskId),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(), + List.of(),List.of(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty()).size()); + assertEquals(EventType.COMPLETED,userTaskService.userTaskById(userTaskId).get().getEventType()); + } + +} diff --git a/custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/UserTaskServiceTest.java b/custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/UserTaskServiceTest.java new file mode 100644 index 00000000..d14f8f73 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/test/java/com/camunda/consulting/UserTaskServiceTest.java @@ -0,0 +1,92 @@ +package com.camunda.consulting; + +import static org.junit.jupiter.api.Assertions.*; + +import com.camunda.consulting.api.service.UserTaskService; +import com.camunda.consulting.impl.UserTask; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.annotation.DirtiesContext; + +@SpringBootTest +@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD) +public class UserTaskServiceTest { + + @Autowired + private UserTaskService userTaskService; + + private static UserTask userTask = new UserTask(); + + @BeforeAll + public static void setup() { + userTask.setUserTaskId("userTaskId"); + userTask.setProcessInstanceId("processInstanceId"); + userTask.setTaskElementName("taskElementName"); + userTask.setFormKey("formKey"); + userTask.setAssignee("assignee"); + userTask.setDueDate("dueDate"); + userTask.setFollowUpDate("followUpDate"); + userTask.setPriority(1); + userTask.setVariables(Map.of("key", "value")); + userTask.setSource("source"); + userTask.setEventType(EventType.CREATED); + } + @Test + public void whenNotUsingPageWithAll() { + // given + assertEquals(0,userTaskService.allUserTasks(Optional.empty(),Optional.empty()).size()); + // when + userTaskService.save(userTask); + // then + assertEquals(1,userTaskService.allUserTasks(Optional.empty(),Optional.empty()).size()); + } + + @Test + public void whenUsingPageWithAll() { + // given + assertEquals(0,userTaskService.allUserTasks(Optional.of(0),Optional.of(10)).size()); + // when + userTaskService.save(userTask); + // then + assertEquals(1,userTaskService.allUserTasks(Optional.of(0),Optional.of(10)).size()); + } + + @Test + public void whenNotUsingPageWithFiltered() { + // given + assertEquals(0, + userTaskService.filteredUserTasks(Optional.empty(), Optional.empty(), Optional.empty(), + Optional.empty(), Optional.empty(), + List.of(), List.of(), Optional.empty(), Optional.empty(), Optional.empty(), + Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty()).size()); + // when + userTaskService.save(userTask); + // then + assertEquals(1, + userTaskService.filteredUserTasks(Optional.empty(), Optional.empty(), Optional.empty(), + Optional.empty(), Optional.empty(), + List.of(), List.of(), Optional.empty(), Optional.empty(), Optional.empty(), + Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty()).size()); + } + + @Test + public void whenUsingPageWithFiltered() { + // given + assertEquals(0,userTaskService.filteredUserTasks(Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(), + List.of(),List.of(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty()).size()); + // when + userTaskService.save(userTask); + // then + assertEquals(1,userTaskService.filteredUserTasks(Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(), + List.of(),List.of(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty(),Optional.empty()).size()); + } + + + + +} \ No newline at end of file diff --git a/custom-tasklist-exporter-based/tasklist/src/test/resources/application.yaml b/custom-tasklist-exporter-based/tasklist/src/test/resources/application.yaml new file mode 100644 index 00000000..84e04658 --- /dev/null +++ b/custom-tasklist-exporter-based/tasklist/src/test/resources/application.yaml @@ -0,0 +1,46 @@ +server: + port: 8083 +spring: + kafka: + bootstrap-servers: localhost:29092 + producer: + value-serializer: org.springframework.kafka.support.serializer.JsonSerializer + key-serializer: org.apache.kafka.common.serialization.StringSerializer + consumer: + key-deserializer: org.apache.kafka.common.serialization.StringDeserializer + value-deserializer: org.springframework.kafka.support.serializer.ErrorHandlingDeserializer + group-id: tasklist-backend + properties: + spring: + deserializer: + value: + delegate: + class: org.springframework.kafka.support.serializer.JsonDeserializer + spring.json.trusted.packages: "com.camunda.consulting.*" + spring.json.use.type.headers: true + spring.json.value.default.type: com.camunda.consulting.impl.UserTask + graphql: + graphiql: + enabled: true + path: /graphiql + data: + mongodb: + host: localhost + port: 27017 + database: tasklist + auto-index-creation: false + authentication-database: admin + mongodb: + embedded: + version: 4.0.3 + +tasklist: + kafka: + user-task-topic: usertask-info + deployment-topic: deploy-info + +logging: + org: + springframework: + data: + mongodb: DEBUG