From 402b89b6ec2c1aedfc36e5d1797fb08afe840621 Mon Sep 17 00:00:00 2001 From: Yuhong Sun Date: Fri, 28 Apr 2023 22:40:46 -0700 Subject: [PATCH] Initial Commit --- backend/.gitignore | 8 + backend/.pre-commit-config.yaml | 12 + backend/Dockerfile | 14 + backend/Dockerfile.background | 14 + backend/danswer/background/update.py | 58 + backend/danswer/chunking/__init__.py | 0 backend/danswer/chunking/chunk.py | 152 + backend/danswer/chunking/models.py | 41 + backend/danswer/configs/__init__.py | 0 backend/danswer/configs/app_configs.py | 73 + backend/danswer/configs/constants.py | 27 + backend/danswer/configs/model_configs.py | 23 + backend/danswer/connectors/__init__.py | 0 .../connectors/google_drive/__init__.py | 0 .../danswer/connectors/google_drive/batch.py | 135 + backend/danswer/connectors/models.py | 19 + backend/danswer/connectors/slack/__init__.py | 0 backend/danswer/connectors/slack/batch.py | 87 + backend/danswer/connectors/slack/config.py | 33 + backend/danswer/connectors/slack/pull.py | 191 + backend/danswer/connectors/slack/utils.py | 22 + backend/danswer/connectors/type_aliases.py | 41 + backend/danswer/connectors/web/__init__.py | 0 backend/danswer/connectors/web/batch.py | 117 + backend/danswer/datastores/__init__.py | 12 + backend/danswer/datastores/interfaces.py | 14 + backend/danswer/datastores/qdrant/__init__.py | 0 backend/danswer/datastores/qdrant/indexing.py | 85 + backend/danswer/datastores/qdrant/store.py | 55 + backend/danswer/direct_qa/__init__.py | 0 backend/danswer/direct_qa/qa_prompts.py | 28 + backend/danswer/direct_qa/question_answer.py | 166 + backend/danswer/direct_qa/semantic_search.py | 89 + backend/danswer/dynamic_configs/__init__.py | 15 + .../dynamic_configs/file_system/store.py | 38 + backend/danswer/dynamic_configs/interface.py | 23 + backend/danswer/embedding/__init__.py | 0 backend/danswer/embedding/biencoder.py | 55 + backend/danswer/embedding/type_aliases.py | 7 + backend/danswer/main.py | 35 + backend/danswer/server/__init__.py | 0 backend/danswer/server/admin.py | 23 + backend/danswer/server/event_loading.py | 61 + backend/danswer/server/search_backend.py | 109 + backend/danswer/utils/__init__.py | 0 backend/danswer/utils/clients.py | 62 + backend/danswer/utils/indexing_pipeline.py | 43 + backend/danswer/utils/logging.py | 24 + backend/danswer/utils/text_processing.py | 19 + backend/danswer/utils/timing.py | 31 + backend/deployment/README.md | 5 + backend/deployment/data/nginx/app.conf | 43 + backend/deployment/docker-compose.yml | 42 + backend/deployment/init-letsencrypt.sh | 80 + backend/requirements/cdk.txt | 2 + backend/requirements/default.txt | 23 + backend/requirements/dev.txt | 10 + backend/scripts/ingestion.py | 114 + backend/scripts/simulate_frontend.py | 58 + .../unit/qa_service/chunking/test_chunk.py | 84 + .../direct_qa/test_question_answer.py | 178 + web/.eslintrc.json | 3 + web/.gitignore | 36 + web/.prettierignore | 6 + web/README.md | 32 + web/next.config.js | 8 + web/package-lock.json | 4107 +++++++++++++++++ web/package.json | 28 + web/postcss.config.js | 6 + web/public/next.svg | 1 + web/public/thirteen.svg | 1 + web/public/vercel.svg | 1 + web/src/app/admin/connectors/page.tsx | 22 + web/src/app/favicon.ico | Bin 0 -> 25931 bytes web/src/app/globals.css | 3 + web/src/app/layout.tsx | 18 + web/src/app/page.tsx | 16 + web/src/components/Header.tsx | 12 + web/src/components/SearchBar.tsx | 93 + web/src/components/SearchResultsDisplay.tsx | 73 + web/src/components/Thinking.tsx | 31 + web/src/components/admin/connectors/Popup.tsx | 14 + .../components/admin/connectors/SlackForm.tsx | 163 + web/src/components/thinking.css | 18 + web/src/components/types.tsx | 10 + web/src/lib/constants.ts | 2 + web/tailwind.config.js | 15 + web/tsconfig.json | 28 + 88 files changed, 7447 insertions(+) create mode 100644 backend/.gitignore create mode 100644 backend/.pre-commit-config.yaml create mode 100644 backend/Dockerfile create mode 100644 backend/Dockerfile.background create mode 100755 backend/danswer/background/update.py create mode 100644 backend/danswer/chunking/__init__.py create mode 100644 backend/danswer/chunking/chunk.py create mode 100644 backend/danswer/chunking/models.py create mode 100644 backend/danswer/configs/__init__.py create mode 100644 backend/danswer/configs/app_configs.py create mode 100644 backend/danswer/configs/constants.py create mode 100644 backend/danswer/configs/model_configs.py create mode 100644 backend/danswer/connectors/__init__.py create mode 100644 backend/danswer/connectors/google_drive/__init__.py create mode 100644 backend/danswer/connectors/google_drive/batch.py create mode 100644 backend/danswer/connectors/models.py create mode 100644 backend/danswer/connectors/slack/__init__.py create mode 100644 backend/danswer/connectors/slack/batch.py create mode 100644 backend/danswer/connectors/slack/config.py create mode 100644 backend/danswer/connectors/slack/pull.py create mode 100644 backend/danswer/connectors/slack/utils.py create mode 100644 backend/danswer/connectors/type_aliases.py create mode 100644 backend/danswer/connectors/web/__init__.py create mode 100644 backend/danswer/connectors/web/batch.py create mode 100644 backend/danswer/datastores/__init__.py create mode 100644 backend/danswer/datastores/interfaces.py create mode 100644 backend/danswer/datastores/qdrant/__init__.py create mode 100644 backend/danswer/datastores/qdrant/indexing.py create mode 100644 backend/danswer/datastores/qdrant/store.py create mode 100644 backend/danswer/direct_qa/__init__.py create mode 100644 backend/danswer/direct_qa/qa_prompts.py create mode 100644 backend/danswer/direct_qa/question_answer.py create mode 100644 backend/danswer/direct_qa/semantic_search.py create mode 100644 backend/danswer/dynamic_configs/__init__.py create mode 100644 backend/danswer/dynamic_configs/file_system/store.py create mode 100644 backend/danswer/dynamic_configs/interface.py create mode 100644 backend/danswer/embedding/__init__.py create mode 100644 backend/danswer/embedding/biencoder.py create mode 100644 backend/danswer/embedding/type_aliases.py create mode 100644 backend/danswer/main.py create mode 100644 backend/danswer/server/__init__.py create mode 100644 backend/danswer/server/admin.py create mode 100644 backend/danswer/server/event_loading.py create mode 100644 backend/danswer/server/search_backend.py create mode 100644 backend/danswer/utils/__init__.py create mode 100644 backend/danswer/utils/clients.py create mode 100644 backend/danswer/utils/indexing_pipeline.py create mode 100644 backend/danswer/utils/logging.py create mode 100644 backend/danswer/utils/text_processing.py create mode 100644 backend/danswer/utils/timing.py create mode 100644 backend/deployment/README.md create mode 100644 backend/deployment/data/nginx/app.conf create mode 100644 backend/deployment/docker-compose.yml create mode 100644 backend/deployment/init-letsencrypt.sh create mode 100644 backend/requirements/cdk.txt create mode 100644 backend/requirements/default.txt create mode 100644 backend/requirements/dev.txt create mode 100644 backend/scripts/ingestion.py create mode 100644 backend/scripts/simulate_frontend.py create mode 100644 backend/tests/unit/qa_service/chunking/test_chunk.py create mode 100644 backend/tests/unit/qa_service/direct_qa/test_question_answer.py create mode 100644 web/.eslintrc.json create mode 100644 web/.gitignore create mode 100644 web/.prettierignore create mode 100644 web/README.md create mode 100644 web/next.config.js create mode 100644 web/package-lock.json create mode 100644 web/package.json create mode 100644 web/postcss.config.js create mode 100644 web/public/next.svg create mode 100644 web/public/thirteen.svg create mode 100644 web/public/vercel.svg create mode 100644 web/src/app/admin/connectors/page.tsx create mode 100644 web/src/app/favicon.ico create mode 100644 web/src/app/globals.css create mode 100644 web/src/app/layout.tsx create mode 100644 web/src/app/page.tsx create mode 100644 web/src/components/Header.tsx create mode 100644 web/src/components/SearchBar.tsx create mode 100644 web/src/components/SearchResultsDisplay.tsx create mode 100644 web/src/components/Thinking.tsx create mode 100644 web/src/components/admin/connectors/Popup.tsx create mode 100644 web/src/components/admin/connectors/SlackForm.tsx create mode 100644 web/src/components/thinking.css create mode 100644 web/src/components/types.tsx create mode 100644 web/src/lib/constants.ts create mode 100644 web/tailwind.config.js create mode 100644 web/tsconfig.json diff --git a/backend/.gitignore b/backend/.gitignore new file mode 100644 index 0000000000..29c7cf8c48 --- /dev/null +++ b/backend/.gitignore @@ -0,0 +1,8 @@ +__pycache__/ +.idea/ +site_crawls/ +.ipynb_checkpoints/ +api_keys.py +*ipynb +qdrant-data/ +typesense-data/ \ No newline at end of file diff --git a/backend/.pre-commit-config.yaml b/backend/.pre-commit-config.yaml new file mode 100644 index 0000000000..f4ad188832 --- /dev/null +++ b/backend/.pre-commit-config.yaml @@ -0,0 +1,12 @@ +repos: +- repo: https://github.com/psf/black + rev: 23.3.0 + hooks: + - id: black + language_version: python3.11 + +- repo: https://github.com/asottile/reorder_python_imports + rev: v3.9.0 + hooks: + - id: reorder-python-imports + args: ['--py311-plus'] \ No newline at end of file diff --git a/backend/Dockerfile b/backend/Dockerfile new file mode 100644 index 0000000000..b519b1f03c --- /dev/null +++ b/backend/Dockerfile @@ -0,0 +1,14 @@ +FROM python:3.11-slim-bullseye + +RUN apt-get update \ + && apt-get install -y git cmake pkg-config libprotobuf-c-dev protobuf-compiler libprotobuf-dev libgoogle-perftools-dev build-essential \ + && rm -rf /var/lib/apt/lists/* + +COPY ./requirements/default.txt /tmp/requirements.txt +RUN pip install --no-cache-dir --upgrade -r /tmp/requirements.txt + +WORKDIR /app +COPY ./qa_service /app/qa_service + +ENV PYTHONPATH . +CMD ["uvicorn", "danswer.main:app", "--host", "0.0.0.0", "--port", "8080"] diff --git a/backend/Dockerfile.background b/backend/Dockerfile.background new file mode 100644 index 0000000000..47ae76c9f1 --- /dev/null +++ b/backend/Dockerfile.background @@ -0,0 +1,14 @@ +FROM python:3.11-slim-bullseye + +RUN apt-get update \ + && apt-get install -y git cmake pkg-config libprotobuf-c-dev protobuf-compiler libprotobuf-dev libgoogle-perftools-dev build-essential cron \ + && rm -rf /var/lib/apt/lists/* + +COPY ./requirements/default.txt /tmp/requirements.txt +RUN pip install --no-cache-dir --upgrade -r /tmp/requirements.txt + +WORKDIR /app +COPY ./qa_service /app/qa_service + +ENV PYTHONPATH . +CMD ["python3", "qa_service/background/update.py"] diff --git a/backend/danswer/background/update.py b/backend/danswer/background/update.py new file mode 100755 index 0000000000..86f5e39d46 --- /dev/null +++ b/backend/danswer/background/update.py @@ -0,0 +1,58 @@ +import time +from typing import cast + +from danswer.connectors.slack.config import get_pull_frequency +from danswer.connectors.slack.pull import SlackPullLoader +from danswer.dynamic_configs import get_dynamic_config_store +from danswer.dynamic_configs.interface import ConfigNotFoundError +from danswer.utils.logging import setup_logger + +logger = setup_logger() + +LAST_PULL_KEY_TEMPLATE = "last_pull_{}" + + +def _check_should_run(current_time: int, last_pull: int, pull_frequency: int) -> bool: + return current_time - last_pull > pull_frequency * 60 + + +def run_update(): + logger.info("Running update") + # TODO (chris): implement a more generic way to run updates + # so we don't need to edit this file for future connectors + dynamic_config_store = get_dynamic_config_store() + current_time = int(time.time()) + + # Slack + try: + pull_frequency = get_pull_frequency() + except ConfigNotFoundError: + pull_frequency = 0 + if pull_frequency: + last_slack_pull_key = LAST_PULL_KEY_TEMPLATE.format(SlackPullLoader.__name__) + try: + last_pull = cast(int, dynamic_config_store.load(last_slack_pull_key)) + except ConfigNotFoundError: + last_pull = None + + if last_pull is None or _check_should_run( + current_time, last_pull, pull_frequency + ): + logger.info(f"Running slack pull from {last_pull or 0} to {current_time}") + for doc_batch in SlackPullLoader().load(last_pull or 0, current_time): + print(len(doc_batch)) + dynamic_config_store.store(last_slack_pull_key, current_time) + + +if __name__ == "__main__": + DELAY = 60 # 60 seconds + + while True: + start = time.time() + try: + run_update() + except Exception: + logger.exception("Failed to run update") + sleep_time = DELAY - (time.time() - start) + if sleep_time > 0: + time.sleep(sleep_time) diff --git a/backend/danswer/chunking/__init__.py b/backend/danswer/chunking/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/chunking/chunk.py b/backend/danswer/chunking/chunk.py new file mode 100644 index 0000000000..aabf05b19e --- /dev/null +++ b/backend/danswer/chunking/chunk.py @@ -0,0 +1,152 @@ +import abc +from collections.abc import Callable + +from danswer.chunking.models import IndexChunk +from danswer.configs.app_configs import CHUNK_OVERLAP +from danswer.configs.app_configs import CHUNK_SIZE +from danswer.connectors.models import Document +from danswer.connectors.models import Section +from danswer.utils.text_processing import shared_precompare_cleanup + +SECTION_SEPARATOR = "\n\n" +ChunkFunc = Callable[[Document], list[IndexChunk]] + + +def chunk_large_section( + section: Section, + document: Document, + start_chunk_id: int, + chunk_size: int = CHUNK_SIZE, + word_overlap: int = CHUNK_OVERLAP, +) -> list[IndexChunk]: + section_text = section.text + char_count = len(section_text) + chunk_strs: list[str] = [] + start_pos = segment_start_pos = 0 + while start_pos < char_count: + back_count_words = 0 + end_pos = segment_end_pos = min(start_pos + chunk_size, char_count) + while not section_text[segment_end_pos - 1].isspace(): + if segment_end_pos >= char_count: + break + segment_end_pos += 1 + while back_count_words <= word_overlap: + if segment_start_pos == 0: + break + if section_text[segment_start_pos].isspace(): + back_count_words += 1 + segment_start_pos -= 1 + if segment_start_pos != 0: + segment_start_pos += 2 + chunk_str = section_text[segment_start_pos:segment_end_pos] + if chunk_str[-1].isspace(): + chunk_str = chunk_str[:-1] + chunk_strs.append(chunk_str) + start_pos = segment_start_pos = end_pos + + # Last chunk should be as long as possible, overlap favored over tiny chunk with no context + if len(chunk_strs) > 1: + chunk_strs.pop() + back_count_words = 0 + start_pos = char_count - chunk_size + while back_count_words <= word_overlap: + if section_text[start_pos].isspace(): + back_count_words += 1 + start_pos -= 1 + chunk_strs.append(section_text[start_pos + 2 :]) + + chunks = [] + for chunk_ind, chunk_str in enumerate(chunk_strs): + chunks.append( + IndexChunk( + source_document=document, + chunk_id=start_chunk_id + chunk_ind, + content=chunk_str, + source_links={0: section.link}, + section_continuation=(chunk_ind != 0), + ) + ) + return chunks + + +def chunk_document( + document: Document, + chunk_size: int = CHUNK_SIZE, + subsection_overlap: int = CHUNK_OVERLAP, +) -> list[IndexChunk]: + chunks: list[IndexChunk] = [] + link_offsets: dict[int, str] = {} + chunk_text = "" + for section in document.sections: + current_length = len(chunk_text) + curr_offset_len = len(shared_precompare_cleanup(chunk_text)) + section_length = len(section.text) + + # Large sections are considered self-contained/unique therefore they start a new chunk and are not concatenated + # at the end by other sections + if section_length > chunk_size: + if chunk_text: + chunks.append( + IndexChunk( + source_document=document, + chunk_id=len(chunks), + content=chunk_text, + source_links=link_offsets, + section_continuation=False, + ) + ) + link_offsets = {} + chunk_text = "" + + large_section_chunks = chunk_large_section( + section=section, + document=document, + start_chunk_id=len(chunks), + chunk_size=chunk_size, + word_overlap=subsection_overlap, + ) + chunks.extend(large_section_chunks) + continue + + # In the case where the whole section is shorter than a chunk, either adding to chunk or start a new one + if current_length + len(SECTION_SEPARATOR) + section_length <= chunk_size: + chunk_text += ( + SECTION_SEPARATOR + section.text if chunk_text else section.text + ) + link_offsets[curr_offset_len] = section.link + else: + chunks.append( + IndexChunk( + source_document=document, + chunk_id=len(chunks), + content=chunk_text, + source_links=link_offsets, + section_continuation=False, + ) + ) + link_offsets = {0: section.link} + chunk_text = section.text + + # Once we hit the end, if we're still in the process of building a chunk, add what we have + if chunk_text: + chunks.append( + IndexChunk( + source_document=document, + chunk_id=len(chunks), + content=chunk_text, + source_links=link_offsets, + section_continuation=False, + ) + ) + return chunks + + +class Chunker: + @abc.abstractmethod + def chunk(self, document: Document) -> list[IndexChunk]: + raise NotImplementedError + + +class DefaultChunker(Chunker): + def chunk(self, document: Document) -> list[IndexChunk]: + return chunk_document(document) diff --git a/backend/danswer/chunking/models.py b/backend/danswer/chunking/models.py new file mode 100644 index 0000000000..156d94a5b7 --- /dev/null +++ b/backend/danswer/chunking/models.py @@ -0,0 +1,41 @@ +import inspect +from dataclasses import dataclass +from typing import Optional + +from danswer.connectors.models import Document + + +@dataclass +class BaseChunk: + chunk_id: int + content: str + source_links: Optional[ + dict[int, str] + ] # Holds the link and the offsets into the raw Chunk text + section_continuation: bool # True if this Chunk's start is not at the start of a Section + + +@dataclass +class IndexChunk(BaseChunk): + source_document: Document + + +@dataclass +class EmbeddedIndexChunk(IndexChunk): + embedding: list[float] + + +@dataclass +class InferenceChunk(BaseChunk): + document_id: str + source_type: str + + @classmethod + def from_dict(cls, init_dict): + return cls( + **{ + k: v + for k, v in init_dict.items() + if k in inspect.signature(cls).parameters + } + ) diff --git a/backend/danswer/configs/__init__.py b/backend/danswer/configs/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/configs/app_configs.py b/backend/danswer/configs/app_configs.py new file mode 100644 index 0000000000..7b7f462c3b --- /dev/null +++ b/backend/danswer/configs/app_configs.py @@ -0,0 +1,73 @@ +import os + +##### +# App Configs +##### +APP_HOST = "0.0.0.0" +APP_PORT = 8080 + + +##### +# Vector DB Configs +##### +# Url / Key are used to connect to a remote Qdrant instance +QDRANT_URL = os.environ.get("QDRANT_URL", "") +QDRANT_API_KEY = os.environ.get("QDRANT_API_KEY", "") +# Host / Port are used for connecting to local Qdrant instance +QDRANT_HOST = os.environ.get("QDRANT_HOST", "localhost") +QDRANT_PORT = 6333 +QDRANT_DEFAULT_COLLECTION = os.environ.get("QDRANT_COLLECTION", "semantic_search") +DB_CONN_TIMEOUT = 2 # Timeout seconds connecting to DBs +INDEX_BATCH_SIZE = 16 # File batches (not accounting file chunking) + + +##### +# Connector Configs +##### +GOOGLE_DRIVE_CREDENTIAL_JSON = os.environ.get("GOOGLE_DRIVE_CREDENTIAL_JSON", "") +GOOGLE_DRIVE_TOKENS_JSON = os.environ.get("GOOGLE_DRIVE_TOKENS_JSON", "") +GOOGLE_DRIVE_INCLUDE_SHARED = False + + +##### +# Query Configs +##### +DEFAULT_PROMPT = "generic-qa" +NUM_RETURNED_HITS = 15 +NUM_RERANKED_RESULTS = 4 +KEYWORD_MAX_HITS = 5 +QUOTE_ALLOWED_ERROR_PERCENT = 0.05 # 1 edit per 2 characters + + +##### +# Text Processing Configs +##### +# Chunking docs to this number of characters not including finishing the last word and the overlap words below +# Calculated by ~500 to 512 tokens max * average 4 chars per token +CHUNK_SIZE = 2000 +# Each chunk includes an additional 5 words from previous chunk +# in extreme cases, may cause some words at the end to be truncated by embedding model +CHUNK_OVERLAP = 5 + + +##### +# Other API Keys +##### +OPENAI_API_KEY = os.environ["OPENAI_API_KEY"] + + +##### +# Encoder Model Endpoint Configs (Currently unused, running the models in memory) +##### +BI_ENCODER_HOST = "localhost" +BI_ENCODER_PORT = 9000 +CROSS_ENCODER_HOST = "localhost" +CROSS_ENCODER_PORT = 9000 + + +##### +# Miscellaneous +##### +TYPESENSE_API_KEY = os.environ.get("TYPESENSE_API_KEY", "") +TYPESENSE_HOST = "localhost" +TYPESENSE_PORT = 8108 diff --git a/backend/danswer/configs/constants.py b/backend/danswer/configs/constants.py new file mode 100644 index 0000000000..5813da77c5 --- /dev/null +++ b/backend/danswer/configs/constants.py @@ -0,0 +1,27 @@ +from enum import Enum + +DOCUMENT_ID = "document_id" +CHUNK_ID = "chunk_id" +CONTENT = "content" +SOURCE_TYPE = "source_type" +SOURCE_LINKS = "source_links" +SOURCE_LINK = "link" +SECTION_CONTINUATION = "section_continuation" +ALLOWED_USERS = "allowed_users" +ALLOWED_GROUPS = "allowed_groups" + + +class DocumentSource(Enum): + Slack = 1 + Web = 2 + GoogleDrive = 3 + Unknown = 4 + + def __str__(self): + return self.name + + def __int__(self): + return self.value + + +WEB_SOURCE = "Web" diff --git a/backend/danswer/configs/model_configs.py b/backend/danswer/configs/model_configs.py new file mode 100644 index 0000000000..403b2986de --- /dev/null +++ b/backend/danswer/configs/model_configs.py @@ -0,0 +1,23 @@ +import os + +# Bi/Cross-Encoder Model Configs +# TODO: try 'all-distilroberta-v1' maybe larger training set has more technical knowledge (768 dim) +# Downside: slower by factor of 3 (model size) +# Important considerations, max tokens must be 512 +DOCUMENT_ENCODER_MODEL = "multi-qa-MiniLM-L6-cos-v1" +DOC_EMBEDDING_DIM = 384 # Depends on the document encoder model + +# L-12-v2 might be worth a try, though stats seem very very similar, L-12 slower by factor of 2 +CROSS_ENCODER_MODEL = "cross-encoder/ms-marco-MiniLM-L-6-v2" + +QUERY_EMBEDDING_CONTEXT_SIZE = 256 +DOC_EMBEDDING_CONTEXT_SIZE = 512 +CROSS_EMBED_CONTEXT_SIZE = 512 +MODEL_CACHE_FOLDER = os.environ.get("TRANSFORMERS_CACHE") + +# Purely an optimization, memory limitation consideration +BATCH_SIZE_ENCODE_CHUNKS = 8 + +# OpenAI Model API Configs +OPENAPI_MODEL_VERSION = "text-davinci-003" +OPENAI_MAX_OUTPUT_TOKENS = 200 diff --git a/backend/danswer/connectors/__init__.py b/backend/danswer/connectors/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/connectors/google_drive/__init__.py b/backend/danswer/connectors/google_drive/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/connectors/google_drive/batch.py b/backend/danswer/connectors/google_drive/batch.py new file mode 100644 index 0000000000..649bbb0c37 --- /dev/null +++ b/backend/danswer/connectors/google_drive/batch.py @@ -0,0 +1,135 @@ +import io +import os +from collections.abc import Generator + +from danswer.configs.app_configs import GOOGLE_DRIVE_CREDENTIAL_JSON +from danswer.configs.app_configs import GOOGLE_DRIVE_INCLUDE_SHARED +from danswer.configs.app_configs import GOOGLE_DRIVE_TOKENS_JSON +from danswer.configs.app_configs import INDEX_BATCH_SIZE +from danswer.configs.constants import DocumentSource +from danswer.configs.constants import SOURCE_TYPE +from danswer.connectors.models import Document +from danswer.connectors.models import Section +from danswer.connectors.type_aliases import BatchLoader +from danswer.utils.logging import setup_logger +from google.auth.transport.requests import Request # type: ignore +from google.oauth2.credentials import Credentials # type: ignore +from google_auth_oauthlib.flow import InstalledAppFlow # type: ignore +from googleapiclient import discovery # type: ignore +from PyPDF2 import PdfReader + +logger = setup_logger() + +SCOPES = ["https://www.googleapis.com/auth/drive.readonly"] +SUPPORTED_DRIVE_DOC_TYPES = [ + "application/vnd.google-apps.document", + "application/pdf", + "application/vnd.google-apps.spreadsheet", +] +ID_KEY = "id" +LINK_KEY = "link" +TYPE_KEY = "type" + + +def get_credentials() -> Credentials: + creds = None + if os.path.exists(GOOGLE_DRIVE_TOKENS_JSON): + creds = Credentials.from_authorized_user_file(GOOGLE_DRIVE_TOKENS_JSON, SCOPES) + + if not creds or not creds.valid: + if creds and creds.expired and creds.refresh_token: + creds.refresh(Request()) + else: + flow = InstalledAppFlow.from_client_secrets_file( + GOOGLE_DRIVE_CREDENTIAL_JSON, SCOPES + ) + creds = flow.run_local_server() + + with open(GOOGLE_DRIVE_TOKENS_JSON, "w") as token_file: + token_file.write(creds.to_json()) + + return creds + + +def get_file_batches( + service: discovery.Resource, + include_shared: bool = GOOGLE_DRIVE_INCLUDE_SHARED, + batch_size: int = INDEX_BATCH_SIZE, +): + next_page_token = "" + while next_page_token is not None: + results = ( + service.files() + .list( + pageSize=batch_size, + supportsAllDrives=include_shared, + fields="nextPageToken, files(mimeType, id, name, webViewLink)", + pageToken=next_page_token, + ) + .execute() + ) + next_page_token = results.get("nextPageToken") + files = results["files"] + valid_files = [] + for file in files: + if file["mimeType"] in SUPPORTED_DRIVE_DOC_TYPES: + valid_files.append(file) + logger.info( + f"Parseable Documents in batch: {[file['name'] for file in valid_files]}" + ) + yield valid_files + + +def extract_text(file: dict[str, str], service: discovery.Resource) -> str: + mime_type = file["mimeType"] + if mime_type == "application/vnd.google-apps.document": + return ( + service.files() + .export(fileId=file["id"], mimeType="text/plain") + .execute() + .decode("utf-8") + ) + elif mime_type == "application/vnd.google-apps.spreadsheet": + return ( + service.files() + .export(fileId=file["id"], mimeType="text/csv") + .execute() + .decode("utf-8") + ) + # Default download to PDF since most types can be exported as a PDF + else: + response = service.files().get_media(fileId=file["id"]).execute() + pdf_stream = io.BytesIO(response) + pdf_reader = PdfReader(pdf_stream) + return "\n".join(page.extract_text() for page in pdf_reader.pages) + + +class BatchGoogleDriveLoader(BatchLoader): + def __init__( + self, + batch_size: int = INDEX_BATCH_SIZE, + include_shared: bool = GOOGLE_DRIVE_INCLUDE_SHARED, + ) -> None: + self.batch_size = batch_size + self.include_shared = include_shared + self.creds = get_credentials() + + def load(self) -> Generator[list[Document], None, None]: + service = discovery.build("drive", "v3", credentials=self.creds) + for files_batch in get_file_batches( + service, self.include_shared, self.batch_size + ): + doc_batch = [] + for file in files_batch: + text_contents = extract_text(file, service) + full_context = file["name"] + " " + text_contents + + doc_batch.append( + Document( + id=file["webViewLink"], + sections=[Section(link=file["webViewLink"], text=full_context)], + metadata={SOURCE_TYPE: DocumentSource.GoogleDrive}, + ) + ) + + yield doc_batch diff --git a/backend/danswer/connectors/models.py b/backend/danswer/connectors/models.py new file mode 100644 index 0000000000..0ff49ff1b7 --- /dev/null +++ b/backend/danswer/connectors/models.py @@ -0,0 +1,19 @@ +from dataclasses import dataclass +from typing import Any + + +@dataclass +class Section: + link: str + text: str + + +@dataclass +class Document: + id: str + sections: list[Section] + metadata: dict[str, Any] + + +def get_raw_document_text(document: Document) -> str: + return "\n\n".join([section.text for section in document.sections]) diff --git a/backend/danswer/connectors/slack/__init__.py b/backend/danswer/connectors/slack/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/connectors/slack/batch.py b/backend/danswer/connectors/slack/batch.py new file mode 100644 index 0000000000..55a9e8e528 --- /dev/null +++ b/backend/danswer/connectors/slack/batch.py @@ -0,0 +1,87 @@ +import json +import os +from collections.abc import Generator +from pathlib import Path +from typing import Any +from typing import cast + +from danswer.configs.app_configs import INDEX_BATCH_SIZE +from danswer.connectors.models import Document +from danswer.connectors.models import Section +from danswer.connectors.slack.utils import get_message_link +from danswer.connectors.type_aliases import BatchLoader + + +def _process_batch_event( + event: dict[str, Any], + matching_doc: Document | None, + workspace: str | None = None, + channel_id: str | None = None, +) -> Document | None: + if event["type"] == "message" and event.get("subtype") != "channel_join": + if matching_doc: + return Document( + id=matching_doc.id, + sections=matching_doc.sections + + [ + Section( + link=get_message_link( + event, workspace=workspace, channel_id=channel_id + ), + text=event["text"], + ) + ], + metadata=matching_doc.metadata, + ) + + return Document( + id=event["ts"], + sections=[ + Section( + link=get_message_link( + event, workspace=workspace, channel_id=channel_id + ), + text=event["text"], + ) + ], + metadata={}, + ) + + return None + + +class BatchSlackLoader(BatchLoader): + def __init__( + self, export_path_str: str, batch_size: int = INDEX_BATCH_SIZE + ) -> None: + self.export_path_str = export_path_str + self.batch_size = batch_size + + def load(self) -> Generator[list[Document], None, None]: + export_path = Path(self.export_path_str) + + with open(export_path / "channels.json") as f: + channels = json.load(f) + + document_batch: dict[str, Document] = {} + for channel_info in channels: + channel_dir_path = export_path / cast(str, channel_info["name"]) + channel_file_paths = [ + channel_dir_path / file_name + for file_name in os.listdir(channel_dir_path) + ] + for path in channel_file_paths: + with open(path) as f: + events = cast(list[dict[str, Any]], json.load(f)) + for event in events: + doc = _process_batch_event( + event, + document_batch.get(event.get("thread_ts", "")), + channel_id=channel_info["id"], + ) + if doc: + document_batch[doc.id] = doc + if len(document_batch) >= self.batch_size: + yield list(document_batch.values()) + + yield list(document_batch.values()) diff --git a/backend/danswer/connectors/slack/config.py b/backend/danswer/connectors/slack/config.py new file mode 100644 index 0000000000..d8956c2985 --- /dev/null +++ b/backend/danswer/connectors/slack/config.py @@ -0,0 +1,33 @@ +from danswer.dynamic_configs import get_dynamic_config_store +from danswer.dynamic_configs.interface import ConfigNotFoundError +from pydantic import BaseModel + + +SLACK_CONFIG_KEY = "slack_connector_config" + + +class SlackConfig(BaseModel): + slack_bot_token: str + workspace_id: str + pull_frequency: int = 0 # in minutes, 0 => no pulling + + +def get_slack_config() -> SlackConfig: + slack_config = get_dynamic_config_store().load(SLACK_CONFIG_KEY) + return SlackConfig.parse_obj(slack_config) + + +def get_slack_bot_token() -> str: + return get_slack_config().slack_bot_token + + +def get_workspace_id() -> str: + return get_slack_config().workspace_id + + +def get_pull_frequency() -> int: + return get_slack_config().pull_frequency + + +def update_slack_config(slack_config: SlackConfig): + get_dynamic_config_store().store(SLACK_CONFIG_KEY, slack_config.dict()) diff --git a/backend/danswer/connectors/slack/pull.py b/backend/danswer/connectors/slack/pull.py new file mode 100644 index 0000000000..3b8ae999d1 --- /dev/null +++ b/backend/danswer/connectors/slack/pull.py @@ -0,0 +1,191 @@ +import time +from collections.abc import Callable +from collections.abc import Generator +from typing import Any +from typing import cast +from typing import List + +from danswer.configs.app_configs import INDEX_BATCH_SIZE +from danswer.connectors.models import Document +from danswer.connectors.models import Section +from danswer.connectors.slack.utils import get_client +from danswer.connectors.slack.utils import get_message_link +from danswer.connectors.type_aliases import PullLoader +from danswer.connectors.type_aliases import SecondsSinceUnixEpoch +from danswer.utils.logging import setup_logger +from slack_sdk import WebClient +from slack_sdk.errors import SlackApiError +from slack_sdk.web import SlackResponse + +logger = setup_logger() + +SLACK_LIMIT = 900 + + +MessageType = dict[str, Any] +# list of messages in a thread +ThreadType = list[MessageType] + + +def _make_slack_api_call_paginated( + call: Callable[..., SlackResponse], +) -> Callable[..., list[dict[str, Any]]]: + """Wraps calls to slack API so that they automatically handle pagination""" + + def paginated_call(**kwargs: Any) -> list[dict[str, Any]]: + results: list[dict[str, Any]] = [] + cursor: str | None = None + has_more = True + while has_more: + for result in call(cursor=cursor, limit=SLACK_LIMIT, **kwargs): + has_more = result.get("has_more", False) + cursor = result.get("response_metadata", {}).get("next_cursor", "") + results.append(cast(dict[str, Any], result)) + return results + + return paginated_call + + +def _make_slack_api_rate_limited( + call: Callable[..., SlackResponse], max_retries: int = 3 +) -> Callable[..., SlackResponse]: + """Wraps calls to slack API so that they automatically handle rate limiting""" + + def rate_limited_call(**kwargs: Any) -> SlackResponse: + for _ in range(max_retries): + try: + # Make the API call + response = call(**kwargs) + + # Check for errors in the response + if response.get("ok"): + return response + else: + raise SlackApiError("", response) + + except SlackApiError as e: + if e.response["error"] == "ratelimited": + # Handle rate limiting: get the 'Retry-After' header value and sleep for that duration + retry_after = int(e.response.headers.get("Retry-After", 1)) + time.sleep(retry_after) + else: + # Raise the error for non-transient errors + raise + + # If the code reaches this point, all retries have been exhausted + raise Exception(f"Max retries ({max_retries}) exceeded") + + return rate_limited_call + + +def _make_slack_api_call( + call: Callable[..., SlackResponse], **kwargs: Any +) -> list[dict[str, Any]]: + return _make_slack_api_call_paginated(_make_slack_api_rate_limited(call))(**kwargs) + + +def get_channels(client: WebClient) -> list[dict[str, Any]]: + """Get all channels in the workspace""" + channels: list[dict[str, Any]] = [] + for result in _make_slack_api_call(client.conversations_list): + channels.extend(result["channels"]) + return channels + + +def get_channel_messages( + client: WebClient, channel: dict[str, Any] +) -> list[MessageType]: + """Get all messages in a channel""" + # join so that the bot can access messages + if not channel["is_member"]: + client.conversations_join( + channel=channel["id"], is_private=channel["is_private"] + ) + + messages: list[MessageType] = [] + for result in _make_slack_api_call( + client.conversations_history, channel=channel["id"] + ): + messages.extend(result["messages"]) + return messages + + +def get_thread(client: WebClient, channel_id: str, thread_id: str) -> ThreadType: + """Get all messages in a thread""" + threads: list[MessageType] = [] + for result in _make_slack_api_call( + client.conversations_replies, channel=channel_id, ts=thread_id + ): + threads.extend(result["messages"]) + return threads + + +def _default_msg_filter(message: MessageType) -> bool: + return message.get("subtype", "") == "channel_join" + + +def get_all_threads( + client: WebClient, + msg_filter_func: Callable[[MessageType], bool] = _default_msg_filter, +) -> dict[str, list[ThreadType]]: + """Get all threads in the workspace""" + channels = get_channels(client) + channel_id_to_messages: dict[str, list[dict[str, Any]]] = {} + for channel in channels: + channel_id_to_messages[channel["id"]] = get_channel_messages(client, channel) + + channel_to_threads: dict[str, list[ThreadType]] = {} + for channel_id, messages in channel_id_to_messages.items(): + final_threads: list[ThreadType] = [] + for message in messages: + thread_ts = message.get("thread_ts") + if thread_ts: + thread = get_thread(client, channel_id, thread_ts) + filtered_thread = [ + message for message in thread if not msg_filter_func(message) + ] + if filtered_thread: + final_threads.append(filtered_thread) + else: + final_threads.append([message]) + channel_to_threads[channel_id] = final_threads + + return channel_to_threads + + +def thread_to_doc(channel_id: str, thread: ThreadType) -> Document: + return Document( + id=f"{channel_id}__{thread[0]['ts']}", + sections=[ + Section( + link=get_message_link(m, channel_id=channel_id), + text=cast(str, m["text"]), + ) + for m in thread + ], + metadata={}, + ) + + +def get_all_docs(client: WebClient) -> list[Document]: + """Get all documents in the workspace""" + channel_id_to_threads = get_all_threads(client) + docs: list[Document] = [] + for channel_id, threads in channel_id_to_threads.items(): + docs.extend(thread_to_doc(channel_id, thread) for thread in threads) + logger.info(f"Pulled {len(docs)} documents from slack") + return docs + + +class SlackPullLoader(PullLoader): + def __init__(self, batch_size: int = INDEX_BATCH_SIZE) -> None: + self.client = get_client() + self.batch_size = batch_size + + def load( + self, start: SecondsSinceUnixEpoch, end: SecondsSinceUnixEpoch + ) -> Generator[List[Document], None, None]: + # TODO: make this respect start and end + all_docs = get_all_docs(self.client) + for i in range(0, len(all_docs), self.batch_size): + yield all_docs[i : i + self.batch_size] diff --git a/backend/danswer/connectors/slack/utils.py b/backend/danswer/connectors/slack/utils.py new file mode 100644 index 0000000000..7941e8afda --- /dev/null +++ b/backend/danswer/connectors/slack/utils.py @@ -0,0 +1,22 @@ +from typing import Any +from typing import cast + +from danswer.connectors.slack.config import get_slack_bot_token +from danswer.connectors.slack.config import get_workspace_id +from slack_sdk import WebClient + + +def get_client() -> WebClient: + """NOTE: assumes token is present in environment variable SLACK_BOT_TOKEN""" + return WebClient(token=get_slack_bot_token()) + + +def get_message_link( + event: dict[str, Any], workspace: str | None = None, channel_id: str | None = None +) -> str: + channel_id = channel_id or cast( + str, event["channel"] + ) # channel must either be present in the event or passed in + message_ts = cast(str, event["ts"]) + message_ts_without_dot = message_ts.replace(".", "") + return f"https://{workspace or get_workspace_id()}.slack.com/archives/{channel_id}/p{message_ts_without_dot}" diff --git a/backend/danswer/connectors/type_aliases.py b/backend/danswer/connectors/type_aliases.py new file mode 100644 index 0000000000..f86d8fea27 --- /dev/null +++ b/backend/danswer/connectors/type_aliases.py @@ -0,0 +1,41 @@ +import abc +from collections.abc import Callable +from collections.abc import Generator +from datetime import datetime +from typing import Any +from typing import List +from typing import Optional + +from danswer.connectors.models import Document + + +ConnectorConfig = dict[str, Any] + +# takes in the raw representation of a document from a source and returns a +# Document object +ProcessDocumentFunc = Callable[..., Document] +BuildListenerFunc = Callable[[ConnectorConfig], ProcessDocumentFunc] + + +class BatchLoader: + @abc.abstractmethod + def load(self) -> Generator[List[Document], None, None]: + raise NotImplementedError + + +SecondsSinceUnixEpoch = int + + +class PullLoader: + @abc.abstractmethod + def load( + self, start: SecondsSinceUnixEpoch, end: SecondsSinceUnixEpoch + ) -> Generator[List[Document], None, None]: + raise NotImplementedError + + +# Fetches raw representations from a specific source for the specified time +# range. Is used when the source does not support subscriptions to some sort +# of event stream +# TODO: use Protocol instead of Callable +TimeRangeBasedLoad = Callable[[datetime, datetime], list[Any]] diff --git a/backend/danswer/connectors/web/__init__.py b/backend/danswer/connectors/web/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/connectors/web/batch.py b/backend/danswer/connectors/web/batch.py new file mode 100644 index 0000000000..0c33c79794 --- /dev/null +++ b/backend/danswer/connectors/web/batch.py @@ -0,0 +1,117 @@ +from collections.abc import Generator +from typing import Any +from typing import cast +from urllib.parse import urljoin +from urllib.parse import urlparse + +from bs4 import BeautifulSoup +from danswer.configs.app_configs import INDEX_BATCH_SIZE +from danswer.configs.constants import DocumentSource +from danswer.configs.constants import SOURCE_TYPE +from danswer.connectors.models import Document +from danswer.connectors.models import Section +from danswer.connectors.type_aliases import BatchLoader +from danswer.utils.logging import setup_logger +from playwright.sync_api import sync_playwright + +logger = setup_logger() +TAG_SEPARATOR = "\n" + + +def is_valid_url(url: str) -> bool: + try: + result = urlparse(url) + return all([result.scheme, result.netloc]) + except ValueError: + return False + + +def get_internal_links( + base_url: str, url: str, soup: BeautifulSoup, should_ignore_pound: bool = True +) -> list[str]: + internal_links = [] + for link in cast(list[dict[str, Any]], soup.find_all("a")): + href = cast(str | None, link.get("href")) + if not href: + continue + + if should_ignore_pound and "#" in href: + href = href.split("#")[0] + + if not is_valid_url(href): + href = urljoin(url, href) + + if urlparse(href).netloc == urlparse(url).netloc and base_url in href: + internal_links.append(href) + return internal_links + + +class BatchWebLoader(BatchLoader): + def __init__( + self, + base_url: str, + batch_size: int = INDEX_BATCH_SIZE, + ) -> None: + self.base_url = base_url + self.batch_size = batch_size + + def load(self) -> Generator[list[Document], None, None]: + """Traverses through all pages found on the website + and converts them into documents""" + visited_links: set[str] = set() + to_visit: list[str] = [self.base_url] + doc_batch: list[Document] = [] + + with sync_playwright() as playwright: + browser = playwright.chromium.launch(headless=True) + context = browser.new_context() + + while to_visit: + current_url = to_visit.pop() + if current_url in visited_links: + continue + visited_links.add(current_url) + + try: + page = context.new_page() + page.goto(current_url) + content = page.content() + soup = BeautifulSoup(content, "html.parser") + + # Heuristics based cleaning + for undesired_tag in ["nav", "header", "footer", "meta"]: + [tag.extract() for tag in soup.find_all(undesired_tag)] + for undesired_div in ["sidebar", "header", "footer"]: + [ + tag.extract() + for tag in soup.find_all("div", {"class": undesired_div}) + ] + + page_text = soup.get_text(TAG_SEPARATOR) + + doc_batch.append( + Document( + id=current_url, + sections=[Section(link=current_url, text=page_text)], + metadata={SOURCE_TYPE: DocumentSource.Web}, + ) + ) + + internal_links = get_internal_links( + self.base_url, current_url, soup + ) + for link in internal_links: + if link not in visited_links: + to_visit.append(link) + + page.close() + except Exception as e: + logger.error(f"Failed to fetch '{current_url}': {e}") + continue + + if len(doc_batch) >= self.batch_size: + yield doc_batch + doc_batch = [] + + if doc_batch: + yield doc_batch diff --git a/backend/danswer/datastores/__init__.py b/backend/danswer/datastores/__init__.py new file mode 100644 index 0000000000..247027fa0a --- /dev/null +++ b/backend/danswer/datastores/__init__.py @@ -0,0 +1,12 @@ +from typing import Type + +from danswer.datastores.interfaces import Datastore +from danswer.datastores.qdrant.store import QdrantDatastore + + +def get_selected_datastore_cls() -> Type[Datastore]: + """Returns the selected Datastore cls. Only one datastore + should be selected for a specific deployment.""" + # TOOD: when more datastores are added, look at env variable to + # figure out which one should be returned + return QdrantDatastore diff --git a/backend/danswer/datastores/interfaces.py b/backend/danswer/datastores/interfaces.py new file mode 100644 index 0000000000..8969f1325c --- /dev/null +++ b/backend/danswer/datastores/interfaces.py @@ -0,0 +1,14 @@ +import abc + +from danswer.chunking.models import EmbeddedIndexChunk +from danswer.chunking.models import InferenceChunk + + +class Datastore: + @abc.abstractmethod + def index(self, chunks: list[EmbeddedIndexChunk]) -> bool: + raise NotImplementedError + + @abc.abstractmethod + def search(self, query: str, num_to_retrieve: int) -> list[InferenceChunk]: + raise NotImplementedError diff --git a/backend/danswer/datastores/qdrant/__init__.py b/backend/danswer/datastores/qdrant/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/datastores/qdrant/indexing.py b/backend/danswer/datastores/qdrant/indexing.py new file mode 100644 index 0000000000..90414db2f0 --- /dev/null +++ b/backend/danswer/datastores/qdrant/indexing.py @@ -0,0 +1,85 @@ +import uuid + +from danswer.chunking.models import EmbeddedIndexChunk +from danswer.configs.constants import ALLOWED_GROUPS +from danswer.configs.constants import ALLOWED_USERS +from danswer.configs.constants import CHUNK_ID +from danswer.configs.constants import CONTENT +from danswer.configs.constants import DOCUMENT_ID +from danswer.configs.constants import DocumentSource +from danswer.configs.constants import SECTION_CONTINUATION +from danswer.configs.constants import SOURCE_LINKS +from danswer.configs.constants import SOURCE_TYPE +from danswer.configs.model_configs import DOC_EMBEDDING_DIM +from danswer.utils.clients import get_qdrant_client +from danswer.utils.logging import setup_logger +from qdrant_client import QdrantClient +from qdrant_client.http.models.models import UpdateStatus +from qdrant_client.models import Distance +from qdrant_client.models import PointStruct +from qdrant_client.models import VectorParams + +logger = setup_logger() + +DEFAULT_BATCH_SIZE = 30 + + +def recreate_collection(collection_name: str, embedding_dim: int = DOC_EMBEDDING_DIM): + logger.info(f"Attempting to recreate collection {collection_name}") + result = get_qdrant_client().recreate_collection( + collection_name=collection_name, + vectors_config=VectorParams(size=embedding_dim, distance=Distance.COSINE), + ) + if not result: + raise RuntimeError("Could not create Qdrant collection") + + +def index_chunks( + chunks: list[EmbeddedIndexChunk], + collection: str, + client: QdrantClient | None = None, + batch_upsert: bool = False, +) -> bool: + if client is None: + client = get_qdrant_client() + + point_structs = [] + for chunk in chunks: + document = chunk.source_document + point_structs.append( + PointStruct( + id=str(uuid.uuid4()), + payload={ + DOCUMENT_ID: document.id, + CHUNK_ID: chunk.chunk_id, + CONTENT: chunk.content, + SOURCE_TYPE: str( + document.metadata.get("source_type", DocumentSource.Unknown) + ), + SOURCE_LINKS: chunk.source_links, + SECTION_CONTINUATION: chunk.section_continuation, + ALLOWED_USERS: [], # TODO + ALLOWED_GROUPS: [], # TODO + }, + vector=chunk.embedding, + ) + ) + + index_results = None + if batch_upsert: + point_struct_batches = [ + point_structs[x : x + DEFAULT_BATCH_SIZE] + for x in range(0, len(point_structs), DEFAULT_BATCH_SIZE) + ] + for point_struct_batch in point_struct_batches: + index_results = client.upsert( + collection_name=collection, points=point_struct_batch + ) + logger.info( + f"Indexing {len(point_struct_batch)} chunks into collection '{collection}', " + f"status: {index_results.status}" + ) + else: + index_results = client.upsert(collection_name=collection, points=point_structs) + logger.info(f"Batch indexing status: {index_results.status}") + return index_results is not None and index_results.status == UpdateStatus.COMPLETED diff --git a/backend/danswer/datastores/qdrant/store.py b/backend/danswer/datastores/qdrant/store.py new file mode 100644 index 0000000000..478a252303 --- /dev/null +++ b/backend/danswer/datastores/qdrant/store.py @@ -0,0 +1,55 @@ +from danswer.chunking.models import EmbeddedIndexChunk +from danswer.chunking.models import InferenceChunk +from danswer.configs.app_configs import QDRANT_DEFAULT_COLLECTION +from danswer.datastores.interfaces import Datastore +from danswer.datastores.qdrant.indexing import index_chunks +from danswer.embedding.biencoder import get_default_model +from danswer.utils.clients import get_qdrant_client +from danswer.utils.logging import setup_logger +from qdrant_client.http.models import FieldCondition +from qdrant_client.http.models import Filter +from qdrant_client.http.models import MatchValue + +logger = setup_logger() + + +class QdrantDatastore(Datastore): + def __init__(self, collection: str = QDRANT_DEFAULT_COLLECTION) -> None: + self.collection = collection + self.client = get_qdrant_client() + + def index(self, chunks: list[EmbeddedIndexChunk]) -> bool: + return index_chunks( + chunks=chunks, collection=self.collection, client=self.client + ) + + def search(self, query: str, num_to_retrieve: int) -> list[InferenceChunk]: + query_embedding = get_default_model().encode( + query + ) # TODO: make this part of the embedder interface + hits = self.client.search( + collection_name=self.collection, + query_vector=query_embedding + if isinstance(query_embedding, list) + else query_embedding.tolist(), + query_filter=None, + limit=num_to_retrieve, + ) + return [InferenceChunk.from_dict(hit.payload) for hit in hits] + + def get_from_id(self, object_id: str) -> InferenceChunk | None: + matches, _ = self.client.scroll( + collection_name=self.collection, + scroll_filter=Filter( + should=[FieldCondition(key="id", match=MatchValue(value=object_id))] + ), + ) + if not matches: + return None + + if len(matches) > 1: + logger.error(f"Found multiple matches for {logger}: {matches}") + + match = matches[0] + + return InferenceChunk.from_dict(match.payload) diff --git a/backend/danswer/direct_qa/__init__.py b/backend/danswer/direct_qa/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/direct_qa/qa_prompts.py b/backend/danswer/direct_qa/qa_prompts.py new file mode 100644 index 0000000000..7fbd908981 --- /dev/null +++ b/backend/danswer/direct_qa/qa_prompts.py @@ -0,0 +1,28 @@ +DOC_SEP_PAT = "---NEW DOCUMENT---" +QUESTION_PAT = "Query:" +ANSWER_PAT = "Answer:" +UNCERTAINTY_PAT = "?" +QUOTE_PAT = "Quote:" + + +def generic_prompt_processor(question: str, documents: list[str]) -> str: + prompt = ( + f"Answer the query based on the documents below and quote the documents sections containing " + f'the answer. Respond with one "{ANSWER_PAT}" section and one or more "{QUOTE_PAT}" sections. ' + f"For each quote, only include text exactly from the documents, don't include the source. " + f'If the query cannot be answered based on the documents, say "{UNCERTAINTY_PAT}". ' + f'Each document is prefixed with "{DOC_SEP_PAT}".\n\n' + ) + + for document in documents: + prompt += f"\n{DOC_SEP_PAT}\n{document}" + + prompt += "\n\n---\n\n" + prompt += f"{QUESTION_PAT}\n{question}\n" + prompt += f"{ANSWER_PAT}\n" + return prompt + + +BASIC_QA_PROMPTS = { + "generic-qa": generic_prompt_processor, +} diff --git a/backend/danswer/direct_qa/question_answer.py b/backend/danswer/direct_qa/question_answer.py new file mode 100644 index 0000000000..afb3a29efb --- /dev/null +++ b/backend/danswer/direct_qa/question_answer.py @@ -0,0 +1,166 @@ +import math +import re +from collections.abc import Callable +from typing import Dict +from typing import Optional +from typing import Tuple +from typing import Union + +import openai +import regex +from danswer.chunking.models import InferenceChunk +from danswer.configs.app_configs import OPENAI_API_KEY +from danswer.configs.app_configs import QUOTE_ALLOWED_ERROR_PERCENT +from danswer.configs.constants import DOCUMENT_ID +from danswer.configs.constants import SOURCE_LINK +from danswer.configs.constants import SOURCE_TYPE +from danswer.configs.model_configs import OPENAI_MAX_OUTPUT_TOKENS +from danswer.configs.model_configs import OPENAPI_MODEL_VERSION +from danswer.direct_qa.qa_prompts import ANSWER_PAT +from danswer.direct_qa.qa_prompts import QUOTE_PAT +from danswer.direct_qa.qa_prompts import UNCERTAINTY_PAT +from danswer.utils.logging import setup_logger +from danswer.utils.text_processing import clean_model_quote +from danswer.utils.text_processing import shared_precompare_cleanup + + +logger = setup_logger() + +openai.api_key = OPENAI_API_KEY + + +def ask_openai( + complete_qa_prompt: str, + model: str = OPENAPI_MODEL_VERSION, + max_tokens: int = OPENAI_MAX_OUTPUT_TOKENS, +) -> str: + try: + response = openai.Completion.create( + prompt=complete_qa_prompt, + temperature=0, + top_p=1, + frequency_penalty=0, + presence_penalty=0, + model=model, + max_tokens=max_tokens, + ) + model_answer = response["choices"][0]["text"].strip() + logger.info("OpenAI Token Usage: " + str(response["usage"]).replace("\n", "")) + return model_answer + except Exception as e: + logger.exception(e) + return "Model Failure" + + +def answer_question( + query: str, + context_docs: list[str], + prompt_processor: Callable[[str, list[str]], str], +) -> str: + formatted_prompt = prompt_processor(query, context_docs) + logger.debug(formatted_prompt) + return ask_openai(formatted_prompt) + + +def separate_answer_quotes( + answer_raw: str, +) -> Tuple[Optional[str], Optional[list[str]]]: + """Gives back the answer and quote sections""" + null_answer_check = ( + answer_raw.replace(ANSWER_PAT, "").replace(QUOTE_PAT, "").strip() + ) + + # If model just gives back the uncertainty pattern to signify answer isn't found or nothing at all + if null_answer_check == UNCERTAINTY_PAT or not null_answer_check: + return None, None + + # If no answer section, don't care about the quote + if answer_raw.lower().strip().startswith(QUOTE_PAT.lower()): + return None, None + + # Sometimes model regenerates the Answer: pattern despite it being provided in the prompt + if answer_raw.lower().startswith(ANSWER_PAT.lower()): + answer_raw = answer_raw[len(ANSWER_PAT) :] + + # Accept quote sections starting with the lower case version + answer_raw = answer_raw.replace( + f"\n{QUOTE_PAT}".lower(), f"\n{QUOTE_PAT}" + ) # Just in case model unreliable + + sections = re.split(rf"(?<=\n){QUOTE_PAT}", answer_raw) + sections_clean = [ + str(section).strip() for section in sections if str(section).strip() + ] + if not sections_clean: + return None, None + + answer = str(sections_clean[0]) + if len(sections) == 1: + return answer, None + return answer, sections_clean[1:] + + +def match_quotes_to_docs( + quotes: list[str], + chunks: list[InferenceChunk], + max_error_percent: float = QUOTE_ALLOWED_ERROR_PERCENT, + fuzzy_search: bool = False, + prefix_only_length: int = 100, +) -> Dict[str, Dict[str, Union[str, int, None]]]: + quotes_dict: dict[str, dict[str, Union[str, int, None]]] = {} + for quote in quotes: + max_edits = math.ceil(float(len(quote)) * max_error_percent) + + for chunk in chunks: + if not chunk.source_links: + continue + + quote_clean = shared_precompare_cleanup( + clean_model_quote(quote, trim_length=prefix_only_length) + ) + chunk_clean = shared_precompare_cleanup(chunk.content) + + # Finding the offset of the quote in the plain text + if fuzzy_search: + re_search_str = ( + r"(" + re.escape(quote_clean) + r"){e<=" + str(max_edits) + r"}" + ) + found = regex.search(re_search_str, chunk_clean) + if not found: + continue + offset = found.span()[0] + else: + if quote_clean not in chunk_clean: + continue + offset = chunk_clean.index(quote_clean) + + # Extracting the link from the offset + curr_link = None + for link_offset, link in chunk.source_links.items(): + # Should always find one because offset is at least 0 and there must be a 0 link_offset + if int(link_offset) <= offset: + curr_link = link + else: + quotes_dict[quote] = { + DOCUMENT_ID: chunk.document_id, + SOURCE_LINK: curr_link, + SOURCE_TYPE: chunk.source_type, + } + break + quotes_dict[quote] = { + DOCUMENT_ID: chunk.document_id, + SOURCE_LINK: curr_link, + SOURCE_TYPE: chunk.source_type, + } + break + return quotes_dict + + +def process_answer( + answer_raw: str, chunks: list[InferenceChunk] +) -> Tuple[Optional[str], Optional[Dict[str, Dict[str, Union[str, int, None]]]]]: + answer, quote_strings = separate_answer_quotes(answer_raw) + if not answer or not quote_strings: + return None, None + quotes_dict = match_quotes_to_docs(quote_strings, chunks) + return answer, quotes_dict diff --git a/backend/danswer/direct_qa/semantic_search.py b/backend/danswer/direct_qa/semantic_search.py new file mode 100644 index 0000000000..f630121dc8 --- /dev/null +++ b/backend/danswer/direct_qa/semantic_search.py @@ -0,0 +1,89 @@ +from typing import List + +import openai +from danswer.chunking.models import InferenceChunk +from danswer.configs.app_configs import NUM_RERANKED_RESULTS +from danswer.configs.app_configs import NUM_RETURNED_HITS +from danswer.configs.app_configs import OPENAI_API_KEY +from danswer.configs.model_configs import CROSS_EMBED_CONTEXT_SIZE +from danswer.configs.model_configs import CROSS_ENCODER_MODEL +from danswer.configs.model_configs import DOCUMENT_ENCODER_MODEL +from danswer.configs.model_configs import MODEL_CACHE_FOLDER +from danswer.configs.model_configs import QUERY_EMBEDDING_CONTEXT_SIZE +from danswer.utils.clients import get_qdrant_client +from danswer.utils.logging import setup_logger +from danswer.utils.timing import build_timing_wrapper +from sentence_transformers import CrossEncoder # type: ignore +from sentence_transformers import SentenceTransformer # type: ignore + + +logger = setup_logger() + +openai.api_key = OPENAI_API_KEY + + +embedding_model = SentenceTransformer( + DOCUMENT_ENCODER_MODEL, cache_folder=MODEL_CACHE_FOLDER +) +embedding_model.max_seq_length = QUERY_EMBEDDING_CONTEXT_SIZE +cross_encoder = CrossEncoder(CROSS_ENCODER_MODEL) +cross_encoder.max_length = CROSS_EMBED_CONTEXT_SIZE + + +@build_timing_wrapper() +def semantic_retrival( + qdrant_collection: str, + query: str, + num_hits: int = NUM_RETURNED_HITS, + use_openai: bool = False, +) -> List[InferenceChunk]: + if use_openai: + query_embedding = openai.Embedding.create( + input=query, model="text-embedding-ada-002" + )["data"][0]["embedding"] + else: + query_embedding = embedding_model.encode(query) + hits = get_qdrant_client().search( + collection_name=qdrant_collection, + query_vector=query_embedding + if isinstance(query_embedding, list) + else query_embedding.tolist(), + query_filter=None, + limit=num_hits, + ) + + retrieved_chunks = [] + for hit in hits: + payload = hit.payload + retrieved_chunks.append(InferenceChunk.from_dict(payload)) + + return retrieved_chunks + + +@build_timing_wrapper() +def semantic_reranking( + query: str, + chunks: List[InferenceChunk], + filtered_result_set_size: int = NUM_RERANKED_RESULTS, +) -> List[InferenceChunk]: + sim_scores = cross_encoder.predict([(query, chunk.content) for chunk in chunks]) + scored_results = list(zip(sim_scores, chunks)) + scored_results.sort(key=lambda x: x[0], reverse=True) + ranked_sim_scores, ranked_chunks = zip(*scored_results) + + logger.debug( + f"Reranked similarity scores: {str(ranked_sim_scores[:filtered_result_set_size])}" + ) + + return ranked_chunks[:filtered_result_set_size] + + +def semantic_search( + qdrant_collection: str, + query: str, + num_hits: int = NUM_RETURNED_HITS, + filtered_result_set_size: int = NUM_RERANKED_RESULTS, +) -> List[InferenceChunk]: + top_chunks = semantic_retrival(qdrant_collection, query, num_hits) + ranked_chunks = semantic_reranking(query, top_chunks, filtered_result_set_size) + return ranked_chunks diff --git a/backend/danswer/dynamic_configs/__init__.py b/backend/danswer/dynamic_configs/__init__.py new file mode 100644 index 0000000000..d2bbb9db66 --- /dev/null +++ b/backend/danswer/dynamic_configs/__init__.py @@ -0,0 +1,15 @@ +import os + +from danswer.dynamic_configs.file_system.store import ( + FileSystemBackedDynamicConfigStore, +) +from danswer.dynamic_configs.interface import DynamicConfigStore + + +def get_dynamic_config_store() -> DynamicConfigStore: + dynamic_config_store_type = os.environ.get("DYNAMIC_CONFIG_STORE") + if dynamic_config_store_type == FileSystemBackedDynamicConfigStore.__name__: + return FileSystemBackedDynamicConfigStore(os.environ["DYNAMIC_CONFIG_DIR_PATH"]) + + # TODO: change exception type + raise Exception("Unknown dynamic config store type") diff --git a/backend/danswer/dynamic_configs/file_system/store.py b/backend/danswer/dynamic_configs/file_system/store.py new file mode 100644 index 0000000000..dee788d27f --- /dev/null +++ b/backend/danswer/dynamic_configs/file_system/store.py @@ -0,0 +1,38 @@ +import json +from pathlib import Path +from typing import cast + +from danswer.dynamic_configs.interface import ConfigNotFoundError +from danswer.dynamic_configs.interface import DynamicConfigStore +from danswer.dynamic_configs.interface import JSON_ro +from filelock import FileLock + + +FILE_LOCK_TIMEOUT = 10 + + +def _get_file_lock(file_name: Path) -> FileLock: + return FileLock(file_name.with_suffix(".lock")) + + +class FileSystemBackedDynamicConfigStore(DynamicConfigStore): + def __init__(self, dir_path: str) -> None: + # TODO (chris): maybe require all possible keys to be passed in + # at app start somehow to prevent key overlaps + self.dir_path = Path(dir_path) + + def store(self, key: str, val: JSON_ro) -> None: + file_path = self.dir_path / key + lock = _get_file_lock(file_path) + with lock.acquire(timeout=FILE_LOCK_TIMEOUT): + with open(file_path, "w+") as f: + json.dump(val, f) + + def load(self, key: str) -> JSON_ro: + file_path = self.dir_path / key + if not file_path.exists(): + raise ConfigNotFoundError + lock = _get_file_lock(file_path) + with lock.acquire(timeout=FILE_LOCK_TIMEOUT): + with open(self.dir_path / key) as f: + return cast(JSON_ro, json.load(f)) diff --git a/backend/danswer/dynamic_configs/interface.py b/backend/danswer/dynamic_configs/interface.py new file mode 100644 index 0000000000..00e6d8a3f9 --- /dev/null +++ b/backend/danswer/dynamic_configs/interface.py @@ -0,0 +1,23 @@ +import abc +from collections.abc import Mapping +from collections.abc import Sequence +from typing import TypeAlias + + +JSON_ro: TypeAlias = ( + Mapping[str, "JSON_ro"] | Sequence["JSON_ro"] | str | int | float | bool | None +) + + +class ConfigNotFoundError(Exception): + pass + + +class DynamicConfigStore: + @abc.abstractmethod + def store(self, key: str, val: JSON_ro) -> None: + raise NotImplementedError + + @abc.abstractmethod + def load(self, key: str) -> JSON_ro: + raise NotImplementedError diff --git a/backend/danswer/embedding/__init__.py b/backend/danswer/embedding/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/embedding/biencoder.py b/backend/danswer/embedding/biencoder.py new file mode 100644 index 0000000000..02b3a06741 --- /dev/null +++ b/backend/danswer/embedding/biencoder.py @@ -0,0 +1,55 @@ +from danswer.chunking.models import EmbeddedIndexChunk +from danswer.chunking.models import IndexChunk +from danswer.configs.model_configs import BATCH_SIZE_ENCODE_CHUNKS +from danswer.configs.model_configs import DOC_EMBEDDING_CONTEXT_SIZE +from danswer.configs.model_configs import DOCUMENT_ENCODER_MODEL +from danswer.embedding.type_aliases import Embedder +from danswer.utils.logging import setup_logger +from sentence_transformers import SentenceTransformer # type: ignore + + +logger = setup_logger() + +_MODEL: None | SentenceTransformer = None + + +def get_default_model() -> SentenceTransformer: + global _MODEL + if _MODEL is None: + _MODEL = SentenceTransformer(DOCUMENT_ENCODER_MODEL) + _MODEL.max_seq_length = DOC_EMBEDDING_CONTEXT_SIZE + + return _MODEL + + +def encode_chunks( + chunks: list[IndexChunk], + embedding_model: SentenceTransformer | None = None, + batch_size: int = BATCH_SIZE_ENCODE_CHUNKS, +) -> list[EmbeddedIndexChunk]: + embedded_chunks = [] + if embedding_model is None: + embedding_model = get_default_model() + + chunk_batches = [ + chunks[i : i + batch_size] for i in range(0, len(chunks), batch_size) + ] + for batch_ind, chunk_batch in enumerate(chunk_batches): + embeddings_batch = embedding_model.encode( + [chunk.content for chunk in chunk_batch] + ) + embedded_chunks.extend( + [ + EmbeddedIndexChunk( + **{k: getattr(chunk, k) for k in chunk.__dataclass_fields__}, + embedding=embeddings_batch[i].tolist() + ) + for i, chunk in enumerate(chunk_batch) + ] + ) + return embedded_chunks + + +class DefaultEmbedder(Embedder): + def embed(self, chunks: list[IndexChunk]) -> list[EmbeddedIndexChunk]: + return encode_chunks(chunks) diff --git a/backend/danswer/embedding/type_aliases.py b/backend/danswer/embedding/type_aliases.py new file mode 100644 index 0000000000..cf8d6fbc97 --- /dev/null +++ b/backend/danswer/embedding/type_aliases.py @@ -0,0 +1,7 @@ +from danswer.chunking.models import EmbeddedIndexChunk +from danswer.chunking.models import IndexChunk + + +class Embedder: + def embed(self, chunks: list[IndexChunk]) -> list[EmbeddedIndexChunk]: + raise NotImplementedError diff --git a/backend/danswer/main.py b/backend/danswer/main.py new file mode 100644 index 0000000000..8149e8b636 --- /dev/null +++ b/backend/danswer/main.py @@ -0,0 +1,35 @@ +import uvicorn +from danswer.configs.app_configs import APP_HOST +from danswer.configs.app_configs import APP_PORT +from danswer.server.admin import router as admin_router +from danswer.server.event_loading import router as event_processing_router +from danswer.server.search_backend import router as backend_router +from danswer.utils.logging import setup_logger +from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware + + +logger = setup_logger() + + +def get_application() -> FastAPI: + application = FastAPI(title="Internal Search QA Backend", debug=True, version="0.1") + application.include_router(backend_router) + application.include_router(event_processing_router) + application.include_router(admin_router) + return application + + +app = get_application() +app.add_middleware( + CORSMiddleware, + allow_origins=["*"], # Change this to the list of allowed origins if needed + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + + +if __name__ == "__main__": + logger.info(f"Running QA Service on http://{APP_HOST}:{str(APP_PORT)}/") + uvicorn.run(app, host=APP_HOST, port=APP_PORT) diff --git a/backend/danswer/server/__init__.py b/backend/danswer/server/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/server/admin.py b/backend/danswer/server/admin.py new file mode 100644 index 0000000000..3f8ca482f3 --- /dev/null +++ b/backend/danswer/server/admin.py @@ -0,0 +1,23 @@ +from danswer.connectors.slack.config import get_slack_config +from danswer.connectors.slack.config import SlackConfig +from danswer.connectors.slack.config import update_slack_config +from danswer.dynamic_configs.interface import ConfigNotFoundError +from danswer.utils.logging import setup_logger +from fastapi import APIRouter + +router = APIRouter(prefix="/admin") + +logger = setup_logger() + + +@router.get("/slack_connector_config", response_model=SlackConfig) +def fetch_slack_config(): + try: + return get_slack_config() + except ConfigNotFoundError: + return SlackConfig(slack_bot_token="", workspace_id="") + + +@router.post("/slack_connector_config") +def modify_slack_config(slack_config: SlackConfig): + update_slack_config(slack_config) diff --git a/backend/danswer/server/event_loading.py b/backend/danswer/server/event_loading.py new file mode 100644 index 0000000000..99bdcd6f48 --- /dev/null +++ b/backend/danswer/server/event_loading.py @@ -0,0 +1,61 @@ +from typing import Any + +from danswer.connectors.slack.pull import get_thread +from danswer.connectors.slack.pull import thread_to_doc +from danswer.connectors.slack.utils import get_client +from danswer.utils.indexing_pipeline import build_indexing_pipeline +from danswer.utils.logging import setup_logger +from fastapi import APIRouter +from pydantic import BaseModel +from pydantic import Extra + +router = APIRouter() + +logger = setup_logger() + + +class SlackEvent(BaseModel, extra=Extra.allow): + type: str + challenge: str | None + event: dict[str, Any] | None + + +class EventHandlingResponse(BaseModel): + challenge: str | None + + +@router.post("/process_slack_event", response_model=EventHandlingResponse) +def process_slack_event(event: SlackEvent): + logger.info("Recieved slack event: %s", event.dict()) + + if event.type == "url_verification": + return {"challenge": event.challenge} + + if event.type == "event_callback" and event.event: + try: + # TODO: process in the background as per slack guidelines + message_type = event.event.get("subtype") + if message_type == "message_changed": + message = event.event["message"] + else: + message = event.event + + channel_id = event.event["channel"] + thread_ts = message.get("thread_ts") + doc = thread_to_doc( + channel_id, + get_thread(get_client(), channel_id, thread_ts) + if thread_ts + else [message], + ) + if doc is None: + logger.info("Message was determined to not be indexable") + return {} + + build_indexing_pipeline()([doc]) + except Exception: + logger.exception("Failed to process slack message") + return {} + + logger.error("Unsupported event type: %s", event.type) + return {} diff --git a/backend/danswer/server/search_backend.py b/backend/danswer/server/search_backend.py new file mode 100644 index 0000000000..dae9664d2c --- /dev/null +++ b/backend/danswer/server/search_backend.py @@ -0,0 +1,109 @@ +import time +from http import HTTPStatus +from typing import Dict +from typing import List +from typing import Union + +from danswer.configs.app_configs import DEFAULT_PROMPT +from danswer.configs.app_configs import KEYWORD_MAX_HITS +from danswer.configs.constants import CONTENT +from danswer.configs.constants import SOURCE_LINKS +from danswer.direct_qa.qa_prompts import BASIC_QA_PROMPTS +from danswer.direct_qa.question_answer import answer_question +from danswer.direct_qa.question_answer import process_answer +from danswer.direct_qa.semantic_search import semantic_search +from danswer.utils.clients import TSClient +from danswer.utils.logging import setup_logger +from fastapi import APIRouter +from pydantic import BaseModel + + +logger = setup_logger() + +router = APIRouter() + + +class ServerStatus(BaseModel): + status: str + + +class QAQuestion(BaseModel): + query: str + collection: str + + +class QAResponse(BaseModel): + answer: Union[str, None] + quotes: Union[Dict[str, Dict[str, str]], None] + + +class KeywordResponse(BaseModel): + results: Union[List[str], None] + + +@router.get("/", response_model=ServerStatus) +@router.get("/status", response_model=ServerStatus) +def read_server_status(): + return {"status": HTTPStatus.OK.value} + + +@router.post("/direct-qa", response_model=QAResponse) +def direct_qa(question: QAQuestion): + prompt_processor = BASIC_QA_PROMPTS[DEFAULT_PROMPT] + query = question.query + collection = question.collection + + logger.info(f"Received semantic query: {query}") + start_time = time.time() + + ranked_chunks = semantic_search(collection, query) + sem_search_time = time.time() + top_docs = [ranked_chunk.document_id for ranked_chunk in ranked_chunks] + top_contents = [ranked_chunk.content for ranked_chunk in ranked_chunks] + + logger.info(f"Semantic search took {sem_search_time - start_time} seconds") + files_log_msg = f"Top links from semantic search: {', '.join(top_docs)}" + logger.info(files_log_msg) + + qa_answer = answer_question(query, top_contents, prompt_processor) + qa_time = time.time() + logger.debug(qa_answer) + logger.info(f"GPT QA took {qa_time - sem_search_time} seconds") + + # Postprocessing, no more models involved, purely rule based + answer, quotes_dict = process_answer(qa_answer, ranked_chunks) + postprocess_time = time.time() + logger.info(f"Postprocessing took {postprocess_time - qa_time} seconds") + + total_time = time.time() - start_time + logger.info(f"Total QA took {total_time} seconds") + + qa_response = {"answer": answer, "quotes": quotes_dict} + return qa_response + + +@router.post("/keyword-search", response_model=KeywordResponse) +def keyword_search(question: QAQuestion): + ts_client = TSClient.get_instance() + query = question.query + collection = question.collection + + logger.info(f"Received keyword query: {query}") + start_time = time.time() + + search_results = ts_client.collections[collection].documents.search( + { + "q": query, + "query_by": CONTENT, + "per_page": KEYWORD_MAX_HITS, + "limit_hits": KEYWORD_MAX_HITS, + } + ) + + hits = search_results["hits"] + sources = [hit["document"][SOURCE_LINKS][0] for hit in hits] + + total_time = time.time() - start_time + logger.info(f"Total Keyword Search took {total_time} seconds") + + return {"results": sources} diff --git a/backend/danswer/utils/__init__.py b/backend/danswer/utils/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/danswer/utils/clients.py b/backend/danswer/utils/clients.py new file mode 100644 index 0000000000..6256e8904f --- /dev/null +++ b/backend/danswer/utils/clients.py @@ -0,0 +1,62 @@ +from typing import Optional + +import typesense # type: ignore +from danswer.configs.app_configs import DB_CONN_TIMEOUT +from danswer.configs.app_configs import QDRANT_API_KEY +from danswer.configs.app_configs import QDRANT_HOST +from danswer.configs.app_configs import QDRANT_PORT +from danswer.configs.app_configs import QDRANT_URL +from danswer.configs.app_configs import TYPESENSE_API_KEY +from danswer.configs.app_configs import TYPESENSE_HOST +from danswer.configs.app_configs import TYPESENSE_PORT +from qdrant_client import QdrantClient + + +_qdrant_client: Optional[QdrantClient] = None + + +def get_qdrant_client() -> QdrantClient: + global _qdrant_client + if _qdrant_client is None: + if QDRANT_URL and QDRANT_API_KEY: + _qdrant_client = QdrantClient(url=QDRANT_URL, api_key=QDRANT_API_KEY) + elif QDRANT_HOST and QDRANT_PORT: + _qdrant_client = QdrantClient(host=QDRANT_HOST, port=QDRANT_PORT) + else: + raise Exception("Unable to instantiate QdrantClient") + + return _qdrant_client + + +class TSClient: + __instance: Optional["TSClient"] = None + + @staticmethod + def get_instance( + host=TYPESENSE_HOST, + port=TYPESENSE_PORT, + api_key=TYPESENSE_API_KEY, + timeout=DB_CONN_TIMEOUT, + ) -> "TSClient": + if TSClient.__instance is None: + TSClient(host, port, api_key, timeout) + return TSClient.__instance # type: ignore + + def __init__(self, host, port, api_key, timeout): + if TSClient.__instance is not None: + raise Exception( + "Singleton instance already exists. Use TSClient.get_instance() to get the instance." + ) + else: + TSClient.__instance = self + self.client = typesense.Client( + { + "api_key": api_key, + "nodes": [{"host": host, "port": str(port), "protocol": "http"}], + "connection_timeout_seconds": timeout, + } + ) + + # delegate all client operations to the third party client + def __getattr__(self, name): + return getattr(self.client, name) diff --git a/backend/danswer/utils/indexing_pipeline.py b/backend/danswer/utils/indexing_pipeline.py new file mode 100644 index 0000000000..0b864d18dc --- /dev/null +++ b/backend/danswer/utils/indexing_pipeline.py @@ -0,0 +1,43 @@ +from collections.abc import Callable +from functools import partial +from itertools import chain + +from danswer.chunking.chunk import Chunker +from danswer.chunking.chunk import DefaultChunker +from danswer.connectors.models import Document +from danswer.datastores.interfaces import Datastore +from danswer.datastores.qdrant.store import QdrantDatastore +from danswer.embedding.biencoder import DefaultEmbedder +from danswer.embedding.type_aliases import Embedder + + +def _indexing_pipeline( + chunker: Chunker, + embedder: Embedder, + datastore: Datastore, + documents: list[Document], +) -> None: + chunks = list(chain(*[chunker.chunk(document) for document in documents])) + chunks_with_embeddings = embedder.embed(chunks) + datastore.index(chunks_with_embeddings) + + +def build_indexing_pipeline( + *, + chunker: Chunker | None = None, + embedder: Embedder | None = None, + datastore: Datastore | None = None, +) -> Callable[[list[Document]], None]: + """Builds a pipline which takes in a list of docs and indexes them. + + Default uses _ chunker, _ embedder, and qdrant for the datastore""" + if chunker is None: + chunker = DefaultChunker() + + if embedder is None: + embedder = DefaultEmbedder() + + if datastore is None: + datastore = QdrantDatastore() + + return partial(_indexing_pipeline, chunker, embedder, datastore) diff --git a/backend/danswer/utils/logging.py b/backend/danswer/utils/logging.py new file mode 100644 index 0000000000..1d2cc9150a --- /dev/null +++ b/backend/danswer/utils/logging.py @@ -0,0 +1,24 @@ +import logging + + +def setup_logger(name=__name__, log_level=logging.INFO): + logger = logging.getLogger(name) + + # If the logger already has handlers, assume it was already configured and return it. + if logger.handlers: + return logger + + logger.setLevel(log_level) + + formatter = logging.Formatter( + "%(asctime)s %(filename)20s%(lineno)4s : %(message)s", + datefmt="%m/%d/%Y %I:%M:%S %p", + ) + + handler = logging.StreamHandler() + handler.setLevel(log_level) + handler.setFormatter(formatter) + + logger.addHandler(handler) + + return logger diff --git a/backend/danswer/utils/text_processing.py b/backend/danswer/utils/text_processing.py new file mode 100644 index 0000000000..86ce262dc2 --- /dev/null +++ b/backend/danswer/utils/text_processing.py @@ -0,0 +1,19 @@ +def clean_model_quote(quote: str, trim_length: int) -> str: + quote_clean = quote.strip() + if quote_clean[0] == '"': + quote_clean = quote_clean[1:] + if quote_clean[-1] == '"': + quote_clean = quote_clean[:-1] + if trim_length > 0: + quote_clean = quote_clean[:trim_length] + return quote_clean + + +def shared_precompare_cleanup(text: str) -> str: + text = text.lower() + text = "".join( + text.split() + ) # GPT models like to return cleaner spacing, not good for quote matching + return text.replace( + "*", "" + ) # GPT models sometimes like to cleanup bulletpoints represented by * diff --git a/backend/danswer/utils/timing.py b/backend/danswer/utils/timing.py new file mode 100644 index 0000000000..c6d1ab7021 --- /dev/null +++ b/backend/danswer/utils/timing.py @@ -0,0 +1,31 @@ +import time +from collections.abc import Callable + +from danswer.utils.logging import setup_logger + +logger = setup_logger() + + +def build_timing_wrapper( + func_name: str | None = None, +) -> Callable[[Callable], Callable]: + """Build a timing wrapper for a function. Logs how long the function took to run. + Use like: + + @build_timing_wrapper() + def my_func(): + ... + """ + + def timing_wrapper(func: Callable) -> Callable: + def wrapped_func(*args, **kwargs): + start_time = time.time() + result = func(*args, **kwargs) + logger.info( + f"{func_name or func.__name__} took {time.time() - start_time} seconds" + ) + return result + + return wrapped_func + + return timing_wrapper diff --git a/backend/deployment/README.md b/backend/deployment/README.md new file mode 100644 index 0000000000..5636c6cf3b --- /dev/null +++ b/backend/deployment/README.md @@ -0,0 +1,5 @@ +This serves as an example for how to deploy everything in a single box. This is far +from optimal, but can get you started easily and cheaply. To run: + +1. Set up a `.env` file in this directory with relevant environment variables (TODO: document) +2. `docker compose up -d --build` \ No newline at end of file diff --git a/backend/deployment/data/nginx/app.conf b/backend/deployment/data/nginx/app.conf new file mode 100644 index 0000000000..099e256190 --- /dev/null +++ b/backend/deployment/data/nginx/app.conf @@ -0,0 +1,43 @@ +upstream app_server { + # fail_timeout=0 means we always retry an upstream even if it failed + # to return a good HTTP response + + # for UNIX domain socket setups + #server unix:/tmp/gunicorn.sock fail_timeout=0; + + # for a TCP configuration + server api:8080 fail_timeout=0; +} + +server { + listen 80; + server_name api.danswer.dev; + + location / { + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_set_header Host $http_host; + # we don't want nginx trying to do something clever with + # redirects, we set the Host: header above already. + proxy_redirect off; + proxy_pass http://app_server; + } + + location /.well-known/acme-challenge/ { + root /var/www/certbot; + } +} + +server { + listen 443 ssl; + server_name api.danswer.dev; + + location / { + proxy_pass http://api.danswer.dev; + } + + ssl_certificate /etc/letsencrypt/live/api.danswer.dev/fullchain.pem; + ssl_certificate_key /etc/letsencrypt/live/api.danswer.dev/privkey.pem; + include /etc/letsencrypt/options-ssl-nginx.conf; + ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; +} \ No newline at end of file diff --git a/backend/deployment/docker-compose.yml b/backend/deployment/docker-compose.yml new file mode 100644 index 0000000000..9aa4868d9d --- /dev/null +++ b/backend/deployment/docker-compose.yml @@ -0,0 +1,42 @@ +# follows https://pentacent.medium.com/nginx-and-lets-encrypt-with-docker-in-less-than-5-minutes-b4b8a60d3a71 +version: '3' +services: + api: + build: + context: .. + dockerfile: Dockerfile + # just for local testing + ports: + - "8080:8080" + env_file: + - .env + volumes: + - local_dynamic_storage:/home/storage + background: + build: + context: .. + dockerfile: Dockerfile.background + env_file: + - .env + volumes: + - local_dynamic_storage:/home/storage + nginx: + image: nginx:1.23.4-alpine + ports: + - "80:80" + - "443:443" + volumes: + - ./data/nginx:/etc/nginx/conf.d + - ./data/certbot/conf:/etc/letsencrypt + - ./data/certbot/www:/var/www/certbot + command: "/bin/sh -c 'while :; do sleep 6h & wait $${!}; nginx -s reload; done & nginx -g \"daemon off;\"'" + depends_on: + - api + certbot: + image: certbot/certbot + volumes: + - ./data/certbot/conf:/etc/letsencrypt + - ./data/certbot/www:/var/www/certbot + entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew; sleep 12h & wait $${!}; done;'" +volumes: + local_dynamic_storage: \ No newline at end of file diff --git a/backend/deployment/init-letsencrypt.sh b/backend/deployment/init-letsencrypt.sh new file mode 100644 index 0000000000..df607a9445 --- /dev/null +++ b/backend/deployment/init-letsencrypt.sh @@ -0,0 +1,80 @@ +#!/bin/bash + +if ! [ -x "$(command -v docker compose)" ]; then + echo 'Error: docker compose is not installed.' >&2 + exit 1 +fi + +domains=(api.danswer.dev www.api.danswer.dev) +rsa_key_size=4096 +data_path="./data/certbot" +email="" # Adding a valid address is strongly recommended +staging=0 # Set to 1 if you're testing your setup to avoid hitting request limits + +if [ -d "$data_path" ]; then + read -p "Existing data found for $domains. Continue and replace existing certificate? (y/N) " decision + if [ "$decision" != "Y" ] && [ "$decision" != "y" ]; then + exit + fi +fi + + +if [ ! -e "$data_path/conf/options-ssl-nginx.conf" ] || [ ! -e "$data_path/conf/ssl-dhparams.pem" ]; then + echo "### Downloading recommended TLS parameters ..." + mkdir -p "$data_path/conf" + curl -s https://raw.githubusercontent.com/certbot/certbot/master/certbot-nginx/certbot_nginx/_internal/tls_configs/options-ssl-nginx.conf > "$data_path/conf/options-ssl-nginx.conf" + curl -s https://raw.githubusercontent.com/certbot/certbot/master/certbot/certbot/ssl-dhparams.pem > "$data_path/conf/ssl-dhparams.pem" + echo +fi + +echo "### Creating dummy certificate for $domains ..." +path="/etc/letsencrypt/live/$domains" +mkdir -p "$data_path/conf/live/$domains" +docker compose run --rm --entrypoint "\ + openssl req -x509 -nodes -newkey rsa:$rsa_key_size -days 1\ + -keyout '$path/privkey.pem' \ + -out '$path/fullchain.pem' \ + -subj '/CN=localhost'" certbot +echo + + +echo "### Starting nginx ..." +docker compose up --force-recreate -d nginx +echo + +echo "### Deleting dummy certificate for $domains ..." +docker compose run --rm --entrypoint "\ + rm -Rf /etc/letsencrypt/live/$domains && \ + rm -Rf /etc/letsencrypt/archive/$domains && \ + rm -Rf /etc/letsencrypt/renewal/$domains.conf" certbot +echo + + +echo "### Requesting Let's Encrypt certificate for $domains ..." +#Join $domains to -d args +domain_args="" +for domain in "${domains[@]}"; do + domain_args="$domain_args -d $domain" +done + +# Select appropriate email arg +case "$email" in + "") email_arg="--register-unsafely-without-email" ;; + *) email_arg="--email $email" ;; +esac + +# Enable staging mode if needed +if [ $staging != "0" ]; then staging_arg="--staging"; fi + +docker compose run --rm --entrypoint "\ + certbot certonly --webroot -w /var/www/certbot \ + $staging_arg \ + $email_arg \ + $domain_args \ + --rsa-key-size $rsa_key_size \ + --agree-tos \ + --force-renewal" certbot +echo + +echo "### Reloading nginx ..." +docker compose exec nginx nginx -s reload diff --git a/backend/requirements/cdk.txt b/backend/requirements/cdk.txt new file mode 100644 index 0000000000..de9d6d332f --- /dev/null +++ b/backend/requirements/cdk.txt @@ -0,0 +1,2 @@ +aws-cdk-lib>=2.0.0 +constructs>=10.0.0 \ No newline at end of file diff --git a/backend/requirements/default.txt b/backend/requirements/default.txt new file mode 100644 index 0000000000..feea343a48 --- /dev/null +++ b/backend/requirements/default.txt @@ -0,0 +1,23 @@ +beautifulsoup4==4.12.0 +fastapi==0.95.0 +filelock==3.12.0 +google-api-python-client==2.86.0 +google-auth-httplib2==0.1.0 +google-auth-oauthlib==1.0.0 +openai==0.27.2 +playwright==1.32.1 +pydantic==1.10.7 +PyPDF2==3.0.1 +pytest-playwright==0.3.2 +qdrant-client==1.1.0 +requests==2.28.2 +sentence-transformers==2.2.2 +slack-sdk==3.20.2 +transformers==4.27.3 +types-beautifulsoup4==4.12.0.3 +types-html5lib==1.1.11.13 +types-regex-2023.3.23.1 +types-requests==2.28.11.17 +types-urllib3==1.26.25.11 +typesense==0.15.1 +uvicorn==0.21.1 diff --git a/backend/requirements/dev.txt b/backend/requirements/dev.txt new file mode 100644 index 0000000000..538d6dae9d --- /dev/null +++ b/backend/requirements/dev.txt @@ -0,0 +1,10 @@ +mypy==1.1.1 +mypy-extensions==1.0.0 +black==23.3.0 +reorder-python-imports==3.9.0 +pre-commit==3.2.2 +types-beautifulsoup4==4.12.0.3 +types-html5lib==1.1.11.13 +types-requests==2.28.11.17 +types-urllib3==1.26.25.11 +types-regex==2023.3.23.1 diff --git a/backend/scripts/ingestion.py b/backend/scripts/ingestion.py new file mode 100644 index 0000000000..bbcde17d6d --- /dev/null +++ b/backend/scripts/ingestion.py @@ -0,0 +1,114 @@ +import argparse +from itertools import chain + +from danswer.chunking.chunk import Chunker +from danswer.chunking.chunk import DefaultChunker +from danswer.configs.app_configs import INDEX_BATCH_SIZE +from danswer.configs.app_configs import QDRANT_DEFAULT_COLLECTION +from danswer.connectors.google_drive.batch import BatchGoogleDriveLoader +from danswer.connectors.slack.batch import BatchSlackLoader +from danswer.connectors.type_aliases import BatchLoader +from danswer.connectors.web.batch import BatchWebLoader +from danswer.datastores.interfaces import Datastore +from danswer.datastores.qdrant.indexing import recreate_collection +from danswer.datastores.qdrant.store import QdrantDatastore +from danswer.embedding.biencoder import DefaultEmbedder +from danswer.embedding.type_aliases import Embedder +from danswer.utils.logging import setup_logger + + +logger = setup_logger() + + +def load_batch( + doc_loader: BatchLoader, + chunker: Chunker, + embedder: Embedder, + datastore: Datastore, +): + num_processed = 0 + total_chunks = 0 + for document_batch in doc_loader.load(): + if not document_batch: + logger.warning("No parseable documents found in batch") + continue + + logger.info(f"Indexed {num_processed} documents") + document_chunks = list( + chain(*[chunker.chunk(document) for document in document_batch]) + ) + num_chunks = len(document_chunks) + total_chunks += num_chunks + logger.info( + f"Document batch yielded {num_chunks} chunks for a total of {total_chunks}" + ) + chunks_with_embeddings = embedder.embed(document_chunks) + datastore.index(chunks_with_embeddings) + num_processed += len(document_batch) + logger.info(f"Finished, indexed a total of {num_processed} documents") + + +def load_slack_batch(file_path: str, qdrant_collection: str): + logger.info("Loading documents from Slack.") + load_batch( + BatchSlackLoader(export_path_str=file_path, batch_size=INDEX_BATCH_SIZE), + DefaultChunker(), + DefaultEmbedder(), + QdrantDatastore(collection=qdrant_collection), + ) + + +def load_web_batch(url: str, qdrant_collection: str): + logger.info("Loading documents from web.") + load_batch( + BatchWebLoader(base_url=url, batch_size=INDEX_BATCH_SIZE), + DefaultChunker(), + DefaultEmbedder(), + QdrantDatastore(collection=qdrant_collection), + ) + + +def load_google_drive_batch(qdrant_collection: str): + logger.info("Loading documents from Google Drive.") + load_batch( + BatchGoogleDriveLoader(batch_size=INDEX_BATCH_SIZE), + DefaultChunker(), + DefaultEmbedder(), + QdrantDatastore(collection=qdrant_collection), + ) + + +class BatchLoadingArgs(argparse.Namespace): + slack_export_dir: str + website_url: str + qdrant_collection: str + rebuild_index: bool + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument( + "--website-url", + default="https://docs.github.com/en/actions", + ) + parser.add_argument( + "--slack-export-dir", + default="/Users/chrisweaver/Downloads/test-slack-export", + ) + parser.add_argument( + "--qdrant-collection", + default=QDRANT_DEFAULT_COLLECTION, + ) + parser.add_argument( + "--rebuild-index", + action="store_true", + help="Deletes and repopulates the semantic search index", + ) + args = parser.parse_args(namespace=BatchLoadingArgs) + + if args.rebuild_index: + recreate_collection(args.qdrant_collection) + + #load_slack_batch(args.slack_export_dir, args.qdrant_collection) + load_web_batch(args.website_url, args.qdrant_collection) + #load_google_drive_batch(args.qdrant_collection) diff --git a/backend/scripts/simulate_frontend.py b/backend/scripts/simulate_frontend.py new file mode 100644 index 0000000000..438fadb5b2 --- /dev/null +++ b/backend/scripts/simulate_frontend.py @@ -0,0 +1,58 @@ +import json + +import requests +from danswer.configs.app_configs import APP_PORT +from danswer.configs.app_configs import QDRANT_DEFAULT_COLLECTION +from danswer.configs.constants import SOURCE_TYPE + + +if __name__ == "__main__": + previous_query = None + while True: + keyword_search = False + query = input( + "\n\nAsk any question:\n - prefix with -k for keyword search\n - input an empty string to " + "rerun last query\n\t" + ) + + if query.lower() in ["q", "quit", "exit", "exit()"]: + break + + if query: + previous_query = query + else: + if not previous_query: + print("No previous query") + continue + print(f"Re-executing previous question:\n\t{previous_query}") + query = previous_query + + endpoint = f"http://127.0.0.1:{APP_PORT}/direct-qa" + if query.startswith("-k "): + keyword_search = True + query = query[2:] + endpoint = f"http://127.0.0.1:{APP_PORT}/keyword-search" + + response = requests.post( + endpoint, json={"query": query, "collection": QDRANT_DEFAULT_COLLECTION} + ) + contents = json.loads(response.content) + if keyword_search: + if contents["results"]: + for link in contents["results"]: + print(link) + else: + print("No matches found") + else: + answer = contents.get("answer") + if answer: + print("Answer: " + answer) + else: + print("Answer: ?") + if contents.get("quotes"): + for ind, (quote, quote_info) in enumerate(contents["quotes"].items()): + print(f"Quote {str(ind)}:\n{quote}") + print(f"Link: {quote_info['link']}") + print(f"Source: {quote_info[SOURCE_TYPE]}") + else: + print("No quotes found") diff --git a/backend/tests/unit/qa_service/chunking/test_chunk.py b/backend/tests/unit/qa_service/chunking/test_chunk.py new file mode 100644 index 0000000000..d4614f3593 --- /dev/null +++ b/backend/tests/unit/qa_service/chunking/test_chunk.py @@ -0,0 +1,84 @@ +import unittest + +from danswer.chunking.chunk import chunk_document +from danswer.chunking.chunk import chunk_large_section +from danswer.connectors.models import Document +from danswer.connectors.models import Section + + +WAR_AND_PEACE = ( + "Well, Prince, so Genoa and Lucca are now just family estates of the Buonapartes. But I warn you, " + "if you don’t tell me that this means war, if you still try to defend the infamies and horrors perpetrated by " + "that Antichrist—I really believe he is Antichrist—I will have nothing more to do with you and you are no longer " + "my friend, no longer my ‘faithful slave,’ as you call yourself! But how do you do? I see I have frightened " + "you—sit down and tell me all the news." +) + + +class TestDocumentChunking(unittest.TestCase): + def setUp(self): + self.large_section = Section(text=WAR_AND_PEACE, link="https://www.test.com/") + self.document = Document( + id="test_document", + metadata={"source_type": "testing"}, + sections=[ + Section( + text="Here is some testing text", link="https://www.test.com/0" + ), + Section( + text="Some more text, still under 100 chars", + link="https://www.test.com/1", + ), + Section( + text="Now with this section it's longer than the chunk size", + link="https://www.test.com/2", + ), + self.large_section, + Section(text="These last 2 sections", link="https://www.test.com/4"), + Section( + text="should be combined into one", link="https://www.test.com/5" + ), + ], + ) + + def test_chunk_large_section(self): + chunks = chunk_large_section( + section=self.large_section, + document=self.document, + start_chunk_id=5, + chunk_size=100, + word_overlap=3, + ) + self.assertEqual(len(chunks), 5) + self.assertEqual(chunks[0].content, WAR_AND_PEACE[:99]) + self.assertEqual( + chunks[-2].content, WAR_AND_PEACE[-176:-63] + ) # slightly longer than 100 due to overlap + self.assertEqual( + chunks[-1].content, WAR_AND_PEACE[-121:] + ) # large overlap with second to last segment + self.assertFalse(chunks[0].section_continuation) + self.assertTrue(chunks[1].section_continuation) + self.assertTrue(chunks[-1].section_continuation) + + def test_chunk_document(self): + chunks = chunk_document(self.document, chunk_size=100, subsection_overlap=3) + self.assertEqual(len(chunks), 8) + self.assertEqual( + chunks[0].content, + self.document.sections[0].text + "\n\n" + self.document.sections[1].text, + ) + self.assertEqual( + chunks[0].source_links, + {0: "https://www.test.com/0", 21: "https://www.test.com/1"}, + ) + self.assertEqual( + chunks[-1].source_links, + {0: "https://www.test.com/4", 18: "https://www.test.com/5"}, + ) + self.assertEqual(chunks[5].chunk_id, 5) + self.assertEqual(chunks[6].source_document, self.document) + + +if __name__ == "__main__": + unittest.main() diff --git a/backend/tests/unit/qa_service/direct_qa/test_question_answer.py b/backend/tests/unit/qa_service/direct_qa/test_question_answer.py new file mode 100644 index 0000000000..c002a85b39 --- /dev/null +++ b/backend/tests/unit/qa_service/direct_qa/test_question_answer.py @@ -0,0 +1,178 @@ +import textwrap +import unittest + +from danswer.chunking.models import InferenceChunk +from danswer.direct_qa.question_answer import match_quotes_to_docs +from danswer.direct_qa.question_answer import separate_answer_quotes + + +class TestQAPostprocessing(unittest.TestCase): + def test_separate_answer_quotes(self): + test_answer = textwrap.dedent( + """ + It seems many people love dogs + Quote: A dog is a man's best friend + Quote: Air Bud was a movie about dogs and people loved it + """ + ).strip() + answer, quotes = separate_answer_quotes(test_answer) + self.assertEqual(answer, "It seems many people love dogs") + self.assertEqual(quotes[0], "A dog is a man's best friend") + self.assertEqual( + quotes[1], "Air Bud was a movie about dogs and people loved it" + ) + + # Lowercase should be allowed + test_answer = textwrap.dedent( + """ + It seems many people love dogs + quote: A dog is a man's best friend + Quote: Air Bud was a movie about dogs and people loved it + """ + ).strip() + answer, quotes = separate_answer_quotes(test_answer) + self.assertEqual(answer, "It seems many people love dogs") + self.assertEqual(quotes[0], "A dog is a man's best friend") + self.assertEqual( + quotes[1], "Air Bud was a movie about dogs and people loved it" + ) + + # No Answer + test_answer = textwrap.dedent( + """ + Quote: This one has no answer + """ + ).strip() + answer, quotes = separate_answer_quotes(test_answer) + self.assertIsNone(answer) + self.assertIsNone(quotes) + + # Multiline Quote + test_answer = textwrap.dedent( + """ + It seems many people love dogs + quote: A well known saying is: + A dog is a man's best friend + Quote: Air Bud was a movie about dogs and people loved it + """ + ).strip() + answer, quotes = separate_answer_quotes(test_answer) + self.assertEqual(answer, "It seems many people love dogs") + self.assertEqual( + quotes[0], "A well known saying is:\nA dog is a man's best friend" + ) + self.assertEqual( + quotes[1], "Air Bud was a movie about dogs and people loved it" + ) + + # Random patterns not picked up + test_answer = textwrap.dedent( + """ + It seems many people love quote: dogs + quote: Quote: A well known saying is: + A dog is a man's best friend + Quote: Answer: Air Bud was a movie about dogs and quote: people loved it + """ + ).strip() + answer, quotes = separate_answer_quotes(test_answer) + self.assertEqual(answer, "It seems many people love quote: dogs") + self.assertEqual( + quotes[0], "Quote: A well known saying is:\nA dog is a man's best friend" + ) + self.assertEqual( + quotes[1], + "Answer: Air Bud was a movie about dogs and quote: people loved it", + ) + + def test_fuzzy_match_quotes_to_docs(self): + chunk_0_text = textwrap.dedent( + """ + Here's a doc with some LINK embedded in the text + THIS SECTION IS A LINK + Some more text + """ + ).strip() + chunk_1_text = textwrap.dedent( + """ + Some completely different text here + ANOTHER LINK embedded in this text + ending in a DIFFERENT-LINK + """ + ).strip() + test_chunk_0 = InferenceChunk( + document_id="test doc 0", + source_type="testing", + chunk_id=0, + content=chunk_0_text, + source_links={ + 0: "doc 0 base", + 23: "first line link", + 49: "second line link", + }, + section_continuation=False, + ) + test_chunk_1 = InferenceChunk( + document_id="test doc 1", + source_type="testing", + chunk_id=0, + content=chunk_1_text, + source_links={0: "doc 1 base", 36: "2nd line link", 82: "last link"}, + section_continuation=False, + ) + + test_quotes = [ + "a doc with some", # Basic case + "a doc with some LINK", # Should take the start of quote, even if a link is in it + "a doc with some \nLINK", # Requires a newline deletion fuzzy match + "a doc with some link", # Capitalization insensitive + "embedded in this text", # Fuzzy match to first doc + "SECTION IS A LINK", # Match exact link + "some more text", # Match the end, after every link offset + "different taxt", # Substitution + "embedded in this texts", # Cannot fuzzy match to first doc, fuzzy match to second doc + "DIFFERENT-LINK", # Exact link match at the end + "Some complitali", # Too many edits, shouldn't match anything + ] + results = match_quotes_to_docs( + test_quotes, [test_chunk_0, test_chunk_1], fuzzy_search=True + ) + self.assertEqual( + results, + { + "a doc with some": {"document": "test doc 0", "link": "doc 0 base"}, + "a doc with some LINK": { + "document": "test doc 0", + "link": "doc 0 base", + }, + "a doc with some \nLINK": { + "document": "test doc 0", + "link": "doc 0 base", + }, + "a doc with some link": { + "document": "test doc 0", + "link": "doc 0 base", + }, + "embedded in this text": { + "document": "test doc 0", + "link": "first line link", + }, + "SECTION IS A LINK": { + "document": "test doc 0", + "link": "second line link", + }, + "some more text": { + "document": "test doc 0", + "link": "second line link", + }, + "different taxt": {"document": "test doc 1", "link": "doc 1 base"}, + "embedded in this texts": { + "document": "test doc 1", + "link": "2nd line link", + }, + "DIFFERENT-LINK": {"document": "test doc 1", "link": "last link"}, + }, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/web/.eslintrc.json b/web/.eslintrc.json new file mode 100644 index 0000000000..bffb357a71 --- /dev/null +++ b/web/.eslintrc.json @@ -0,0 +1,3 @@ +{ + "extends": "next/core-web-vitals" +} diff --git a/web/.gitignore b/web/.gitignore new file mode 100644 index 0000000000..c87c9b392c --- /dev/null +++ b/web/.gitignore @@ -0,0 +1,36 @@ +# See https://help.github.com/articles/ignoring-files/ for more about ignoring files. + +# dependencies +/node_modules +/.pnp +.pnp.js + +# testing +/coverage + +# next.js +/.next/ +/out/ + +# production +/build + +# misc +.DS_Store +*.pem + +# debug +npm-debug.log* +yarn-debug.log* +yarn-error.log* +.pnpm-debug.log* + +# local env files +.env*.local + +# vercel +.vercel + +# typescript +*.tsbuildinfo +next-env.d.ts diff --git a/web/.prettierignore b/web/.prettierignore new file mode 100644 index 0000000000..ba17c27d86 --- /dev/null +++ b/web/.prettierignore @@ -0,0 +1,6 @@ +**/.git +**/.svn +**/.hg +**/node_modules +**/.next +**/.vscode \ No newline at end of file diff --git a/web/README.md b/web/README.md new file mode 100644 index 0000000000..2845027e1e --- /dev/null +++ b/web/README.md @@ -0,0 +1,32 @@ +This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app). + +## Getting Started + +First, run the development server: + +```bash +npm run dev +# or +yarn dev +# or +pnpm dev +``` + +Open [http://localhost:3000](http://localhost:3000) with your browser to see the result. + +This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font. + +## Learn More + +To learn more about Next.js, take a look at the following resources: + +- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API. +- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial. + +You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome! + +## Deploy on Vercel + +The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js. + +Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details. diff --git a/web/next.config.js b/web/next.config.js new file mode 100644 index 0000000000..4436b22b5b --- /dev/null +++ b/web/next.config.js @@ -0,0 +1,8 @@ +/** @type {import('next').NextConfig} */ +const nextConfig = { + experimental: { + appDir: true, + }, +}; + +module.exports = nextConfig; diff --git a/web/package-lock.json b/web/package-lock.json new file mode 100644 index 0000000000..8352d6b96d --- /dev/null +++ b/web/package-lock.json @@ -0,0 +1,4107 @@ +{ + "name": "qa", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "qa", + "version": "0.1.0", + "dependencies": { + "@phosphor-icons/react": "^2.0.8", + "@types/node": "18.15.11", + "@types/react": "18.0.32", + "@types/react-dom": "18.0.11", + "autoprefixer": "^10.4.14", + "eslint": "8.37.0", + "eslint-config-next": "13.2.4", + "formik": "^2.2.9", + "next": "13.2.4", + "postcss": "^8.4.23", + "react": "18.2.0", + "react-dom": "18.2.0", + "tailwindcss": "^3.3.1", + "typescript": "5.0.3", + "yup": "^1.1.1" + } + }, + "node_modules/@babel/runtime": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.21.0.tgz", + "integrity": "sha512-xwII0//EObnq89Ji5AKYQaRYiW/nZ3llSv29d49IuxPhKbtJoLP+9QUUZ4nVragQVtaVGeZrpB+ZtG/Pdy/POw==", + "dependencies": { + "regenerator-runtime": "^0.13.11" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", + "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==", + "dependencies": { + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.5.0.tgz", + "integrity": "sha512-vITaYzIcNmjn5tF5uxcZ/ft7/RXGrMUIS9HalWckEOF6ESiwXKoMzAQf2UW0aVd6rnOeExTJVd5hmWXucBKGXQ==", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.0.2.tgz", + "integrity": "sha512-3W4f5tDUra+pA+FzgugqL2pRimUTDJWKr7BINqOpkZrC0uYI0NIc0/JFgBROCU07HR6GieA5m3/rsPIhDmCXTQ==", + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.5.1", + "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/js": { + "version": "8.37.0", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.37.0.tgz", + "integrity": "sha512-x5vzdtOOGgFVDCUs81QRB2+liax8rFg3+7hqM+QhBG0/G3F1ZsoYl97UrqgHgQ9KKT7G6c4V+aTUCgu/n22v1A==", + "engines": { + "node": "^12.22.0 || ^14.17.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/@jridgewell/gen-mapping": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz", + "integrity": "sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==", + "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/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/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.18", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.18.tgz", + "integrity": "sha512-w+niJYzMHdd7USdiH2U6869nqhD2nbfZXND5Yp93qIbEmnDNk7PD48o+YchRVpzMU7M6jVCbenTR7PA1FLQ9pA==", + "dependencies": { + "@jridgewell/resolve-uri": "3.1.0", + "@jridgewell/sourcemap-codec": "1.4.14" + } + }, + "node_modules/@jridgewell/trace-mapping/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/@next/env": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/env/-/env-13.2.4.tgz", + "integrity": "sha512-+Mq3TtpkeeKFZanPturjcXt+KHfKYnLlX6jMLyCrmpq6OOs4i1GqBOAauSkii9QeKCMTYzGppar21JU57b/GEA==" + }, + "node_modules/@next/eslint-plugin-next": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/eslint-plugin-next/-/eslint-plugin-next-13.2.4.tgz", + "integrity": "sha512-ck1lI+7r1mMJpqLNa3LJ5pxCfOB1lfJncKmRJeJxcJqcngaFwylreLP7da6Rrjr6u2gVRTfmnkSkjc80IiQCwQ==", + "dependencies": { + "glob": "7.1.7" + } + }, + "node_modules/@next/swc-android-arm-eabi": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-android-arm-eabi/-/swc-android-arm-eabi-13.2.4.tgz", + "integrity": "sha512-DWlalTSkLjDU11MY11jg17O1gGQzpRccM9Oes2yTqj2DpHndajrXHGxj9HGtJ+idq2k7ImUdJVWS2h2l/EDJOw==", + "cpu": [ + "arm" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-android-arm64": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-android-arm64/-/swc-android-arm64-13.2.4.tgz", + "integrity": "sha512-sRavmUImUCf332Gy+PjIfLkMhiRX1Ez4SI+3vFDRs1N5eXp+uNzjFUK/oLMMOzk6KFSkbiK/3Wt8+dHQR/flNg==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-darwin-arm64": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-13.2.4.tgz", + "integrity": "sha512-S6vBl+OrInP47TM3LlYx65betocKUUlTZDDKzTiRDbsRESeyIkBtZ6Qi5uT2zQs4imqllJznVjFd1bXLx3Aa6A==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-darwin-x64": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-13.2.4.tgz", + "integrity": "sha512-a6LBuoYGcFOPGd4o8TPo7wmv5FnMr+Prz+vYHopEDuhDoMSHOnC+v+Ab4D7F0NMZkvQjEJQdJS3rqgFhlZmKlw==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-freebsd-x64": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-freebsd-x64/-/swc-freebsd-x64-13.2.4.tgz", + "integrity": "sha512-kkbzKVZGPaXRBPisoAQkh3xh22r+TD+5HwoC5bOkALraJ0dsOQgSMAvzMXKsN3tMzJUPS0tjtRf1cTzrQ0I5vQ==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-arm-gnueabihf": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-linux-arm-gnueabihf/-/swc-linux-arm-gnueabihf-13.2.4.tgz", + "integrity": "sha512-7qA1++UY0fjprqtjBZaOA6cas/7GekpjVsZn/0uHvquuITFCdKGFCsKNBx3S0Rpxmx6WYo0GcmhNRM9ru08BGg==", + "cpu": [ + "arm" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-arm64-gnu": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-13.2.4.tgz", + "integrity": "sha512-xzYZdAeq883MwXgcwc72hqo/F/dwUxCukpDOkx/j1HTq/J0wJthMGjinN9wH5bPR98Mfeh1MZJ91WWPnZOedOg==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-arm64-musl": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-13.2.4.tgz", + "integrity": "sha512-8rXr3WfmqSiYkb71qzuDP6I6R2T2tpkmf83elDN8z783N9nvTJf2E7eLx86wu2OJCi4T05nuxCsh4IOU3LQ5xw==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-x64-gnu": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-13.2.4.tgz", + "integrity": "sha512-Ngxh51zGSlYJ4EfpKG4LI6WfquulNdtmHg1yuOYlaAr33KyPJp4HeN/tivBnAHcZkoNy0hh/SbwDyCnz5PFJQQ==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-linux-x64-musl": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-13.2.4.tgz", + "integrity": "sha512-gOvwIYoSxd+j14LOcvJr+ekd9fwYT1RyMAHOp7znA10+l40wkFiMONPLWiZuHxfRk+Dy7YdNdDh3ImumvL6VwA==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-win32-arm64-msvc": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-13.2.4.tgz", + "integrity": "sha512-q3NJzcfClgBm4HvdcnoEncmztxrA5GXqKeiZ/hADvC56pwNALt3ngDC6t6qr1YW9V/EPDxCYeaX4zYxHciW4Dw==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-win32-ia32-msvc": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-win32-ia32-msvc/-/swc-win32-ia32-msvc-13.2.4.tgz", + "integrity": "sha512-/eZ5ncmHUYtD2fc6EUmAIZlAJnVT2YmxDsKs1Ourx0ttTtvtma/WKlMV5NoUsyOez0f9ExLyOpeCoz5aj+MPXw==", + "cpu": [ + "ia32" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@next/swc-win32-x64-msvc": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-13.2.4.tgz", + "integrity": "sha512-0MffFmyv7tBLlji01qc0IaPP/LVExzvj7/R5x1Jph1bTAIj4Vu81yFQWHHQAP6r4ff9Ukj1mBK6MDNVXm7Tcvw==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "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/@phosphor-icons/react": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/@phosphor-icons/react/-/react-2.0.8.tgz", + "integrity": "sha512-VWACI+MkRGpol4htOcVtWKaDCosrcuCg8toJfPS0osgVjxM8i/KoSZSPxQvG5XYPCI8iyJoHKRpSfzOISAXFyg==", + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "react": ">= 16.8", + "react-dom": ">= 16.8" + } + }, + "node_modules/@pkgr/utils": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/@pkgr/utils/-/utils-2.3.1.tgz", + "integrity": "sha512-wfzX8kc1PMyUILA+1Z/EqoE4UCXGy0iRGMhPwdfae1+f0OXlLqCk+By+aMzgJBzR9AzS4CDizioG6Ss1gvAFJw==", + "dependencies": { + "cross-spawn": "^7.0.3", + "is-glob": "^4.0.3", + "open": "^8.4.0", + "picocolors": "^1.0.0", + "tiny-glob": "^0.2.9", + "tslib": "^2.4.0" + }, + "engines": { + "node": "^12.20.0 || ^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/unts" + } + }, + "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/@swc/helpers": { + "version": "0.4.14", + "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.4.14.tgz", + "integrity": "sha512-4C7nX/dvpzB7za4Ql9K81xK3HPxCpHMgwTZVyf+9JQ6VUbn9jjZVN7/Nkdz/Ugzs2CSjqnL/UPXroiVBVHUWUw==", + "dependencies": { + "tslib": "^2.4.0" + } + }, + "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/node": { + "version": "18.15.11", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.11.tgz", + "integrity": "sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q==" + }, + "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/react": { + "version": "18.0.32", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.0.32.tgz", + "integrity": "sha512-gYGXdtPQ9Cj0w2Fwqg5/ak6BcK3Z15YgjSqtyDizWUfx7mQ8drs0NBUzRRsAdoFVTO8kJ8L2TL8Skm7OFPnLUw==", + "dependencies": { + "@types/prop-types": "*", + "@types/scheduler": "*", + "csstype": "^3.0.2" + } + }, + "node_modules/@types/react-dom": { + "version": "18.0.11", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.0.11.tgz", + "integrity": "sha512-O38bPbI2CWtgw/OoQoY+BRelw7uysmXbWvw3nLWO21H1HSh+GOlqPuXshJfjmpNlKiiSDG9cc1JZAaMmVdcTlw==", + "dependencies": { + "@types/react": "*" + } + }, + "node_modules/@types/scheduler": { + "version": "0.16.3", + "resolved": "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.16.3.tgz", + "integrity": "sha512-5cJ8CB4yAx7BH1oMvdU0Jh9lrEXyPkar6F9G/ERswkCuvP4KQZfZkSjcMbAICCpQTN4OuZn8tz0HiKv9TGZgrQ==" + }, + "node_modules/@typescript-eslint/parser": { + "version": "5.57.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.57.0.tgz", + "integrity": "sha512-orrduvpWYkgLCyAdNtR1QIWovcNZlEm6yL8nwH/eTxWLd8gsP+25pdLHYzL2QdkqrieaDwLpytHqycncv0woUQ==", + "dependencies": { + "@typescript-eslint/scope-manager": "5.57.0", + "@typescript-eslint/types": "5.57.0", + "@typescript-eslint/typescript-estree": "5.57.0", + "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.57.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.57.0.tgz", + "integrity": "sha512-NANBNOQvllPlizl9LatX8+MHi7bx7WGIWYjPHDmQe5Si/0YEYfxSljJpoTyTWFTgRy3X8gLYSE4xQ2U+aCozSw==", + "dependencies": { + "@typescript-eslint/types": "5.57.0", + "@typescript-eslint/visitor-keys": "5.57.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/types": { + "version": "5.57.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.57.0.tgz", + "integrity": "sha512-mxsod+aZRSyLT+jiqHw1KK6xrANm19/+VFALVFP5qa/aiJnlP38qpyaTd0fEKhWvQk6YeNZ5LGwI1pDpBRBhtQ==", + "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.57.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.57.0.tgz", + "integrity": "sha512-LTzQ23TV82KpO8HPnWuxM2V7ieXW8O142I7hQTxWIHDcCEIjtkat6H96PFkYBQqGFLW/G/eVVOB9Z8rcvdY/Vw==", + "dependencies": { + "@typescript-eslint/types": "5.57.0", + "@typescript-eslint/visitor-keys": "5.57.0", + "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/visitor-keys": { + "version": "5.57.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.57.0.tgz", + "integrity": "sha512-ery2g3k0hv5BLiKpPuwYt9KBkAp2ugT6VvyShXdLOkax895EC55sP0Tx5L0fZaQueiK3fBLvHVvEl3jFS5ia+g==", + "dependencies": { + "@typescript-eslint/types": "5.57.0", + "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/acorn": { + "version": "8.8.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz", + "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "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/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/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": "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/any-promise": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", + "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==" + }, + "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": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + }, + "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/array-buffer-byte-length": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz", + "integrity": "sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==", + "dependencies": { + "call-bind": "^1.0.2", + "is-array-buffer": "^3.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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-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.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/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/autoprefixer": { + "version": "10.4.14", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.14.tgz", + "integrity": "sha512-FQzyfOsTlwVzjHxKEqRIAdJx9niO6VCBCoEwax/VLSoQF29ggECcPuBqUMZ+u8jCZOPSy8b8/8KnuFbp0SaFZQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/autoprefixer" + } + ], + "dependencies": { + "browserslist": "^4.21.5", + "caniuse-lite": "^1.0.30001464", + "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.3", + "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.6.3.tgz", + "integrity": "sha512-/BQzOX780JhsxDnPpH4ZiyrJAzcd8AfzFPkv+89veFSr1rcMjuq2JDCwypKaPeB6ljHp9KjXhPpjgCvQlWYuqg==", + "engines": { + "node": ">=4" + } + }, + "node_modules/axobject-query": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-3.1.1.tgz", + "integrity": "sha512-goKlv8DZrK9hUh975fnHzhNIO4jUnFCfv/dszV5VwUGDFjI6vQ2VwoyjYjYNEbBE8AH87TduWP5uyDR1D+Iteg==", + "dependencies": { + "deep-equal": "^2.0.5" + } + }, + "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/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/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/browserslist": { + "version": "4.21.5", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.5.tgz", + "integrity": "sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + } + ], + "dependencies": { + "caniuse-lite": "^1.0.30001449", + "electron-to-chromium": "^1.4.284", + "node-releases": "^2.0.8", + "update-browserslist-db": "^1.0.10" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "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/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-lite": { + "version": "1.0.30001473", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001473.tgz", + "integrity": "sha512-ewDad7+D2vlyy+E4UJuVfiBsU69IL+8oVmTuZnH5Q6CIUbxNfI50uVpRHbUPDD6SUaN2o0Lh4DhTrvLG/Tn1yg==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ] + }, + "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/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/client-only": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/client-only/-/client-only-0.0.1.tgz", + "integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==" + }, + "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/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/commander": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", + "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==", + "engines": { + "node": ">= 6" + } + }, + "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/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/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/csstype": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.2.tgz", + "integrity": "sha512-I7K1Uu0MBPzaFKg4nI5Q7Vs2t+3gWWW648spaF+Rg7pI9ds18Ugn+lvg4SHczUdKlHI5LWBXyqfS8+DufyBsgQ==" + }, + "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/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/deep-equal": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-2.2.0.tgz", + "integrity": "sha512-RdpzE0Hv4lhowpIUKKMJfeH6C1pXdtT1/it80ubgWqwI3qpuxUBpC1S4hnHg+zjnuOoDkzUtUCEEkG+XG5l3Mw==", + "dependencies": { + "call-bind": "^1.0.2", + "es-get-iterator": "^1.1.2", + "get-intrinsic": "^1.1.3", + "is-arguments": "^1.1.1", + "is-array-buffer": "^3.0.1", + "is-date-object": "^1.0.5", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.2", + "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.9" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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": "2.2.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-2.2.1.tgz", + "integrity": "sha512-R9hc1Xa/NOBi9WRVUWg19rl1UB7Tt4kuPd+thNJgFZoxXsTz7ncaPaeIm+40oSGuP33DfMb4sZt1QIGiJzC4EA==", + "engines": { + "node": ">=0.10.0" + } + }, + "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.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "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/didyoumean": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz", + "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==" + }, + "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/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/electron-to-chromium": { + "version": "1.4.368", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.368.tgz", + "integrity": "sha512-e2aeCAixCj9M7nJxdB/wDjO6mbYX+lJJxSJCXDzlr5YPGYVofuJwGN9nKg2o6wWInjX6XmxRinn3AeJMK81ltw==" + }, + "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/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/es-abstract": { + "version": "1.21.2", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.2.tgz", + "integrity": "sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==", + "dependencies": { + "array-buffer-byte-length": "^1.0.0", + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "es-set-tostringtag": "^2.0.1", + "es-to-primitive": "^1.2.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.2.0", + "get-symbol-description": "^1.0.0", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.5", + "is-array-buffer": "^3.0.2", + "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-typed-array": "^1.1.10", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.3", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trim": "^1.2.7", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.9" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-get-iterator": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/es-get-iterator/-/es-get-iterator-1.1.3.tgz", + "integrity": "sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "has-symbols": "^1.0.3", + "is-arguments": "^1.1.1", + "is-map": "^2.0.2", + "is-set": "^2.0.2", + "is-string": "^1.0.7", + "isarray": "^2.0.5", + "stop-iteration-iterator": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", + "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "dependencies": { + "get-intrinsic": "^1.1.3", + "has": "^1.0.3", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "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-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": { + "version": "8.37.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.37.0.tgz", + "integrity": "sha512-NU3Ps9nI05GUoVMxcZx1J8CNR6xOvUT4jAUMH5+z8lpp3aEdPVCImKw6PWG4PY+Vfkpr+jvMpxs/qoE7wq0sPw==", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.4.0", + "@eslint/eslintrc": "^2.0.2", + "@eslint/js": "8.37.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-visitor-keys": "^3.4.0", + "espree": "^9.5.1", + "esquery": "^1.4.2", + "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", + "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-next": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/eslint-config-next/-/eslint-config-next-13.2.4.tgz", + "integrity": "sha512-lunIBhsoeqw6/Lfkd6zPt25w1bn0znLA/JCL+au1HoEpSb4/PpsOYsYtgV/q+YPsoKIOzFyU5xnb04iZnXjUvg==", + "dependencies": { + "@next/eslint-plugin-next": "13.2.4", + "@rushstack/eslint-patch": "^1.1.3", + "@typescript-eslint/parser": "^5.42.0", + "eslint-import-resolver-node": "^0.3.6", + "eslint-import-resolver-typescript": "^3.5.2", + "eslint-plugin-import": "^2.26.0", + "eslint-plugin-jsx-a11y": "^6.5.1", + "eslint-plugin-react": "^7.31.7", + "eslint-plugin-react-hooks": "^4.5.0" + }, + "peerDependencies": { + "eslint": "^7.23.0 || ^8.0.0", + "typescript": ">=3.3.1" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/eslint-import-resolver-node": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.7.tgz", + "integrity": "sha512-gozW2blMLJCeFpBwugLTGyvVjNoeo1knonXAcatC6bjPBZitotxdWf7Gimr25N4c0AAOo4eOUfaG82IJPDpqCA==", + "dependencies": { + "debug": "^3.2.7", + "is-core-module": "^2.11.0", + "resolve": "^1.22.1" + } + }, + "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-import-resolver-typescript": { + "version": "3.5.4", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-3.5.4.tgz", + "integrity": "sha512-9xUpnedEmSfG57sN1UvWPiEhfJ8bPt0Wg2XysA7Mlc79iFGhmJtRUg9LxtkK81FhMUui0YuR2E8iUsVhePkh4A==", + "dependencies": { + "debug": "^4.3.4", + "enhanced-resolve": "^5.12.0", + "get-tsconfig": "^4.5.0", + "globby": "^13.1.3", + "is-core-module": "^2.11.0", + "is-glob": "^4.0.3", + "synckit": "^0.8.5" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/unts/projects/eslint-import-resolver-ts" + }, + "peerDependencies": { + "eslint": "*", + "eslint-plugin-import": "*" + } + }, + "node_modules/eslint-import-resolver-typescript/node_modules/globby": { + "version": "13.1.3", + "resolved": "https://registry.npmjs.org/globby/-/globby-13.1.3.tgz", + "integrity": "sha512-8krCNHXvlCgHDpegPzleMq07yMYTO2sXKASmZmquEYWEmCx6J5UTRbp5RwMJkTJGtcQ44YpiUYUiN0b9mzy8Bw==", + "dependencies": { + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.11", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint-import-resolver-typescript/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/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-import": { + "version": "2.27.5", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.27.5.tgz", + "integrity": "sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==", + "dependencies": { + "array-includes": "^3.1.6", + "array.prototype.flat": "^1.3.1", + "array.prototype.flatmap": "^1.3.1", + "debug": "^3.2.7", + "doctrine": "^2.1.0", + "eslint-import-resolver-node": "^0.3.7", + "eslint-module-utils": "^2.7.4", + "has": "^1.0.3", + "is-core-module": "^2.11.0", + "is-glob": "^4.0.3", + "minimatch": "^3.1.2", + "object.values": "^1.1.6", + "resolve": "^1.22.1", + "semver": "^6.3.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": "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-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/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-jsx-a11y": { + "version": "6.7.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.7.1.tgz", + "integrity": "sha512-63Bog4iIethyo8smBklORknVjB0T2dwB8Mr/hIC+fBS0uyHdYYpzM/Ed+YC8VxTjlXHEWFOdmgwcDn1U2L9VCA==", + "dependencies": { + "@babel/runtime": "^7.20.7", + "aria-query": "^5.1.3", + "array-includes": "^3.1.6", + "array.prototype.flatmap": "^1.3.1", + "ast-types-flow": "^0.0.7", + "axe-core": "^4.6.2", + "axobject-query": "^3.1.1", + "damerau-levenshtein": "^1.0.8", + "emoji-regex": "^9.2.2", + "has": "^1.0.3", + "jsx-ast-utils": "^3.3.3", + "language-tags": "=1.0.5", + "minimatch": "^3.1.2", + "object.entries": "^1.1.6", + "object.fromentries": "^2.0.6", + "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.32.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.32.2.tgz", + "integrity": "sha512-t2fBMa+XzonrrNkyVirzKlvn5RXzzPwRHtMvLAtVZrt8oxgnTQaYbU6SXTOO1mwQgp1y5+toMSKInnzGr0Knqg==", + "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.4", + "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-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-visitor-keys": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.0.tgz", + "integrity": "sha512-HPpKPUBQcAsZOsHAFwTtIKcYlCje62XB7SEAcxjtmW6TD1WVpkS6i6/hOVtTZIl4zGj/mBqpFVGvaDneik+VoQ==", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/espree": { + "version": "9.5.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.5.1.tgz", + "integrity": "sha512-5yxtHSZXRSW5pvv3hAlXM5+/Oswi1AUFqBmbibKb5s6bp3rGIDkyXU6xCoyuuLhijr4SFwPrXRoZjz0AZDN9tg==", + "dependencies": { + "acorn": "^8.8.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.4.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz", + "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==", + "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/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/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.15.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", + "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "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/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/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/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/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/formik": { + "version": "2.2.9", + "resolved": "https://registry.npmjs.org/formik/-/formik-2.2.9.tgz", + "integrity": "sha512-LQLcISMmf1r5at4/gyJigGn0gOwFbeEAlji+N9InZF6LIMXnFNkO42sCI8Jt84YZggpD4cPWObAZaxpEFtSzNA==", + "funding": [ + { + "type": "individual", + "url": "https://opencollective.com/formik" + } + ], + "dependencies": { + "deepmerge": "^2.1.1", + "hoist-non-react-statics": "^3.3.0", + "lodash": "^4.17.21", + "lodash-es": "^4.17.21", + "react-fast-compare": "^2.0.1", + "tiny-warning": "^1.0.2", + "tslib": "^1.10.0" + }, + "peerDependencies": { + "react": ">=16.8.0" + } + }, + "node_modules/formik/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/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/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/get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "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-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/get-tsconfig": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.5.0.tgz", + "integrity": "sha512-MjhiaIWCJ1sAU4pIQ5i5OfOuHHxVo1oYeNsWTON7jxYkod8pHocXeh+SSbmu5OZZZK73B6cbJ2XADzXehLyovQ==", + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/glob": { + "version": "7.1.7", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz", + "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "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/globals": { + "version": "13.20.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.20.0.tgz", + "integrity": "sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ==", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "dependencies": { + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/globalyzer": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/globalyzer/-/globalyzer-0.1.0.tgz", + "integrity": "sha512-40oNTM9UfG6aBmuKxk/giHn5nQ8RVz/SS4Ir6zgzOv9/qC3kKZ9v4etGTcJbEl/NyVQH7FGU7d+X1egr57Md2Q==" + }, + "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/globrex": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/globrex/-/globrex-0.1.2.tgz", + "integrity": "sha512-uHJgbwAMwNFf5mLst7IWLNg14x1CkeqglJb/K3doi4dw6q2IvAAmM/Y81kevy83wP+Sst+nutFTYOGg3d1lsxg==" + }, + "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.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==" + }, + "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/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": "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/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-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "engines": { + "node": ">= 0.4" + }, + "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/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/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/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/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/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/internal-slot": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", + "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "dependencies": { + "get-intrinsic": "^1.2.0", + "has": "^1.0.3", + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "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-array-buffer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", + "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "is-typed-array": "^1.1.10" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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-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-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-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-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-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-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-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": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==" + }, + "node_modules/jiti": { + "version": "1.18.2", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.18.2.tgz", + "integrity": "sha512-QAdOptna2NYiSSpv0O/BwoHBSmz4YhpzJHyi+fnMRTXFjp7B8i/YG5Z8IfusxB1ufjcD2Sre1F3R+nX3fvy7gg==", + "bin": { + "jiti": "bin/jiti.js" + } + }, + "node_modules/js-sdsl": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.4.0.tgz", + "integrity": "sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg==", + "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": "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/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": "1.0.2", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", + "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", + "dependencies": { + "minimist": "^1.2.0" + }, + "bin": { + "json5": "lib/cli.js" + } + }, + "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/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.5", + "resolved": "https://registry.npmjs.org/language-tags/-/language-tags-1.0.5.tgz", + "integrity": "sha512-qJhlO9cGXi6hBGKoxEG/sKZDAHD5Hnu9Hs4WbOY3pCWXDhw0N8x1NenNzm2EnNLkLkk7J2SdxAkDSbb6ftT+UQ==", + "dependencies": { + "language-subtag-registry": "~0.3.2" + } + }, + "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/lilconfig": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz", + "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==", + "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/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-es": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.21.tgz", + "integrity": "sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==" + }, + "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/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/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/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/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/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.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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/mz": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz", + "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", + "dependencies": { + "any-promise": "^1.0.0", + "object-assign": "^4.0.1", + "thenify-all": "^1.0.0" + } + }, + "node_modules/nanoid": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz", + "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "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/next": { + "version": "13.2.4", + "resolved": "https://registry.npmjs.org/next/-/next-13.2.4.tgz", + "integrity": "sha512-g1I30317cThkEpvzfXujf0O4wtaQHtDCLhlivwlTJ885Ld+eOgcz7r3TGQzeU+cSRoNHtD8tsJgzxVdYojFssw==", + "dependencies": { + "@next/env": "13.2.4", + "@swc/helpers": "0.4.14", + "caniuse-lite": "^1.0.30001406", + "postcss": "8.4.14", + "styled-jsx": "5.1.1" + }, + "bin": { + "next": "dist/bin/next" + }, + "engines": { + "node": ">=14.6.0" + }, + "optionalDependencies": { + "@next/swc-android-arm-eabi": "13.2.4", + "@next/swc-android-arm64": "13.2.4", + "@next/swc-darwin-arm64": "13.2.4", + "@next/swc-darwin-x64": "13.2.4", + "@next/swc-freebsd-x64": "13.2.4", + "@next/swc-linux-arm-gnueabihf": "13.2.4", + "@next/swc-linux-arm64-gnu": "13.2.4", + "@next/swc-linux-arm64-musl": "13.2.4", + "@next/swc-linux-x64-gnu": "13.2.4", + "@next/swc-linux-x64-musl": "13.2.4", + "@next/swc-win32-arm64-msvc": "13.2.4", + "@next/swc-win32-ia32-msvc": "13.2.4", + "@next/swc-win32-x64-msvc": "13.2.4" + }, + "peerDependencies": { + "@opentelemetry/api": "^1.4.0", + "fibers": ">= 3.1.0", + "node-sass": "^6.0.0 || ^7.0.0", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "sass": "^1.3.0" + }, + "peerDependenciesMeta": { + "@opentelemetry/api": { + "optional": true + }, + "fibers": { + "optional": true + }, + "node-sass": { + "optional": true + }, + "sass": { + "optional": true + } + } + }, + "node_modules/next/node_modules/postcss": { + "version": "8.4.14", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.14.tgz", + "integrity": "sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==", + "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/node-releases": { + "version": "2.0.10", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.10.tgz", + "integrity": "sha512-5GFldHPXVG/YZmFzJvKK2zDSzPKhEp0+ZR5SVaoSag9fsL5YgHbUHDfnG5494ISANDcK4KwPXAx2xqVEydmd7w==" + }, + "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/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.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", + "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", + "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.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.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/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/open": { + "version": "8.4.2", + "resolved": "https://registry.npmjs.org/open/-/open-8.4.2.tgz", + "integrity": "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==", + "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/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/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/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-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-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/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/postcss": { + "version": "8.4.23", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.23.tgz", + "integrity": "sha512-bQ3qMcpF6A/YjR55xtoTr0jGOlnPOKAIMdOWiv0EIT6HVPEaJiJB4NLljSbiHoC2RX7DN5Uvjtpbg1NPdwv1oA==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "nanoid": "^3.3.6", + "picocolors": "^1.0.0", + "source-map-js": "^1.0.2" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "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-js": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.0.1.tgz", + "integrity": "sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==", + "dependencies": { + "camelcase-css": "^2.0.1" + }, + "engines": { + "node": "^12 || ^14 || >= 16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + "peerDependencies": { + "postcss": "^8.4.21" + } + }, + "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-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-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/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/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/property-expr": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/property-expr/-/property-expr-2.0.5.tgz", + "integrity": "sha512-IJUkICM5dP5znhCckHSv30Q4b5/JA5enCtkRHYaOVOAocnH/1BQEYTC5NMfT3AVl/iXKdr3aqQbQn9DxyWknwA==" + }, + "node_modules/punycode": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz", + "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==", + "engines": { + "node": ">=6" + } + }, + "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/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-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-fast-compare": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/react-fast-compare/-/react-fast-compare-2.0.4.tgz", + "integrity": "sha512-suNP+J1VU1MWFKcyt7RtjiSWUjvidmQSlqu+eHslq+342xCbGTYmC0mEhPCOHxlW0CywylOC1u2DFAT+bv4dBw==" + }, + "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/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/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/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/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/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-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/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/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-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/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/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/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/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/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/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/stop-iteration-iterator": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.0.0.tgz", + "integrity": "sha512-iCGQj+0l0HOdZ2AEeBADlsRC+vsnDsZsbdSiH1yNSjcfKM7fdpCMfqAL/dwF5BLiw/XhRft/Wax6zQbhq2BcjQ==", + "dependencies": { + "internal-slot": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "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.trim": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", + "integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==", + "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/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/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": "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/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/styled-jsx": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/styled-jsx/-/styled-jsx-5.1.1.tgz", + "integrity": "sha512-pW7uC1l4mBZ8ugbiZrcIsiIvVx1UmTfw7UkC3Um2tmfUq9Bhk8IiyEIPl6F8agHgjzku6j0xQEZbfA5uSgSaCw==", + "dependencies": { + "client-only": "0.0.1" + }, + "engines": { + "node": ">= 12.0.0" + }, + "peerDependencies": { + "react": ">= 16.8.0 || 17.x.x || ^18.0.0-0" + }, + "peerDependenciesMeta": { + "@babel/core": { + "optional": true + }, + "babel-plugin-macros": { + "optional": true + } + } + }, + "node_modules/sucrase": { + "version": "3.32.0", + "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.32.0.tgz", + "integrity": "sha512-ydQOU34rpSyj2TGyz4D2p8rbktIOZ8QY9s+DGLvFU1i5pWJE8vkpruCjGCMHsdXwnD7JDcS+noSwM/a7zyNFDQ==", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.2", + "commander": "^4.0.0", + "glob": "7.1.6", + "lines-and-columns": "^1.1.6", + "mz": "^2.7.0", + "pirates": "^4.0.1", + "ts-interface-checker": "^0.1.9" + }, + "bin": { + "sucrase": "bin/sucrase", + "sucrase-node": "bin/sucrase-node" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/sucrase/node_modules/glob": { + "version": "7.1.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", + "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "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/synckit": { + "version": "0.8.5", + "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.8.5.tgz", + "integrity": "sha512-L1dapNV6vu2s/4Sputv8xGsCdAVlb5nRDMFU/E27D44l5U6cw1g0dGd45uLc+OXjNMmF4ntiMdCimzcjFKQI8Q==", + "dependencies": { + "@pkgr/utils": "^2.3.1", + "tslib": "^2.5.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/unts" + } + }, + "node_modules/tailwindcss": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.3.1.tgz", + "integrity": "sha512-Vkiouc41d4CEq0ujXl6oiGFQ7bA3WEhUZdTgXAhtKxSy49OmKs8rEfQmupsfF0IGW8fv2iQkp1EVUuapCFrZ9g==", + "dependencies": { + "arg": "^5.0.2", + "chokidar": "^3.5.3", + "color-name": "^1.1.4", + "didyoumean": "^1.2.2", + "dlv": "^1.1.3", + "fast-glob": "^3.2.12", + "glob-parent": "^6.0.2", + "is-glob": "^4.0.3", + "jiti": "^1.17.2", + "lilconfig": "^2.0.6", + "micromatch": "^4.0.5", + "normalize-path": "^3.0.0", + "object-hash": "^3.0.0", + "picocolors": "^1.0.0", + "postcss": "^8.0.9", + "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.11", + "postcss-value-parser": "^4.2.0", + "quick-lru": "^5.1.1", + "resolve": "^1.22.1", + "sucrase": "^3.29.0" + }, + "bin": { + "tailwind": "lib/cli.js", + "tailwindcss": "lib/cli.js" + }, + "engines": { + "node": ">=12.13.0" + }, + "peerDependencies": { + "postcss": "^8.0.9" + } + }, + "node_modules/tailwindcss/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/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/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/thenify": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz", + "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==", + "dependencies": { + "any-promise": "^1.0.0" + } + }, + "node_modules/thenify-all": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz", + "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==", + "dependencies": { + "thenify": ">= 3.1.0 < 4" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/tiny-case": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tiny-case/-/tiny-case-1.0.3.tgz", + "integrity": "sha512-Eet/eeMhkO6TX8mnUteS9zgPbUMQa4I6Kkp5ORiBD5476/m+PIRiumP5tmh5ioJpH7k51Kehawy2UDfsnxxY8Q==" + }, + "node_modules/tiny-glob": { + "version": "0.2.9", + "resolved": "https://registry.npmjs.org/tiny-glob/-/tiny-glob-0.2.9.tgz", + "integrity": "sha512-g/55ssRPUjShh+xkfx9UPDXqhckHEsHr4Vd9zX55oSdGZc/MD0m3sferOkwWtp98bv+kcVfEHtRJgBVJzelrzg==", + "dependencies": { + "globalyzer": "0.1.0", + "globrex": "^0.1.2" + } + }, + "node_modules/tiny-warning": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tiny-warning/-/tiny-warning-1.0.3.tgz", + "integrity": "sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==" + }, + "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/toposort": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/toposort/-/toposort-2.0.2.tgz", + "integrity": "sha512-0a5EOkAUp8D4moMi2W8ZF8jcga7BgZd91O/yabJCFY8az+XSzeGyTKs0Aoo897iV1Nj6guFq8orWDS96z91oGg==" + }, + "node_modules/ts-interface-checker": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz", + "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==" + }, + "node_modules/tsconfig-paths": { + "version": "3.14.2", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.2.tgz", + "integrity": "sha512-o/9iXgCYc5L/JxCHPe3Hvh8Q/2xm5Z+p18PESBU6Ff33695QnCHBEjcytY2q19ua7Mbl/DavtBOLq+oG0RCL+g==", + "dependencies": { + "@types/json5": "^0.0.29", + "json5": "^1.0.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + } + }, + "node_modules/tslib": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.5.0.tgz", + "integrity": "sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg==" + }, + "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-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/typed-array-length": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", + "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "dependencies": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "is-typed-array": "^1.1.9" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typescript": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.3.tgz", + "integrity": "sha512-xv8mOEDnigb/tN9PSMTwSEqAnUvkoXMQlicOb0IUVDBSQCgBSaAAROUZYy2IcUy5qU6XajK5jjjO7TMWqBTKZA==", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=12.20" + } + }, + "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/update-browserslist-db": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.11.tgz", + "integrity": "sha512-dCwEFf0/oT85M1fHBg4F0jtLwJrutGoHSQXCh7u4o2t1drG+c0a9Flnqww6XUKSfQMPpJBRjU8d4RXB09qtvaA==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + }, + "bin": { + "update-browserslist-db": "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/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/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/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/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "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/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/yup": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/yup/-/yup-1.1.1.tgz", + "integrity": "sha512-KfCGHdAErqFZWA5tZf7upSUnGKuTOnsI3hUsLr7fgVtx+DK04NPV01A68/FslI4t3s/ZWpvXJmgXhd7q6ICnag==", + "dependencies": { + "property-expr": "^2.0.5", + "tiny-case": "^1.0.3", + "toposort": "^2.0.2", + "type-fest": "^2.19.0" + } + }, + "node_modules/yup/node_modules/type-fest": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz", + "integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==", + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +} diff --git a/web/package.json b/web/package.json new file mode 100644 index 0000000000..91172cca5f --- /dev/null +++ b/web/package.json @@ -0,0 +1,28 @@ +{ + "name": "qa", + "version": "0.1.0", + "private": true, + "scripts": { + "dev": "next dev", + "build": "next build", + "start": "next start", + "lint": "next lint" + }, + "dependencies": { + "@phosphor-icons/react": "^2.0.8", + "@types/node": "18.15.11", + "@types/react": "18.0.32", + "@types/react-dom": "18.0.11", + "autoprefixer": "^10.4.14", + "eslint": "8.37.0", + "eslint-config-next": "13.2.4", + "formik": "^2.2.9", + "next": "13.2.4", + "postcss": "^8.4.23", + "react": "18.2.0", + "react-dom": "18.2.0", + "tailwindcss": "^3.3.1", + "typescript": "5.0.3", + "yup": "^1.1.1" + } +} diff --git a/web/postcss.config.js b/web/postcss.config.js new file mode 100644 index 0000000000..12a703d900 --- /dev/null +++ b/web/postcss.config.js @@ -0,0 +1,6 @@ +module.exports = { + plugins: { + tailwindcss: {}, + autoprefixer: {}, + }, +}; diff --git a/web/public/next.svg b/web/public/next.svg new file mode 100644 index 0000000000..5174b28c56 --- /dev/null +++ b/web/public/next.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/web/public/thirteen.svg b/web/public/thirteen.svg new file mode 100644 index 0000000000..8977c1bd12 --- /dev/null +++ b/web/public/thirteen.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/web/public/vercel.svg b/web/public/vercel.svg new file mode 100644 index 0000000000..d2f8422273 --- /dev/null +++ b/web/public/vercel.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/web/src/app/admin/connectors/page.tsx b/web/src/app/admin/connectors/page.tsx new file mode 100644 index 0000000000..521576fa9c --- /dev/null +++ b/web/src/app/admin/connectors/page.tsx @@ -0,0 +1,22 @@ +"use client"; + +import { Inter } from "next/font/google"; +import { Header } from "@/components/Header"; +import { SlackForm } from "@/components/admin/connectors/SlackForm"; + +const inter = Inter({ subsets: ["latin"] }); + +export default function Home() { + return ( + <> +
+
+
+

Slack

+
+

Config

+ console.log(success)}/> +
+ + ); +} diff --git a/web/src/app/favicon.ico b/web/src/app/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..718d6fea4835ec2d246af9800eddb7ffb276240c GIT binary patch literal 25931 zcmeHv30#a{`}aL_*G&7qml|y<+KVaDM2m#dVr!KsA!#An?kSQM(q<_dDNCpjEux83 zLb9Z^XxbDl(w>%i@8hT6>)&Gu{h#Oeyszu?xtw#Zb1mO{pgX9699l+Qppw7jXaYf~-84xW z)w4x8?=youko|}Vr~(D$UXIbiXABHh`p1?nn8Po~fxRJv}|0e(BPs|G`(TT%kKVJAdg5*Z|x0leQq0 zkdUBvb#>9F()jo|T~kx@OM8$9wzs~t2l;K=woNssA3l6|sx2r3+kdfVW@e^8e*E}v zA1y5{bRi+3Z`uD3{F7LgFJDdvm;nJilkzDku>BwXH(8ItVCXk*-lSJnR?-2UN%hJ){&rlvg`CDTj z)Bzo!3v7Ou#83zEDEFcKt(f1E0~=rqeEbTnMvWR#{+9pg%7G8y>u1OVRUSoox-ovF z2Ydma(;=YuBY(eI|04{hXzZD6_f(v~H;C~y5=DhAC{MMS>2fm~1H_t2$56pc$NH8( z5bH|<)71dV-_oCHIrzrT`2s-5w_+2CM0$95I6X8p^r!gHp+j_gd;9O<1~CEQQGS8) zS9Qh3#p&JM-G8rHekNmKVewU;pJRcTAog68KYo^dRo}(M>36U4Us zfgYWSiHZL3;lpWT=zNAW>Dh#mB!_@Lg%$ms8N-;aPqMn+C2HqZgz&9~Eu z4|Kp<`$q)Uw1R?y(~S>ePdonHxpV1#eSP1B;Ogo+-Pk}6#0GsZZ5!||ev2MGdh}_m z{DeR7?0-1^zVs&`AV6Vt;r3`I`OI_wgs*w=eO%_#7Kepl{B@xiyCANc(l zzIyd4y|c6PXWq9-|KM8(zIk8LPk(>a)zyFWjhT!$HJ$qX1vo@d25W<fvZQ2zUz5WRc(UnFMKHwe1| zWmlB1qdbiA(C0jmnV<}GfbKtmcu^2*P^O?MBLZKt|As~ge8&AAO~2K@zbXelK|4T<{|y4`raF{=72kC2Kn(L4YyenWgrPiv z@^mr$t{#X5VuIMeL!7Ab6_kG$&#&5p*Z{+?5U|TZ`B!7llpVmp@skYz&n^8QfPJzL z0G6K_OJM9x+Wu2gfN45phANGt{7=C>i34CV{Xqlx(fWpeAoj^N0Biu`w+MVcCUyU* zDZuzO0>4Z6fbu^T_arWW5n!E45vX8N=bxTVeFoep_G#VmNlQzAI_KTIc{6>c+04vr zx@W}zE5JNSU>!THJ{J=cqjz+4{L4A{Ob9$ZJ*S1?Ggg3klFp!+Y1@K+pK1DqI|_gq z5ZDXVpge8-cs!o|;K73#YXZ3AShj50wBvuq3NTOZ`M&qtjj#GOFfgExjg8Gn8>Vq5 z`85n+9|!iLCZF5$HJ$Iu($dm?8~-ofu}tEc+-pyke=3!im#6pk_Wo8IA|fJwD&~~F zc16osQ)EBo58U7XDuMexaPRjU@h8tXe%S{fA0NH3vGJFhuyyO!Uyl2^&EOpX{9As0 zWj+P>{@}jxH)8|r;2HdupP!vie{sJ28b&bo!8`D^x}TE$%zXNb^X1p@0PJ86`dZyj z%ce7*{^oo+6%&~I!8hQy-vQ7E)0t0ybH4l%KltWOo~8cO`T=157JqL(oq_rC%ea&4 z2NcTJe-HgFjNg-gZ$6!Y`SMHrlj}Etf7?r!zQTPPSv}{so2e>Fjs1{gzk~LGeesX%r(Lh6rbhSo_n)@@G-FTQy93;l#E)hgP@d_SGvyCp0~o(Y;Ee8{ zdVUDbHm5`2taPUOY^MAGOw*>=s7=Gst=D+p+2yON!0%Hk` zz5mAhyT4lS*T3LS^WSxUy86q&GnoHxzQ6vm8)VS}_zuqG?+3td68_x;etQAdu@sc6 zQJ&5|4(I?~3d-QOAODHpZ=hlSg(lBZ!JZWCtHHSj`0Wh93-Uk)_S%zsJ~aD>{`A0~ z9{AG(e|q3g5B%wYKRxiL2Y$8(4w6bzchKuloQW#e&S3n+P- z8!ds-%f;TJ1>)v)##>gd{PdS2Oc3VaR`fr=`O8QIO(6(N!A?pr5C#6fc~Ge@N%Vvu zaoAX2&(a6eWy_q&UwOhU)|P3J0Qc%OdhzW=F4D|pt0E4osw;%<%Dn58hAWD^XnZD= z>9~H(3bmLtxpF?a7su6J7M*x1By7YSUbxGi)Ot0P77`}P3{)&5Un{KD?`-e?r21!4vTTnN(4Y6Lin?UkSM z`MXCTC1@4A4~mvz%Rh2&EwY))LeoT=*`tMoqcEXI>TZU9WTP#l?uFv+@Dn~b(>xh2 z;>B?;Tz2SR&KVb>vGiBSB`@U7VIWFSo=LDSb9F{GF^DbmWAfpms8Sx9OX4CnBJca3 zlj9(x!dIjN?OG1X4l*imJNvRCk}F%!?SOfiOq5y^mZW)jFL@a|r-@d#f7 z2gmU8L3IZq0ynIws=}~m^#@&C%J6QFo~Mo4V`>v7MI-_!EBMMtb%_M&kvAaN)@ZVw z+`toz&WG#HkWDjnZE!6nk{e-oFdL^$YnbOCN}JC&{$#$O27@|Tn-skXr)2ml2~O!5 zX+gYoxhoc7qoU?C^3~&!U?kRFtnSEecWuH0B0OvLodgUAi}8p1 zrO6RSXHH}DMc$&|?D004DiOVMHV8kXCP@7NKB zgaZq^^O<7PoKEp72kby@W0Z!Y*Ay{&vfg#C&gG@YVR9g?FEocMUi1gSN$+V+ayF45{a zuDZDTN}mS|;BO%gEf}pjBfN2-gIrU#G5~cucA;dokXW89%>AyXJJI z9X4UlIWA|ZYHgbI z5?oFk@A=Ik7lrEQPDH!H+b`7_Y~aDb_qa=B2^Y&Ow41cU=4WDd40dp5(QS-WMN-=Y z9g;6_-JdNU;|6cPwf$ak*aJIcwL@1n$#l~zi{c{EW?T;DaW*E8DYq?Umtz{nJ&w-M zEMyTDrC&9K$d|kZe2#ws6)L=7K+{ zQw{XnV6UC$6-rW0emqm8wJoeZK)wJIcV?dST}Z;G0Arq{dVDu0&4kd%N!3F1*;*pW zR&qUiFzK=@44#QGw7k1`3t_d8&*kBV->O##t|tonFc2YWrL7_eqg+=+k;!F-`^b8> z#KWCE8%u4k@EprxqiV$VmmtiWxDLgnGu$Vs<8rppV5EajBXL4nyyZM$SWVm!wnCj-B!Wjqj5-5dNXukI2$$|Bu3Lrw}z65Lc=1G z^-#WuQOj$hwNGG?*CM_TO8Bg-1+qc>J7k5c51U8g?ZU5n?HYor;~JIjoWH-G>AoUP ztrWWLbRNqIjW#RT*WqZgPJXU7C)VaW5}MiijYbABmzoru6EmQ*N8cVK7a3|aOB#O& zBl8JY2WKfmj;h#Q!pN%9o@VNLv{OUL?rixHwOZuvX7{IJ{(EdPpuVFoQqIOa7giLVkBOKL@^smUA!tZ1CKRK}#SSM)iQHk)*R~?M!qkCruaS!#oIL1c z?J;U~&FfH#*98^G?i}pA{ z9Jg36t4=%6mhY(quYq*vSxptes9qy|7xSlH?G=S@>u>Ebe;|LVhs~@+06N<4CViBk zUiY$thvX;>Tby6z9Y1edAMQaiH zm^r3v#$Q#2T=X>bsY#D%s!bhs^M9PMAcHbCc0FMHV{u-dwlL;a1eJ63v5U*?Q_8JO zT#50!RD619#j_Uf))0ooADz~*9&lN!bBDRUgE>Vud-i5ck%vT=r^yD*^?Mp@Q^v+V zG#-?gKlr}Eeqifb{|So?HM&g91P8|av8hQoCmQXkd?7wIJwb z_^v8bbg`SAn{I*4bH$u(RZ6*xUhuA~hc=8czK8SHEKTzSxgbwi~9(OqJB&gwb^l4+m`k*Q;_?>Y-APi1{k zAHQ)P)G)f|AyjSgcCFps)Fh6Bca*Xznq36!pV6Az&m{O8$wGFD? zY&O*3*J0;_EqM#jh6^gMQKpXV?#1?>$ml1xvh8nSN>-?H=V;nJIwB07YX$e6vLxH( zqYwQ>qxwR(i4f)DLd)-$P>T-no_c!LsN@)8`e;W@)-Hj0>nJ-}Kla4-ZdPJzI&Mce zv)V_j;(3ERN3_@I$N<^|4Lf`B;8n+bX@bHbcZTopEmDI*Jfl)-pFDvo6svPRoo@(x z);_{lY<;);XzT`dBFpRmGrr}z5u1=pC^S-{ce6iXQlLGcItwJ^mZx{m$&DA_oEZ)B{_bYPq-HA zcH8WGoBG(aBU_j)vEy+_71T34@4dmSg!|M8Vf92Zj6WH7Q7t#OHQqWgFE3ARt+%!T z?oLovLVlnf?2c7pTc)~cc^($_8nyKwsN`RA-23ed3sdj(ys%pjjM+9JrctL;dy8a( z@en&CQmnV(()bu|Y%G1-4a(6x{aLytn$T-;(&{QIJB9vMox11U-1HpD@d(QkaJdEb zG{)+6Dos_L+O3NpWo^=gR?evp|CqEG?L&Ut#D*KLaRFOgOEK(Kq1@!EGcTfo+%A&I z=dLbB+d$u{sh?u)xP{PF8L%;YPPW53+@{>5W=Jt#wQpN;0_HYdw1{ksf_XhO4#2F= zyPx6Lx2<92L-;L5PD`zn6zwIH`Jk($?Qw({erA$^bC;q33hv!d!>%wRhj# zal^hk+WGNg;rJtb-EB(?czvOM=H7dl=vblBwAv>}%1@{}mnpUznfq1cE^sgsL0*4I zJ##!*B?=vI_OEVis5o+_IwMIRrpQyT_Sq~ZU%oY7c5JMIADzpD!Upz9h@iWg_>>~j zOLS;wp^i$-E?4<_cp?RiS%Rd?i;f*mOz=~(&3lo<=@(nR!_Rqiprh@weZlL!t#NCc zO!QTcInq|%#>OVgobj{~ixEUec`E25zJ~*DofsQdzIa@5^nOXj2T;8O`l--(QyU^$t?TGY^7#&FQ+2SS3B#qK*k3`ye?8jUYSajE5iBbJls75CCc(m3dk{t?- zopcER9{Z?TC)mk~gpi^kbbu>b-+a{m#8-y2^p$ka4n60w;Sc2}HMf<8JUvhCL0B&Btk)T`ctE$*qNW8L$`7!r^9T+>=<=2qaq-;ll2{`{Rg zc5a0ZUI$oG&j-qVOuKa=*v4aY#IsoM+1|c4Z)<}lEDvy;5huB@1RJPquU2U*U-;gu z=En2m+qjBzR#DEJDO`WU)hdd{Vj%^0V*KoyZ|5lzV87&g_j~NCjwv0uQVqXOb*QrQ zy|Qn`hxx(58c70$E;L(X0uZZ72M1!6oeg)(cdKO ze0gDaTz+ohR-#d)NbAH4x{I(21yjwvBQfmpLu$)|m{XolbgF!pmsqJ#D}(ylp6uC> z{bqtcI#hT#HW=wl7>p!38sKsJ`r8}lt-q%Keqy%u(xk=yiIJiUw6|5IvkS+#?JTBl z8H5(Q?l#wzazujH!8o>1xtn8#_w+397*_cy8!pQGP%K(Ga3pAjsaTbbXJlQF_+m+-UpUUent@xM zg%jqLUExj~o^vQ3Gl*>wh=_gOr2*|U64_iXb+-111aH}$TjeajM+I20xw(((>fej-@CIz4S1pi$(#}P7`4({6QS2CaQS4NPENDp>sAqD z$bH4KGzXGffkJ7R>V>)>tC)uax{UsN*dbeNC*v}#8Y#OWYwL4t$ePR?VTyIs!wea+ z5Urmc)X|^`MG~*dS6pGSbU+gPJoq*^a=_>$n4|P^w$sMBBy@f*Z^Jg6?n5?oId6f{ z$LW4M|4m502z0t7g<#Bx%X;9<=)smFolV&(V^(7Cv2-sxbxopQ!)*#ZRhTBpx1)Fc zNm1T%bONzv6@#|dz(w02AH8OXe>kQ#1FMCzO}2J_mST)+ExmBr9cva-@?;wnmWMOk z{3_~EX_xadgJGv&H@zK_8{(x84`}+c?oSBX*Ge3VdfTt&F}yCpFP?CpW+BE^cWY0^ zb&uBN!Ja3UzYHK-CTyA5=L zEMW{l3Usky#ly=7px648W31UNV@K)&Ub&zP1c7%)`{);I4b0Q<)B}3;NMG2JH=X$U zfIW4)4n9ZM`-yRj67I)YSLDK)qfUJ_ij}a#aZN~9EXrh8eZY2&=uY%2N0UFF7<~%M zsB8=erOWZ>Ct_#^tHZ|*q`H;A)5;ycw*IcmVxi8_0Xk}aJA^ath+E;xg!x+As(M#0=)3!NJR6H&9+zd#iP(m0PIW8$ z1Y^VX`>jm`W!=WpF*{ioM?C9`yOR>@0q=u7o>BP-eSHqCgMDj!2anwH?s%i2p+Q7D zzszIf5XJpE)IG4;d_(La-xenmF(tgAxK`Y4sQ}BSJEPs6N_U2vI{8=0C_F?@7<(G; zo$~G=8p+076G;`}>{MQ>t>7cm=zGtfbdDXm6||jUU|?X?CaE?(<6bKDYKeHlz}DA8 zXT={X=yp_R;HfJ9h%?eWvQ!dRgz&Su*JfNt!Wu>|XfU&68iRikRrHRW|ZxzRR^`eIGt zIeiDgVS>IeExKVRWW8-=A=yA`}`)ZkWBrZD`hpWIxBGkh&f#ijr449~m`j6{4jiJ*C!oVA8ZC?$1RM#K(_b zL9TW)kN*Y4%^-qPpMP7d4)o?Nk#>aoYHT(*g)qmRUb?**F@pnNiy6Fv9rEiUqD(^O zzyS?nBrX63BTRYduaG(0VVG2yJRe%o&rVrLjbxTaAFTd8s;<<@Qs>u(<193R8>}2_ zuwp{7;H2a*X7_jryzriZXMg?bTuegABb^87@SsKkr2)0Gyiax8KQWstw^v#ix45EVrcEhr>!NMhprl$InQMzjSFH54x5k9qHc`@9uKQzvL4ihcq{^B zPrVR=o_ic%Y>6&rMN)hTZsI7I<3&`#(nl+3y3ys9A~&^=4?PL&nd8)`OfG#n zwAMN$1&>K++c{^|7<4P=2y(B{jJsQ0a#U;HTo4ZmWZYvI{+s;Td{Yzem%0*k#)vjpB zia;J&>}ICate44SFYY3vEelqStQWFihx%^vQ@Do(sOy7yR2@WNv7Y9I^yL=nZr3mb zXKV5t@=?-Sk|b{XMhA7ZGB@2hqsx}4xwCW!in#C zI@}scZlr3-NFJ@NFaJlhyfcw{k^vvtGl`N9xSo**rDW4S}i zM9{fMPWo%4wYDG~BZ18BD+}h|GQKc-g^{++3MY>}W_uq7jGHx{mwE9fZiPCoxN$+7 zrODGGJrOkcPQUB(FD5aoS4g~7#6NR^ma7-!>mHuJfY5kTe6PpNNKC9GGRiu^L31uG z$7v`*JknQHsYB!Tm_W{a32TM099djW%5e+j0Ve_ct}IM>XLF1Ap+YvcrLV=|CKo6S zb+9Nl3_YdKP6%Cxy@6TxZ>;4&nTneadr z_ES90ydCev)LV!dN=#(*f}|ZORFdvkYBni^aLbUk>BajeWIOcmHP#8S)*2U~QKI%S zyrLmtPqb&TphJ;>yAxri#;{uyk`JJqODDw%(Z=2`1uc}br^V%>j!gS)D*q*f_-qf8&D;W1dJgQMlaH5er zN2U<%Smb7==vE}dDI8K7cKz!vs^73o9f>2sgiTzWcwY|BMYHH5%Vn7#kiw&eItCqa zIkR2~Q}>X=Ar8W|^Ms41Fm8o6IB2_j60eOeBB1Br!boW7JnoeX6Gs)?7rW0^5psc- zjS16yb>dFn>KPOF;imD}e!enuIniFzv}n$m2#gCCv4jM#ArwlzZ$7@9&XkFxZ4n!V zj3dyiwW4Ki2QG{@i>yuZXQizw_OkZI^-3otXC{!(lUpJF33gI60ak;Uqitp74|B6I zgg{b=Iz}WkhCGj1M=hu4#Aw173YxIVbISaoc z-nLZC*6Tgivd5V`K%GxhBsp@SUU60-rfc$=wb>zdJzXS&-5(NRRodFk;Kxk!S(O(a0e7oY=E( zAyS;Ow?6Q&XA+cnkCb{28_1N8H#?J!*$MmIwLq^*T_9-z^&UE@A(z9oGYtFy6EZef LrJugUA?W`A8`#=m literal 0 HcmV?d00001 diff --git a/web/src/app/globals.css b/web/src/app/globals.css new file mode 100644 index 0000000000..b5c61c9567 --- /dev/null +++ b/web/src/app/globals.css @@ -0,0 +1,3 @@ +@tailwind base; +@tailwind components; +@tailwind utilities; diff --git a/web/src/app/layout.tsx b/web/src/app/layout.tsx new file mode 100644 index 0000000000..79df0237e7 --- /dev/null +++ b/web/src/app/layout.tsx @@ -0,0 +1,18 @@ +import "./globals.css"; + +export const metadata = { + title: "Create Next App", + description: "Generated by create next app", +}; + +export default function RootLayout({ + children, +}: { + children: React.ReactNode; +}) { + return ( + + {children} + + ); +} diff --git a/web/src/app/page.tsx b/web/src/app/page.tsx new file mode 100644 index 0000000000..01042c9fdf --- /dev/null +++ b/web/src/app/page.tsx @@ -0,0 +1,16 @@ +import { Inter } from "next/font/google"; +import { SearchSection } from "@/components/SearchBar"; +import { Header } from "@/components/Header"; + +const inter = Inter({ subsets: ["latin"] }); + +export default function Home() { + return ( + <> +
+
+ +
+ + ); +} diff --git a/web/src/components/Header.tsx b/web/src/components/Header.tsx new file mode 100644 index 0000000000..73f2b7f8ee --- /dev/null +++ b/web/src/components/Header.tsx @@ -0,0 +1,12 @@ +import React from "react"; +import "tailwindcss/tailwind.css"; + +export const Header: React.FC = () => { + return ( +
+
+

danswer 💃

+
+
+ ); +}; diff --git a/web/src/components/SearchBar.tsx b/web/src/components/SearchBar.tsx new file mode 100644 index 0000000000..3b6975b987 --- /dev/null +++ b/web/src/components/SearchBar.tsx @@ -0,0 +1,93 @@ +"use client"; + +import React, { useState, KeyboardEvent, ChangeEvent } from "react"; +import { MagnifyingGlass } from "@phosphor-icons/react"; +import "tailwindcss/tailwind.css"; +import { SearchResultsDisplay } from "./SearchResultsDisplay"; +import { SearchResponse } from "./types"; + +const BACKEND_URL = + process.env.NEXT_PUBLIC_BACKEND_URL || "http://localhost:8000"; // "http://servi-lb8a1-jhqpsz92kbm2-1605938866.us-east-2.elb.amazonaws.com/direct-qa"; + +const searchRequest = async (query: string): Promise => { + const response = await fetch(BACKEND_URL + "/direct-qa", { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + query: query, + collection: "semantic_search", + }), + }); + return response.json(); +}; + +export const SearchSection: React.FC<{}> = () => { + const [answer, setAnswer] = useState(); + const [isFetching, setIsFetching] = useState(false); + + return ( + <> + { + setIsFetching(true); + searchRequest(query).then((response) => { + setIsFetching(false); + setAnswer(response); + }); + }} + /> + + + ); +}; + +interface SearchBarProps { + onSearch: (searchTerm: string) => void; +} + +const SearchBar: React.FC = ({ onSearch }) => { + const [searchTerm, setSearchTerm] = useState(""); + + const handleChange = (event: ChangeEvent) => { + const target = event.target; + setSearchTerm(target.value); + + // Reset the textarea height + target.style.height = "24px"; + + // Calculate the new height based on scrollHeight + const newHeight = target.scrollHeight; + + // Apply the new height + target.style.height = `${newHeight}px`; + }; + + // const handleSubmit = (event: KeyboardEvent) => { + // onSearch(searchTerm); + // }; + + const handleKeyDown = (event: KeyboardEvent) => { + if (event.key === "Enter" && !event.shiftKey) { + onSearch(searchTerm); + event.preventDefault(); + } + }; + + return ( +
+
+ +